DtMessageMemberCall.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2020 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 
 
 
#ifndef DtMessageMemberCall_H_ 
#define DtMessageMemberCall_H_ 
 
#include <vrvCore/vrvCore.h> 
#include <vrvUtil/DtMessage.h>
#include <vrvCore/DtAgentManager.h>
#include <vrvCore/DtAgentUpdateResolverInterface.h>
#include <vrvCore/DtAgent.h>
#include <vrvCore/DtDe.h>
#include <boost/type_traits.hpp>

namespace makVrv 
{ 

   template <typename T, bool isPointer,bool isDriver>
   struct StorageType
   {
      typedef typename boost::remove_const<typename boost::remove_reference<T>::type>::type Result;
   };

   template <typename T>
   struct StorageType<T,true,true>
   {
      typedef DtUniqueID Result;
   };

   template <class T>
   struct CleanupType
   {      

      //Clean up T to make sure it is just the class.
      typedef typename boost::remove_pointer<typename boost::remove_const<T>::type>::type TClass;

      enum { IsObject = boost::is_class<typename boost::remove_pointer<T>::type>::value};

      //Grab the Storage type of T, w/ T is a pointer & if T is a extends DtAgent.
      typedef typename StorageType<T, boost::is_pointer<T>::value, IsObject >::Result Result;
   };


   template <typename DesiredType>
   struct Cast
   {
      inline static DesiredType toFunctionType(DtDe&,DesiredType input)
      {
         return input;
      }

      inline static DesiredType toFunctionType(DtDe& de,DtUniqueID input)
      {
         DtAgentUpdateResolverInterface* updater = de.agentManager().findUpdater(input);
         if(updater)
         {
            return (DesiredType)updater->objectMemoryAddress();
         }
         else
         {
            return 0;
         }
      }
   };
   
   template <>
   struct Cast<DtUniqueID>
   {
      inline static DtUniqueID toFunctionType(DtDe&,DtUniqueID input)
      {
         return input;
      }
   };

   template <class C>
   class DtMessageMemberCall
   {
   public:
      virtual ~DtMessageMemberCall() {}
      virtual void call(DtDe& de,C* c,DtMessage& msg) = 0;
   };


   template < class C>
   class DtMessageMemberCall0 : public DtMessageMemberCall<C>
   {
   public:
      typedef void (C::*MemberFuncPtr)();

      DtMessageMemberCall0(MemberFuncPtr m) : myFunc(m){}
      virtual ~DtMessageMemberCall0() {}

      virtual void call(DtDe& de, C* c,DtMessage& msg)
      {
         try
         {
            (c->*myFunc)();
         }
         catch(DtException& ex)
         {
            de.DT_LOG_WARN << ex << std::endl;
         }
         catch(...)
         {
            de.DT_LOG_WARN << "Caught unknown exception" << std::endl;
         }
      }
      MemberFuncPtr myFunc;
   };

   template <class C>
   DtMessageMemberCall<C>* bindMember(void (C::*m)())
   {
      return new DtMessageMemberCall0<C>(m);
   }

   //Define a Subclass of DtMessageMemberCall with N arguments.
   #define DT_DEFINE_MESSAGE_MEMBER_CALL(argCount)\
   template < class C, MAKE_LIST(typename T,argCount) >\
   class DtMessageMemberCall##argCount : public DtMessageMemberCall<C>\
   {\
   public:\
      typedef void (C::*MemberFuncPtr)( MAKE_LIST(T,argCount) );\
      DtMessageMemberCall##argCount(MemberFuncPtr m) \
      : myFunc(m)\
      {\
      }\
      virtual void call(DtDe& de, C* c,DtMessage& msg)\
      {\
         MAKE_DECL_MULTILIST(typename CleanupType<T,>::Result a,argCount);\
         msg >> MAKE_STREAMOUT(a,argCount);\
         try\
         {\
            (c->*myFunc)(MAKE_CAST_CALL(Cast<T,>::toFunctionType,de,a,argCount));\
         }\
         catch(DtException& ex)\
         {\
            de.DT_LOG_WARN << ex << std::endl;\
         }\
         catch(...)\
         {\
            de.DT_LOG_WARN << "Caught unknown exception" << std::endl;\
         }\
      }\
      MemberFuncPtr myFunc;\
   };\
   \
   template <class C, MAKE_LIST(typename T,argCount) >\
   DtMessageMemberCall<C>* bindMember(void (C::*m)( MAKE_LIST(T,argCount) ))\
   {\
      return new DtMessageMemberCall##argCount<C, MAKE_LIST(T,argCount) >(m);\
   }

   DT_DEFINE_MESSAGE_MEMBER_CALL(1)
   DT_DEFINE_MESSAGE_MEMBER_CALL(2)
   DT_DEFINE_MESSAGE_MEMBER_CALL(3)
   DT_DEFINE_MESSAGE_MEMBER_CALL(4)
   DT_DEFINE_MESSAGE_MEMBER_CALL(5)
   DT_DEFINE_MESSAGE_MEMBER_CALL(6)
   DT_DEFINE_MESSAGE_MEMBER_CALL(7)
   DT_DEFINE_MESSAGE_MEMBER_CALL(8)
   DT_DEFINE_MESSAGE_MEMBER_CALL(9)
   DT_DEFINE_MESSAGE_MEMBER_CALL(10)

} 
 
#define DtMessageMemberCall_INL_ 
#include "DtMessageMemberCall.inl" 
#undef DtMessageMemberCall_INL_ 

#endif