TypelessStub.h

Go to the documentation of this file.

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

   begin                : Sun Aug 22 2004
   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_TypelessStub_H
#define MOCKPP_TypelessStub_H


#include <mockpp/mockpp.h> // always first

#include <mockpp/stub/Stub.h>

#include <mockpp/SelfDescribing.h>


MOCKPP_NS_START


template <typename R>  // Returntype
class TypelessStub : public SelfDescribing
{
  public:

    typedef AutoPointer<TypelessStub<R> > AP;  

    virtual ~TypelessStub()
    {}

    virtual R typelessInvoke() = 0;

    virtual String describeTo( String &buffer ) const = 0;
};


template <typename R,  // Returntype
          typename I>  // Invocation
class TypelessStubAdapterBase : public Stub<R, I>
{
  protected:

    TypelessStubAdapterBase(typename TypelessStub<R>::AP tm, bool in_delete)
      : stubber(tm.release())
      , do_delete(in_delete)
    {}

    virtual ~TypelessStubAdapterBase()
    {
      if (do_delete)
        delete stubber;
      stubber = 0;
    }

  public:

    virtual String describeTo( String &buffer ) const
    {
      return stubber->describeTo(buffer);
    }

  protected:

    TypelessStub<R> *stubber;        
    bool             do_delete;      
};


template <typename R,  // Returntype
          typename I>  // Invocation
class TypelessStubAdapter : public TypelessStubAdapterBase<R, I>
{
  public:

    TypelessStubAdapter(typename TypelessStub<R>::AP tm, bool in_delete = true)
      : TypelessStubAdapterBase<R, I>(tm, in_delete)
    {}

    virtual R invoke( const I &invocation )
    {
      MOCKPP_UNUSED(invocation);
      return this->stubber->typelessInvoke();
    }
};


#ifndef MOCKPP_PTI_WEAKNESS // Partial Template Instantiation Weakness


template <typename I>  // Invocation
class TypelessStubAdapter<void, I> : public TypelessStubAdapterBase<void, I>
{
  public:

    TypelessStubAdapter(typename TypelessStub<void>::AP tm, bool in_delete = true)
      : TypelessStubAdapterBase<void, I>(tm, in_delete)
    {}

    virtual void invoke( const I &invocation )
    {
      MOCKPP_UNUSED(invocation);
      this->stubber->typelessInvoke();
    }
};


#define MOCKPP_TYPELESSSTUBADAPTER_PTI_IMPL(I)
#define MOCKPP_TYPELESSSTUBADAPTER_PTI_DECL(I)


#else // MOCKPP_PTI_WEAKNESS Partial Template Instantiation Weakness


#define MOCKPP_TYPELESSSTUBADAPTER_PTI_DECL(I) \
MOCKPP_NS_START \
template<> \
void MOCKPP_NS::TypelessStubAdapter<void, I >; \
}


#define MOCKPP_TYPELESSSTUBADAPTER_PTI_IMPL(I) \
MOCKPP_NS_START \
template<> \
class TypelessStubAdapter<void, I > : public TypelessStubAdapterBase<void, I > \
{ \
 public: \
  TypelessStubAdapter<void, I >(TypelessStub<void>::AP tm, bool in_delete = true) \
   : TypelessStubAdapterBase<void, I >(tm, in_delete) \
  {} \
  \
  void invoke( const I &invocation) \
  { \
   MOCKPP_UNUSED(invocation); \
   this->stubber->typelessInvoke(); \
  } \
}; \
MOCKPP_NS_END


#endif // MOCKPP_PTI_WEAKNESS

MOCKPP_NS_END


#endif // MOCKPP_TypelessStub_H

---