delegate.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 2019 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************************/

#pragma once


namespace makVrf
{


   template <typename Ret, typename Param0>
   class Callback
   {
   public:
      virtual Ret invoke(Param0 param0) = 0;
      virtual Callback* clone() = 0;

      virtual ~Callback() {};

      virtual bool operator==(const Callback<Ret, Param0>& rhs)=0;
      virtual bool operator!=(const Callback<Ret, Param0>& rhs)
      {
         return !(*this==rhs);
      }
   };


   template <typename Ret, typename Param0>
   class StaticFunctionCallback : public Callback<Ret, Param0>
   {
   private:
      Ret (*myFunction)(Param0);

   public:
      StaticFunctionCallback(Ret (*func)(Param0))
         : myFunction(func)
      {}

      StaticFunctionCallback(const StaticFunctionCallback& orig)
      {
         myFunction=orig.myFunction;
      }

      virtual StaticFunctionCallback* clone()
      {
         StaticFunctionCallback* nc=new StaticFunctionCallback( myFunction);
         return nc;
      }

      virtual Ret invoke(Param0 param0)
      {
         return (*myFunction)(param0);
      }

      virtual bool operator==(const Callback<Ret, Param0>& rhs)
      {
         StaticFunctionCallback* rhsp= (StaticFunctionCallback*)&rhs;
         return myFunction == rhsp->myFunction;
      }
   };


   template <typename Ret, typename Param0, typename T, typename Method>
   class MethodCallback : public Callback<Ret, Param0>
   {
   private:
      void* myObject;
      Method myMethod;

   public:
      MethodCallback(void *object, Method method)
         : myObject(object)
         , myMethod(method)
      {}

      MethodCallback(const MethodCallback& orig)
      {
         myObject=orig.myObject;
         myMethod=orig.myMethod;
      }

      virtual MethodCallback* clone()
      {
         MethodCallback* nc=new MethodCallback(myObject, myMethod);
         return nc;
      }

      virtual Ret invoke(Param0 param0)
      {
         T *obj = static_cast<T *>(myObject);
         return (obj->*myMethod)(param0);
      }

      virtual bool operator==(const Callback<Ret, Param0>& rhs)
      {
         MethodCallback* rhsp= (MethodCallback*)&rhs;
         return (myObject == rhsp->myObject) && (myMethod==rhsp->myMethod);
      }
   };

   template <typename Ret, typename Param0>
   class DtDelegate
   {
   private:
      Callback<Ret, Param0>* myCallback;
      bool myIsStatic;

   public:
      DtDelegate()
         :myCallback(0)
         ,myIsStatic(false)
      {}
      DtDelegate(Ret (*func)(Param0))
         :myCallback(new StaticFunctionCallback<Ret, Param0>(func))
         ,myIsStatic(true)
      {}

      template <typename T, typename Method>
      DtDelegate(T *object, Method method)
         :myCallback(new MethodCallback<Ret, Param0, T, Method>(object, method))
         ,myIsStatic(false)
      {}


      DtDelegate(const DtDelegate& orig)
      {
         myCallback=orig.myCallback->clone();
         myIsStatic=orig.myIsStatic;
      }

      DtDelegate& operator=(const DtDelegate& orig)
      {
         if(this!=&orig)
         {
            myCallback=orig.myCallback->clone();
            myIsStatic=orig.myIsStatic;
         }

         return *this;
      }

      virtual ~DtDelegate(void) { delete myCallback; }

      Ret operator()(Param0 param0)
      {
#ifdef _DEBUG
         if(myCallback==0)
            throw "Missing callback";
#endif

         return myCallback->invoke(param0);
      }

      bool operator==(const DtDelegate& rhs)
      {
         if(myIsStatic!=rhs.myIsStatic)
         {
            return false;
         }

         return (*myCallback)==(*(rhs.myCallback));
      }

      bool operator!=(const DtDelegate& rhs)
      {
         return !(*this==rhs);
      }
   };
} //makVrf::