MeVisLab/Standard/Sources/ML/MLObjMgr/ObjMgr/mlObjMgrClient.h

Go to the documentation of this file.

// **InsertLicense** code
//-------------------------------------------------------------------------

//-------------------------------------------------------------------------

#ifndef __mlObjMgrClient_H
#define __mlObjMgrClient_H

#ifndef __MLObjMgrSystem_H
#include "MLObjMgrSystem.h"
#endif
#ifndef __mlObjMgrBase_H
#include "mlObjMgrBase.h"
#endif
#ifndef __mlObjMgrObjectContainer_H
#include "mlObjMgrObjectContainer.h"
#endif
#ifndef __mlObjMgrEvent_H
#include "mlObjMgrEvent.h"
#endif

// Hack to control output of debug information by specific symbols
#ifdef _DEBUG
# define mlDebugBySym(SYM,COUTS)          { const RuntimeType *rt = getClassTypeId();        \
                                            ML_CHECK_RUNTIME_TYPE(rt);                       \
                                            _mlDebugConst(((std::string)ML_CONSTANT_PREFIX)+ \
                                                          rt->getName() + "-" + (SYM),       \
                                                          COUTS);                            \
                                          }
#else
# define mlDebugBySym(SYM,COUTS)
#endif

#define omcDebug(msg)             mlDebug(getFieldStringValue("instanceName") << " (" << debugCommentFld->getStringValue() << "): " << msg)
#define omcDebugBySym(sym,msg)  { mlDebugBySym(sym, getFieldStringValue("instanceName") << " (" << debugCommentFld->getStringValue() << "): " << msg); \
                                  omcDebug(msg); }

ML_START_NAMESPACE

   class ObjMgr;

   class MLOBJMGR_EXPORT ObjMgrClient : public ObjMgrBase
   {
      friend class ObjMgr;
      friend class ObjMgrBase;

      typedef ObjMgrBase inherited;

      ML_ABSTRACT_CLASS_HEADER(ObjMgrClient)

      public:

         enum EventReceiveMode {
            EVENTS_NONE= 0,
            EVENTS_SELECTED,
            EVENTS_ALL,
            NUM_EVENT_RECEIVE_MODES
         };

         static const char *EventReceiveModeStrings[NUM_EVENT_RECEIVE_MODES];

      protected:

         ObjMgr  *_objMgr;
         
         ObjMgrBase  *_sourceModule;

         MLint32  _skipNotificationCount;

         omEventContainer  _events;

         EventReceiveMode  _eventReceiveMode;

         std::set<std::string>  _acceptedObjects;
         
         std::set<std::string>  _acceptedInfoLayers;

         virtual void handleNotification(Field *field);

         virtual void handleObjMgrNotification() {}

         virtual void objContainerChanged() {}
     
         inline const omObjectContainer *getConstObjContainer() const { return _objectContainer; }
         inline       omObjectContainer *getObjContainer()            { return _objectContainer; }
     
         inline omEventContainer &getMutableEventContainer()  { return _events; }

         void registerWithSourceModule();
         void cancelSourceModuleRegistration();

         void registerWithObjMgr();
         void cancelObjMgrRegistration();

         virtual std::string getDebugComment() const {
            return debugCommentFld->getStringValue();
         }

         ObjMgrClient(int inputNum, int outputNum, EventReceiveMode eventReceiveMode);

      private:

         ObjMgrClient(const ObjMgrClient &) : ObjMgrBase(0,0){
           ML_PRINT_FATAL_ERROR("ObjMgrClient::ObjMgrClient(const ObjMgrClient&)", 
                                ML_PROGRAMMING_ERROR, 
                                "Invalid usage of copy constructor");
         }

         ObjMgrClient &operator=(const ObjMgrClient &){
           ML_PRINT_FATAL_ERROR("ObjMgrClient::operator=", 
                                ML_PROGRAMMING_ERROR, 
                                "Invalid usage of assignment operator");
           return *this;
         }

         omObjectContainer *_objectContainer;

         BaseField   *objectsInFld;

         void gotNotification();

      public:

         IntField    *priorityFld;

         StringField *debugCommentFld;

         ~ObjMgrClient();

         inline void  addAcceptedObjectID(const std::string &id) {
            _acceptedObjects.insert(id);
         }
         inline void  clearAcceptedObjectIDs() {
            _acceptedObjects.clear();
         }

         inline void  addAcceptedInfoLayerName(const std::string &layerName) {
            _acceptedInfoLayers.insert(layerName);
         }
         inline void  clearAcceptedInfoLayerNames() {
            _acceptedInfoLayers.clear();
         }

         inline void  setEventReceiveMode(EventReceiveMode mode) {
            _eventReceiveMode= mode;
         }
         inline EventReceiveMode  getEventReceiveMode() {
            return _eventReceiveMode;
         }

         void  sendNotification();

         inline const omEventContainer &getEventContainer() const {
            return _events;
         }
     
         void  clearEventContainer() {
            _events.clear();
         }
    };

ML_END_NAMESPACE

#endif // __mlObjMgrClient_H