noArgumentCallbackList.h

Go to the documentation of this file.

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


#pragma once

#include "readerWriter/readerWriterDefines.h"

#include <set>
#include <boost/function.hpp>

#include <tbb/spin_mutex.h>


template <typename T_CallbackFunctionType>
struct DtCallbackFunctionInfo
{
   DtCallbackFunctionInfo(T_CallbackFunctionType func, void* usr = 0)
   : callback(func)
   , usrData(usr)
   , deletedFlag(new bool(false))
   {
   }

   DtCallbackFunctionInfo(const DtCallbackFunctionInfo& orig)
   : callback(orig.callback)
   , deletedFlag(orig.deletedFlag)
   , usrData(orig.usrData)
   {
   }

   DtCallbackFunctionInfo& operator=(const DtCallbackFunctionInfo& rhs)
   {
      callback = rhs.callback;
      deletedFlag = rhs.deletedFlag;
      usrData = rhs.usrData;

      return *this;
   }

   bool operator<(const DtCallbackFunctionInfo& rhs) const
   {
      return callback < rhs.callback || (!(rhs.callback < callback) && usrData < rhs.usrData);
   }

   bool operator>(const DtCallbackFunctionInfo& rhs) const
   {
      return (rhs < *this);
   }

   bool operator==(const DtCallbackFunctionInfo& rhs) const
   {
      return ((callback == rhs.callback) &&
              (userData == rhs.userData));
   }

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

   void setIsDeleted(bool b) { *deletedFlag = b; };
   bool isDeleted() const { return *deletedFlag; };

   const T_CallbackFunctionType& getCallback() const { return callback; };
   void* userData() const { return usrData; };

protected:
   std::shared_ptr<bool> deletedFlag;
   T_CallbackFunctionType callback;
   void* usrData;
};

template <typename T_CallbackArg>
class DtCallbackList
{
public:
   typedef void (*DtCallbackFunctionType)(T_CallbackArg, void*);

   DtCallbackList();

   explicit DtCallbackList(const DtCallbackList& orig);

   bool addCallback(DtCallbackFunctionType fcn, void* usrData);
   bool removeCallback(DtCallbackFunctionType fcn, void* usrData);

   void invokeCallbacks(T_CallbackArg arg);

   void removeAll();

   DtCallbackList& operator=(const DtCallbackList& orig)
   {
      myCallbackList = orig.myCallbackList;
      myCallbackCount = orig.myCallbackCount;

      return *this;
   }

protected:
   struct DtCallbackInfoType : public DtCallbackFunctionInfo<DtCallbackFunctionType>
   {
      DtCallbackInfoType(DtCallbackFunctionType callback, void* userData = 0)
      : DtCallbackFunctionInfo<DtCallbackFunctionType>(callback, userData)
      {
      }
   };

   typedef std::set<DtCallbackInfoType> DtCallbackListType;

   mutable tbb::spin_mutex myMutex;

   DtCallbackListType myCallbackList;
   unsigned myCallbackCount;
};

class DT_DLL_readerWriter DtNoArgumentCallbackList
{
public:
   typedef void (*DtCallbackFunctionType)(void*);

   DtNoArgumentCallbackList();

   explicit  DtNoArgumentCallbackList(const DtNoArgumentCallbackList& orig);

   bool addCallback(DtCallbackFunctionType fcn, void* usrData);
   bool removeCallback(DtCallbackFunctionType fcn, void* usrData);

   void invokeCallbacks();

   void removeAll();

protected:
   struct DtCallbackInfoType : public DtCallbackFunctionInfo<DtCallbackFunctionType>
   {
      DtCallbackInfoType(DtCallbackFunctionType callback, void* userData)
      : DtCallbackFunctionInfo(callback, userData)
      {
      }
   };

   typedef std::set<DtCallbackInfoType> DtCallbackListType;

   mutable tbb::spin_mutex myMutex;

   DtCallbackListType myCallbackList;
   unsigned myCallbackCount;

private:
   DtNoArgumentCallbackList& operator=(const DtNoArgumentCallbackList& orig);
};

template <typename Callback>
class DtCallbackListT;

class DT_DLL_readerWriter DtCallbackConnection
{
public:
   DtCallbackConnection() { }

   bool disconnect()
   {
      if (myDisconnectFunction)
      {
         bool value = myDisconnectFunction();
         myDisconnectFunction = DisconnectFunctionType();
         return value;
      }
      
      return false;
   }

private:
   template <typename Callback>
   friend class DtCallbackListT;

   typedef boost::function<bool()> DisconnectFunctionType;

   explicit DtCallbackConnection(const DisconnectFunctionType& func)
      : myDisconnectFunction(func) { }

   DisconnectFunctionType myDisconnectFunction;
};

template <typename Callback>
class DtCallbackListT
{
public:
   DtCallbackListT() : myCallbackCount(0) { }

   DtCallbackConnection addCallback(const Callback& callback, bool* addedFirst = 0);

   void removeCallback(const Callback& callback, bool* removedLast = 0);

   void removeCallback(const boost::function<bool(const Callback&)>& removePredicate, bool* removedLast = 0);

   void removeAll();


   void invokeCallbacks();

   template <typename T1>
   void invokeCallbacks(const T1&);

   template <typename T1, typename T2>
   void invokeCallbacks(const T1&, const T2&);

   template <typename T1, typename T2, typename T3>
   void invokeCallbacks(const T1&, const T2&, const T3&);

protected:
   struct DtCallbackInfoType : public DtCallbackFunctionInfo<Callback>
   {
      DtCallbackInfoType(const Callback& callback)
      : DtCallbackFunctionInfo<Callback>(callback)
      {
      }
   };

   bool disconnect(const DtCallbackInfoType&);

   mutable tbb::spin_mutex myMutex;

   typename DtCallbackInfoType::List myCallbackList;
   unsigned myCallbackCount;

private:
   DtCallbackListT(const DtCallbackListT&);
   DtCallbackListT& operator=(const DtCallbackListT&);
};


#define callbackList_inl_
#include "readerWriter/noArgumentCallbackList.inl"
#undef  callbackList_inl_