ResponseVector1.h

Go to the documentation of this file.

/**************************************************************************

   begin                : Sat Feb 15 2003
   copyright            : (C) 2002-2010 by Ewald Arnold
   email                : mockpp at ewald-arnold dot de

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as
   published by the Free Software Foundation; either version 2 of the License,
   or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 **/

#ifndef MOCKPP_ResponseVector1_H
#define MOCKPP_ResponseVector1_H

#include <mockpp/constraint/ConstraintHolder.h>
#include <mockpp/constraint/IsEqual.h>
#include <mockpp/visiting/VisitableMockObject_template.h>


MOCKPP_NS_START


template <typename P1>
class ResponseThrowableVector1 : public ResponseVectorBase
{
  public:

    ResponseThrowableVector1(const String &aName, VerifiableList *parent)
      : ResponseVectorBase(aName, parent)
    {}

    virtual ~ResponseThrowableVector1()
    {
      reset();
    }

    void add(Throwable *throwable, const P1 &p1, unsigned count)
    {
      const ConstraintHolder<P1> h1 = new IsEqual<P1>(p1);
      add(throwable, h1, count);
    }

    void add(Throwable *throwable,
             const ConstraintHolder<P1> &p1,
             unsigned count)
    {
      counter.push_back(count);
      tvec.push_back(throwable);
      typename MOCKPP_NS::Constraint<P1>::AP cons1 (p1);
      t1vec.push_back(cons1.release());
    }

    void reset()
    {
      counter.clear();
      tvec.reset();

      for (unsigned i1 = 0; i1 < t1vec.size(); ++i1)
        delete t1vec[i1];
      t1vec.clear();
    }

    bool find(Throwable * &throwable, const P1 &p1)
    {
       for (unsigned i = 0; i < t1vec.size(); ++i)
         if (   counter[i] > 0
             && t1vec[i]->eval(p1)
            )
         {
           if (tvec.at(i) == 0)
             return false;

           if (counter[i] != MOCKPP_UNLIMITED)
             --counter[i];

           throwable = tvec.at(i);
           return true;
         }
       return false;
    }

  protected:

    MOCKPP_STL::vector<Constraint<P1>*>       t1vec; 
};


template <typename R, typename P1>
class ResponseVector1  : public ResponseThrowableVector1<P1>
{
  public:

    ResponseVector1(const String &aName, VerifiableList *parent)
      : ResponseThrowableVector1<P1>(aName, parent)
    {}

    void add(Throwable *throwable, const P1 &p1, unsigned count)
    {
      MOCKPP_ASSERT_TRUE(throwable != 0);
      ResponseThrowableVector1<P1>::add(throwable, p1, count);
      R r;
      rvec.push_back(r);
    }

    void add(Throwable *throwable,
             const ConstraintHolder<P1> &p1,
             unsigned count)
    {
      MOCKPP_ASSERT_TRUE(throwable != 0);
      ResponseThrowableVector1<P1>::add (throwable, p1, count);
      R r;
      rvec.push_back(r);
    }

    void add(const R &r, const P1 &p1, unsigned count)
    {
      ResponseThrowableVector1<P1>::add((Throwable*)0, p1, count);
      rvec.push_back(r);
    }

    void add(const R &r,
             const ConstraintHolder<P1> &p1,
             unsigned count)
    {
      ResponseThrowableVector1<P1>::add((Throwable*)0, p1, count);
      rvec.push_back(r);
    }

    void reset()
    {
      ResponseThrowableVector1<P1>::reset();
      rvec.clear();
    }

#if defined(__BORLANDC__) || (__GNUC__ < 3)   // ==> BCB5.5.1 ?? F1004 Internal compiler error at 0x12548c1 with base 0x1200000
    bool find(Throwable * &throwable, const P1 &p1)
    {
      return ResponseThrowableVector1<P1>::find(throwable, p1);
    }
#else
    using ResponseThrowableVector1<P1>::find;
#endif

    bool find(R &r, const P1 &p1)
    {
       for (unsigned i = 0; i < this->t1vec.size(); ++i)
         if (   this->counter[i] > 0
             && this->t1vec[i]->eval(p1)
            )
         {
           if (this->tvec.at(i) != 0)
             return false;

           if (this->counter[i] != MOCKPP_UNLIMITED)
             --this->counter[i];

           r = rvec[i];
           return true;
         }
       return false;
    }

  private:

    MOCKPP_STL::vector<R>        rvec;
};

MOCKPP_NS_END


#endif // MOCKPP_ResponseVector1_H

---