delegate.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*********************************************************************************/
 
#pragma once
 
//! \file delegate.h
//! \brief Defines a lightweight single-parameter delegate system for callback functions
//! \ingroup vreRadarFxShared
//!
//! This delegate implementation provides a lightweight alternative to boost::function+boost::bind
//! for registering and invoking callbacks with a single parameter
 
namespace makRadarFx
{
 
 
//! \brief Abstract base callback class for the delegate system
//! \tparam Ret Return type of the callback function
//! \tparam Param0 Type of the single parameter passed to the callback
//!
//! This abstract base class defines the interface for all callback types
//! used internally by the delegate system
template <typename Ret, typename Param0>
class Callback
{
public:
   //! \brief Invokes the callback with the provided parameter
   //! \param param0 The parameter to pass to the callback
   //! \return Result of the callback invocation
   //!
   //! Pure virtual method that executes the actual callback code
   virtual Ret invoke(Param0 param0) = 0;
 
   //! \brief Creates a copy of this callback
   //! \return Pointer to a newly allocated copy of this callback
   //!
   //! Pure virtual method that implements deep copying of callback objects
   virtual Callback* clone() = 0;
 
   //! \brief Virtual destructor for proper cleanup of derived classes
   virtual ~Callback() {};
 
   //! \brief Equality comparison operator
   //! \param rhs The right-hand side callback to compare with
   //! \return True if the callbacks are functionally equivalent
   //!
   //! Pure virtual method that implements equality comparison between callbacks
   virtual bool operator==(const Callback& rhs) = 0;
 
   //! \brief Inequality comparison operator
   //! \param rhs The right-hand side callback to compare with
   //! \return True if the callbacks are not functionally equivalent
   virtual bool operator!=(const Callback& rhs) { return !(*this == rhs); }
};
 
 
//! \brief Callback implementation for static or global functions
//! \tparam Ret Return type of the callback function
//! \tparam Param0 Type of the single parameter passed to the callback
//!
//! This class implements the Callback interface for global functions or static
//! class methods that accept a single parameter and return a value
template <typename Ret, typename Param0>
class StaticFunctionCallback : public Callback<Ret, Param0>
{
private:
   //! \brief Pointer to the static or global function
   Ret (*myFunction)(Param0);
 
public:
   //! \brief Constructor
   //! \param func Pointer to the static or global function to bind
   StaticFunctionCallback(Ret (*func)(Param0))
      : myFunction(func)
   {
   }
 
   //! \brief Copy constructor
   //! \param orig Original callback to copy from
   StaticFunctionCallback(const StaticFunctionCallback& orig) { myFunction = orig.myFunction; }
 
   //! \brief Creates a copy of this callback
   //! \return Pointer to a newly allocated copy of this callback
   //!
   //! Implements the clone method from the base class for deep copying
   virtual StaticFunctionCallback* clone()
   {
      StaticFunctionCallback* nc = new StaticFunctionCallback(myFunction);
      return nc;
   }
 
   //! \brief Invokes the bound function with the provided parameter
   //! \param param0 The parameter to pass to the function
   //! \return Result of the function invocation
   virtual Ret invoke(Param0 param0) { return (*myFunction)(param0); }
 
   //! \brief Equality comparison operator
   //! \param rhs The right-hand side callback to compare with
   //! \return True if both callbacks reference the same function
   virtual bool operator==(const Callback<Ret, Param0>& rhs)
   {
      StaticFunctionCallback* rhsp = (StaticFunctionCallback*)&rhs;
      return myFunction == rhsp->myFunction;
   }
};
 
 
//! \brief Callback implementation for class member functions
//! \tparam Ret Return type of the callback function
//! \tparam Param0 Type of the single parameter passed to the callback
//! \tparam T Type of the class containing the member function
//! \tparam Method Type of the member function pointer
//!
//! This class implements the Callback interface for non-static class member
//! methods that accept a single parameter and return a value
template <typename Ret, typename Param0, typename T, typename Method>
class MethodCallback : public Callback<Ret, Param0>
{
private:
   //! \brief Pointer to the object instance
   void* myObject;
 
   //! \brief Pointer to the member function
   Method myMethod;
 
public:
   //! \brief Constructor
   //! \param object Pointer to the object instance
   //! \param method Pointer to the member function to bind
   MethodCallback(void* object, Method method)
      : myObject(object)
      , myMethod(method)
   {
   }
 
   //! \brief Copy constructor
   //! \param orig Original callback to copy from
   MethodCallback(const MethodCallback& orig)
   {
      myObject = orig.myObject;
      myMethod = orig.myMethod;
   }
 
   //! \brief Creates a copy of this callback
   //! \return Pointer to a newly allocated copy of this callback
   //!
   //! Implements the clone method from the base class for deep copying
   virtual MethodCallback* clone()
   {
      MethodCallback* nc = new MethodCallback(myObject, myMethod);
      return nc;
   }
 
   //! \brief Invokes the bound member function with the provided parameter
   //! \param param0 The parameter to pass to the member function
   //! \return Result of the member function invocation
   virtual Ret invoke(Param0 param0)
   {
      T* obj = static_cast<T*>(myObject);
      return (obj->*myMethod)(param0);
   }
 
   //! \brief Equality comparison operator
   //! \param rhs The right-hand side callback to compare with
   //! \return True if both callbacks reference the same object and method
   virtual bool operator==(const Callback<Ret, Param0>& rhs)
   {
      MethodCallback* rhsp = (MethodCallback*)&rhs;
      return (myObject == rhsp->myObject) && (myMethod == rhsp->myMethod);
   }
};
 
 
//! \brief Delegate class for binding and invoking callbacks
//! \tparam Ret Return type of the callback function
//! \tparam Param0 Type of the single parameter passed to the callback
//!
//! This class provides a lightweight mechanism for binding either static/global
//! functions or class member functions for invocation at a later time. The delegate
//! supports a single parameter and return value, and provides comparison operators
//! to check if two delegates refer to the same callback.
template <typename Ret, typename Param0>
class DtDelegate
{
private:
   //! \brief Pointer to the underlying callback implementation
   Callback<Ret, Param0>* myCallback;
 
   //! \brief Flag indicating if this is a static/global function callback
   bool myIsStatic;
 
public:
   //! \brief Default constructor
   //!
   //! Creates an empty delegate with no bound callback
   DtDelegate()
      : myCallback(0)
      , myIsStatic(false)
   {
   }
 
   //! \brief Constructor for static or global functions
   //! \param func Pointer to the static or global function to bind
   //!
   //! Creates a delegate bound to a static or global function
   DtDelegate(Ret (*func)(Param0))
      : myCallback(new StaticFunctionCallback<Ret, Param0>(func))
      , myIsStatic(true)
   {
   }
 
   //! \brief Constructor for class member functions
   //! \tparam T Type of the class containing the member function
   //! \tparam Method Type of the member function pointer
   //! \param object Pointer to the object instance
   //! \param method Pointer to the member function to bind
   //!
   //! Creates a delegate bound to a non-static class member function
   template <typename T, typename Method>
   DtDelegate(T* object, Method method)
      : myCallback(new MethodCallback<Ret, Param0, T, Method>(object, method))
      , myIsStatic(false)
   {
   }
 
   //! \brief Copy constructor
   //! \param orig Original delegate to copy from
   //!
   //! Creates a new delegate that is a deep copy of the original
   DtDelegate(const DtDelegate& orig)
   {
      myCallback = orig.myCallback->clone();
      myIsStatic = orig.myIsStatic;
   }
 
   //! \brief Assignment operator
   //! \param orig Original delegate to assign from
   //! \return Reference to this delegate after assignment
   //!
   //! Assigns this delegate to be a deep copy of the original
   DtDelegate& operator=(const DtDelegate& orig)
   {
      if (this != &orig)
      {
         myCallback = orig.myCallback->clone();
         myIsStatic = orig.myIsStatic;
      }
 
      return *this;
   }
 
   //! \brief Virtual destructor
   //!
   //! Cleans up the underlying callback implementation
   virtual ~DtDelegate(void) { delete myCallback; }
 
   //! \brief Function call operator for invoking the delegate
   //! \param param0 The parameter to pass to the callback
   //! \return Result of the callback invocation
   //!
   //! Executes the bound callback with the provided parameter
   Ret operator()(Param0 param0)
   {
#ifdef _DEBUG
      if (myCallback == 0)
      {
         throw "Missing callback";
      }
#endif
 
      return myCallback->invoke(param0);
   }
 
   //! \brief Equality comparison operator
   //! \param rhs The right-hand side delegate to compare with
   //! \return True if both delegates reference the same callback
   //!
   //! Compares two delegates to determine if they reference the same callback
   bool operator==(const DtDelegate& rhs) const
   {
      if (myIsStatic != rhs.myIsStatic)
      {
         return false;
      }
 
      return (*myCallback) == (*(rhs.myCallback));
   }
 
   //! \brief Inequality comparison operator
   //! \param rhs The right-hand side delegate to compare with
   //! \return True if the delegates do not reference the same callback
   bool operator!=(const DtDelegate& rhs) { return !(*this == rhs); }
};
} // namespace makRadarFx