callback.h

Go to the documentation of this file.

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


#pragma once

#include <functional>


/*
usage:

A Callback is an object that is created to hold a function and can called at a later time.  It can either reference 
a static class function, global function, or class member function on an object.  

The template Callback class is typedef to a specific function signature (i.e: return( parameter values)) by 
declaring the function signature in the callback template

typedef Callback<void(int, double)> FooCallback;

To create a Callback of a static function, you use the function address:

void foo(int a, double b) {...}

FooCallback f(foo);

to create a Callback of a member function, you need to use the object's pointer and a member function pointer to a function
with the same signature:

class Foo
{
   void doStuff(int a, double b) {...}
}

Foo a;

FooCallback f(&a, &Foo::doStuff);

At some other point in the code, you can invoke the callbacks as though the delegate were a function

int a =1;
double b = 20.0;

f(a, b);

*/

namespace Legion
{
   //forward definitions of the function capture classes used in the delegate
   template <typename Ret, typename... Params> class AbstractFunctionCapture;
   template <typename Ret, typename... Params> class StaticFunctionCapture;
   template <typename Ret, typename T, typename Method, typename... Params> class MethodCapture;
   template <typename Ret, typename... Params> class StdFunctionCapture;

   template<typename T> class Callback;
   template <typename Ret, typename... Params>
   class Callback<Ret (Params...)>
   {
   private:
      AbstractFunctionCapture<Ret, Params...>* myFunctionCapture;
      int myType;

   public:
      Callback()
         :myFunctionCapture(0)
         , myType(0)
      {}

      Callback(Ret(*func)(Params...))
         :myFunctionCapture(new StaticFunctionCapture<Ret, Params...>(func))
         , myType(1)
      {}

      template <typename T, typename Method>
      Callback(T *object, Method method)
         : myFunctionCapture(new MethodCapture<Ret, T, Method, Params...>(object, method))
         , myType(2)
      {}

      Callback(std::function<Ret(Params...)>& stdFunc)
         : myFunctionCapture(new StdFunctionCapture<Ret, Params...>(stdFunc))
         , myType(3)
      {}


      Callback(const Callback& orig)
      {
         if (orig.myFunctionCapture)
         {
            myFunctionCapture = orig.myFunctionCapture->clone();
         }
         else
         {
            myFunctionCapture = 0;
         }

         myType = orig.myType;
      }

      Callback& operator=(const Callback& orig)
      {
         if (this != &orig)
         {
            if (orig.myFunctionCapture)
            {
               myFunctionCapture = orig.myFunctionCapture->clone();
            }
            else
            {
               myFunctionCapture = 0;
            }

            myType = orig.myType;
         }

         return *this;
      }

      ~Callback(void) { delete myFunctionCapture; }

      bool isValid() { return myFunctionCapture != 0; }

      Ret operator()(Params... params) const
      {
         return myFunctionCapture->invoke(params...);
      }

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

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

      bool operator!=(const Callback& rhs) const
      {
         return !(*this == rhs);
      }
   };


   //--------------------------------Implementation details of capturing a static function or member function-------------------------------------------------------


   template <typename Ret, typename... Params>
   class AbstractFunctionCapture
   {
   public:
      virtual Ret invoke(Params... params) const = 0;
      virtual AbstractFunctionCapture* clone() const = 0;

      virtual bool operator==(const AbstractFunctionCapture<Ret, Params...>& rhs) const = 0;

      virtual bool operator!=(const AbstractFunctionCapture<Ret, Params...>& rhs) const
      {
         return !(*this == rhs);
      }
   };


   template <typename Ret, typename... Params>
   class StaticFunctionCapture : public AbstractFunctionCapture<Ret, Params...>
   {
   private:
      Ret(*myFunction)(Params... params);

   public:
      StaticFunctionCapture(Ret(*func)(Params... params))
         : myFunction(func)
      {}

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

      StaticFunctionCapture& operator=(const StaticFunctionCapture& orig)
      {
         if (this != &orig)
         {
            myFunction = orig.myFunction;
         }

         return *this;
      }

      StaticFunctionCapture* clone() const
      {
         StaticFunctionCapture* nc = new StaticFunctionCapture(myFunction);
         return nc;
      }

      Ret invoke(Params... params) const
      {
         return (*myFunction)(params...);
      }

      bool operator==(const AbstractFunctionCapture<Ret, Params...>& rhs) const
      {
         StaticFunctionCapture* rhsp = (StaticFunctionCapture*)&rhs;
         return myFunction == rhsp->myFunction;
      }
   };


   template <typename Ret, typename T, typename Method, typename... Params>
   class MethodCapture : public AbstractFunctionCapture<Ret, Params...>
   {
   private:
      void* myObject;
      Method myMethod;

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

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

      MethodCapture* clone() const
      {
         MethodCapture* nc = new MethodCapture(myObject, myMethod);
         return nc;
      }

      MethodCapture& operator=(const MethodCapture& orig)
      {
         if (this != &orig)
         {
            myObject = orig.myObject;
            myMethod = orig.myMethod;
         }

         return *this;
      }

      Ret invoke(Params... params) const
      {
         T *obj = static_cast<T *>(myObject);
         return (obj->*myMethod)(params...);
      }

      bool operator==(const AbstractFunctionCapture<Ret, Params...>& rhs) const
      {
         MethodCapture* rhsp = (MethodCapture*)&rhs;
         return (myObject == rhsp->myObject) && (myMethod == rhsp->myMethod);
      }
   };


   template <typename Ret, typename... Params>
   class StdFunctionCapture : public AbstractFunctionCapture<Ret, Params...>
   {
   private:
      std::function<Ret(Params...)> myFunc;

   public:
      StdFunctionCapture(const std::function<Ret(Params...)>& func)
         : myFunc(func)
      {}

      StdFunctionCapture(const StdFunctionCapture& orig)
      {
         myFunc = orig.myFunc;
      }

      StdFunctionCapture* clone() const
      {
         StdFunctionCapture* nc = new StdFunctionCapture(myFunc);
         return nc;
      }

      StdFunctionCapture& operator=(const StdFunctionCapture& orig)
      {
         if (this != &orig)
         {
            myFunc = orig.myFunc;
         }

         return *this;
      }

      Ret invoke(Params... params) const
      {
         return myFunc(params...);
      }

      bool operator==(const AbstractFunctionCapture<Ret, Params...>& rhs) const
      {
         StdFunctionCapture* rhsp = (StdFunctionCapture*)&rhs;
         return *(long*)(char*)(&myFunc) == *(long*)(char*)(&rhsp->myFunc);
      }
   };
}