ResponseVector2.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_ResponseVector2_H
#define MOCKPP_ResponseVector2_H

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


MOCKPP_NS_START


template <typename P1, typename P2>
class ResponseThrowableVector2 : public ResponseVectorBase
{
  public:

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

    virtual ~ResponseThrowableVector2()
    {
      reset();
    }

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

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

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

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

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

    bool find(Throwable * &throwable, const P1 &p1, const P2 &p2)
    {
       for (unsigned i = 0; i < t1vec.size(); ++i)
         if (   counter[i] > 0
             && t1vec[i]->eval(p1)
             && t2vec[i]->eval(p2)
            )
         {
           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; 
    MOCKPP_STL::vector<Constraint<P2>*>       t2vec; 
};


template <typename R, typename P1, typename P2>
class ResponseVector2  : public ResponseThrowableVector2<P1, P2>
{
  public:

    ResponseVector2(const String &aName, VerifiableList *parent)
      : ResponseThrowableVector2<P1, P2>(aName, parent)
    {}

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

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

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

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

    void reset()
    {
      ResponseThrowableVector2<P1, P2>::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, const P2 &p2)
    {
      return ResponseThrowableVector2<P1, P2>::find(throwable, p1, p2);
    }
#else
    using ResponseThrowableVector2<P1, P2>::find;
#endif

    bool find(R &r, const P1 &p1, const P2 &p2)
    {
       for (unsigned i = 0; i < this->t1vec.size(); ++i)
         if (   this->counter[i] > 0
             && this->t1vec[i]->eval(p1)
             && this->t2vec[i]->eval(p2)
            )
         {
           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_ResponseVector2_H

---