signalSlot.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
******************************************************************************/



#ifndef signalSlot_H_
#define signalSlot_H_

#include <vlutil/vlSmartPointers.h>
#include <list>

namespace MAKLogger
{

template <typename SignalType>
class DtSlot
{
public:

   DtSlot(){}
   virtual ~DtSlot(){}

   virtual void operator()(const SignalType&) = 0;
   virtual void* id()     = 0;
   virtual int   idSize() = 0;

   bool operator==(DtSlot<SignalType>& slot2)
   {
      if(this->idSize() != slot2.idSize()) return false;
      return memcmp(this->id(),slot2.id(),this->idSize()) == 0;
   }

};

template <typename SignalType>
class DtFunctionSlot : public DtSlot<SignalType>
{
public:
   typedef void (*SlotFunction)(const SignalType&);

   DtFunctionSlot(SlotFunction function) :
   myFunction(function)
   {
   }

   virtual void operator()(const SignalType& value)
   {
      myFunction(value);
   }

   virtual int   idSize()
   {
      return sizeof(myFunction);
   }

   virtual void* id()
   {
      return &myFunction;
   }

protected:
   SlotFunction myFunction;
};

template <typename ClassType,typename SignalType>
class DtMemberSlot : public DtSlot<SignalType>
{
public:

   typedef void (ClassType::*SlotMemberFunction)(const SignalType&);
   struct MemberSlotId
   {
      MemberSlotId(ClassType* objectValue, SlotMemberFunction memberFunctionValue)
         : object(objectValue)
         , memberFunction(memberFunctionValue)
      {
      }
      ClassType*         object;
      SlotMemberFunction memberFunction;
   };

   DtMemberSlot(ClassType* obj,SlotMemberFunction memberFunction)
      : myId(obj, memberFunction)
   {}

   virtual ~DtMemberSlot()
   {
   }

   virtual void operator()(const SignalType& value)
   {
      (myId.object->*myId.memberFunction)(value);
   }

   virtual int idSize()
   {
      return sizeof(myId);
   }

   virtual void* id()
   {
      return &myId;
   }

protected:
   MemberSlotId myId;
};


template <typename SignalType>
class DtSignal
{
public:
   typedef void (*DtSlotFunction)(const SignalType&);

   typedef DtSlot<SignalType>            SlotType;
   typedef DtBoost::shared_ptr<SlotType> SlotTypeSP;
   typedef std::list<SlotTypeSP>        SlotList;

   void connect(SlotTypeSP slot)
   {
      mySlots.push_back(slot);
   }

   void disconnect(SlotTypeSP slot)
   {
      typename SlotList::iterator newEnd = std::remove_if(mySlots.begin(),mySlots.end(), std::bind2nd(std::ptr_fun(compare),slot));
      mySlots.erase(newEnd, mySlots.end());
   }

   void operator()(const SignalType& value)
   {
      typename SlotList::iterator func = mySlots.begin();
      typename SlotList::iterator end  = mySlots.end();
      for(;func != end;++func)
      {
         SlotTypeSP& s = *func;
         s->operator()(value);
      }
   }

protected:

   static bool compare(SlotTypeSP slot1,SlotTypeSP slot2)
   {
      return *(slot1.get()) == *(slot2.get());
   }

   SlotList mySlots;
};

template <typename SignalType>
class DtValueSignal : public DtSignal<SignalType>
{
public:
   DtValueSignal(SignalType& valueRef) :
      myRef(valueRef)
   {
   }

   void setAndEmitOnNotEqual(const SignalType& newValue)
   {
      if(newValue != myRef)
      {
         myRef = newValue;
         (*this)(myRef);
      }
   }

   void setAndEmitOnEqual(const SignalType& newValue)
   {
      if(newValue == myRef)
      {
         myRef = newValue;
         (*this)(myRef);
      }
      else
      {
         myRef = newValue;
      }
   }

   void setAndEmit(const SignalType& newValue)
   {
      myRef = newValue;
      (*this)(myRef);
   }


protected:
   SignalType& myRef;
};



template<typename SignalType>
void DtConnect(DtSignal<SignalType>& signal,void  (*slot)(SignalType))
{
   signal.connect(typename DtSignal<SignalType>::SlotTypeSP(new DtFunctionSlot<SignalType>(slot)));
}

template <typename ClassType,typename SignalType>
void DtConnect(DtSignal<SignalType>& signal,ClassType* member,void (ClassType::*slot)(const SignalType&))
{
#ifdef __solaris__
   signal.connect(DtSignal<SignalType>::SlotTypeSP(new DtMemberSlot<ClassType,SignalType>(member,slot)));
#else
   signal.connect(typename DtSignal<SignalType>::SlotTypeSP(new DtMemberSlot<ClassType,SignalType>(member,slot)));
#endif
}

template<typename SignalType>
void DtDisconnect(DtSignal<SignalType>& signal,void  (*slot)(SignalType) )
{
   signal.disconnect(typename DtSignal<SignalType>::SlotTypeSP(new DtFunctionSlot<SignalType>(slot)));
}

template <typename ClassType,typename SignalType>
void DtDisconnect(DtSignal<SignalType>& signal,ClassType* member,void (ClassType::*slot)(const SignalType&) )
{
   signal.disconnect(typename DtSignal<SignalType>::SlotTypeSP(new DtMemberSlot<ClassType,SignalType>(member,slot)));
}

}

#endif