noArgumentCallbackList.h

Go to the documentation of this file.

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


#pragma once

#include "readerWriter/readerWriterDefines.h"

#include <list>
#include <boost/shared_ptr.hpp>
#include <boost/function.hpp>

#include <tbb/spin_mutex.h>

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();

protected:
   struct DtCallbackInfoType
   {
      DtCallbackFunctionType callback;
      void* userData;
      bool deletedFlag;

      DtCallbackInfoType(DtCallbackFunctionType callback, void* userData);
   };

   typedef std::list< boost::shared_ptr<DtCallbackInfoType> > DtCallbackListType;

   mutable tbb::spin_mutex myMutex;

   DtCallbackListType myCallbackList;
   unsigned myCallbackCount;

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

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
   {
      DtCallbackFunctionType callback;
      void* userData;
      bool deletedFlag;

      DtCallbackInfoType(DtCallbackFunctionType callback, void* userData);
   };

   typedef std::list< boost::shared_ptr<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
   {
      typedef boost::shared_ptr<DtCallbackInfoType> Ptr;
      typedef boost::weak_ptr<DtCallbackInfoType> WPtr;
      typedef std::list<Ptr> List;

      Callback callback;
      bool deletedFlag;

      typename List::iterator iterator;

      DtCallbackInfoType(const Callback& callback)
         : callback(callback), deletedFlag(false) { }

      Callback& getCallback() { return callback; }
   };

   bool disconnect(const typename DtCallbackInfoType::WPtr&);

   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_