BaseClass.h

Go to the documentation of this file.

#ifndef BASECLASS_H
#define BASECLASS_H

#include <vrecko/Export>

#include <vector>
#include <string>
#include <map>

#include <vrecko/MTLock.h>
#include <vrecko/Message.h>

//#include <osg/Timer>

//#include <xercesc/parsers/AbstractDOMParser.hpp>
//#include <xercesc/dom/DOMDocument.hpp>

#include <xercesc/util/XercesDefs.hpp>

#include <vrecko/Logger.h>

XERCES_CPP_NAMESPACE_BEGIN
    class DOMNode;
    class DOMDocument;
XERCES_CPP_NAMESPACE_END


namespace vrecko {

class VRECKO_EXPORT AutoPtrV;
class VRECKO_EXPORT World;
class VRECKO_EXPORT BaseClass;

#define EVENTDISPATCHER_PRIORITY -1000000

class IOPinBase : public osg::Referenced {
public:
    std::string& getPinName() { return pinName; };
    
    virtual VreckoMessage* createCompatibleMessage() = 0;
protected:
    std::string pinName;
    BaseClass *owner;
};


class InputPinBase : public IOPinBase {
public:
    virtual void processMessage(VreckoMessage *message) = 0;
};

class OutputPinBase : public IOPinBase {
};


class IORequestPinBase : public IOPinBase {
public:
    virtual VreckoMessage* createReturningCompatibleMessage() = 0;
};

class RequestInputPinBase : public IORequestPinBase {
public:
    virtual osg::ref_ptr<VreckoMessage> processRequest(VreckoMessage *message) = 0;
};

class RequestOutputPinBase : public IORequestPinBase {
};


class VRECKO_EXPORT BaseClass {
    protected:
        typedef std::map<std::string, int> AttributeMap;
        AttributeMap attribute;
        MTReadWriteLock attributeLock;

    public:
        BaseClass(const char* startingSenderString);

        BaseClass(BaseClass &bc);

        virtual ~BaseClass();

        virtual bool initialize(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *parameters = NULL);

        virtual bool initializeFromString(const char *xmlString);

        
        virtual void update(void) {};

        virtual XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *saveXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *) {return NULL;}

//      /// Types of an input/output and parameter.
//      OBSOLETE after the message revolution in summer 2011.
//
//      typedef enum {
//          UNKNOWN = 0,
//          BOOL,
//          INT,
//          UINT,
//          LONG_INT,
//          ULONG,
//          FLOAT,
//          DOUBLE,
//          STRING,
//          MESSAGE,
//          VEC2,
//          VEC3,
//          VEC4,
//          MATRIX,
//          QUAT,
//          POINTER,
//          VEC3ARRAY // = std::vector<osg::Vec3>
//      } IO_Type;
//
//      /// The struct for description of input.
//      typedef struct {
//          /// Name of the input.
//          std::string name;
//          /// Type of the input.
//          IO_Type type;
//          /// Possible value for the input.
//      } INPUT_DESCRIPTION;
//
//      /// The struct for description of output.
//      typedef struct {
//          /// Name of the output.
//          std::string name;
//          /// Type of the output.
//          IO_Type type;
//          /// Possible value for the output.
//          //std::vector<std::string> value;
//          /// Is it required?
//          bool required;
//      } OUTPUT_DESCRIPTION;
//
//      /** Return vector with description of all inputs for the object. */
//      inline std::vector<INPUT_DESCRIPTION> &getInput(void) {return input;}
//      /** Return type of the input. */
//      IO_Type getInputType(const std::string &name);
//      /** Return vector with description of all outputs for the object. */
//      inline std::vector<OUTPUT_DESCRIPTION> &getOutput(void) {return output;}
//      /** Return type of the output. */
//      IO_Type getOutputType(const std::string &name);
//      
        bool inputPresent(const std::string &name);

        bool outputPresent(const std::string &name);

//      /* Returns true if the given request input is present */
//      bool requestInputPresent(const std::string &name);
//      /* Returns true if the given request output is present */
//      bool requestOutputPresent(const std::string &name);
//
//      /* Return string of IO_Type. */
//      static std::string getIO_TypeString(IO_Type type);
//
//      /* Add a input to the existing list of the inputs. */
//      void addInput(const char *name, IO_Type type);
//      /* Remove the input from the list of inputs. */
//      void removeInput(const char *name);
//
//      /* Older way. Add a output to the existing list of the outputs. */
//      void addOutput(const char *name, IO_Type type);
//      /* Older way. Remove the output from the list of outputs. */
//      void removeOutput(const char *name);
//
//      /* Return type of the input. */
//      VreckoMessage* getRequestInputType(const std::string &name);
//      /* Return type of the output. */
//      VreckoMessage* getRequestOutputType(const std::string &name);
//      /* Add a input to the existing list of the inputs. */
//      void addRequestInput(const char *name, IO_Type type);
//      /* Remove the request input from the list of inputs. */
//      void removeRequestInput(const char *name);
//      /* Add a output to the existing list of the outputs. */
//      void addRequestOutput(const char *name, IO_Type type);
//      /* Remove the request output from the list of outputs. */
//      void removeRequestOutput(const char *name);

        void addInputPin(InputPinBase *pin);
        
        void removeInputPin(InputPinBase *pin);

        void addOutputPin(OutputPinBase *pin);

        void removeOutputPin(OutputPinBase *pin);


        void addRequestInputPin(RequestInputPinBase *pin);

        void removeRequestInputPin(RequestInputPinBase *pin);

        void addRequestOutputPin(RequestOutputPinBase *pin);
        void removeRequestOutputPin(RequestOutputPinBase *pin);

        enum NotificationTypes {
            // bit flags
            NOTIFICATION_DELETE_CLASS       = 1,
            NOTIFICATION_EO_REGISTERING     = 2,
            NOTIFICATION_EO_UNREGISTERING   = 4,
            NOTIFICATION_PROGRAM_TERMINATION = 8,
            NOTIFICATION_ALL                = 0xFFFFFFFF 
        };

        bool addNotification(BaseClass *receiver, unsigned long notificationTypes);

        bool removeNotification(BaseClass *receiver, unsigned long notificationTypes = NOTIFICATION_ALL);

        virtual void processEvent(const std::string& input_name, VreckoMessage *pMessage);
        
        virtual VreckoMessage *processRequest(const std::string& request_input_name, VreckoMessage *pMessage);

        virtual const std::string &getSenderString(void) {return senderString;}

        void reportError(const std::string &error);

        /* Sets pointer to the World. */
        // OBSOLETE: Simply use the [vrecko::world] variable from World.h
//      inline void setWorldPtr(World *ptr) { /* pWorld = ptr; */ static bool bAlreadyWritten = false; if (!bAlreadyWritten) { logger.debugLog("setWorldPtr() is obsolete, there is now a global \"vrecko::world\" variable holding pointer to World (include World.h to use it)"); bAlreadyWritten = true; } }
        
        /* Gets pointer to the World. */
        // OBSOLETE: Simply use the [vrecko::world] variable from World.h
//      inline World *getWorldPtr() const { static bool bAlreadyWritten = false; if (!bAlreadyWritten) { logger.debugLog("getWorldPtr() is becoming obsolete, there is now a global \"vrecko::world\" variable holding pointer to World (include World.h to use it)"); bAlreadyWritten = true; } return world; }
        
        inline void setPriority(long int pr) {priority = pr;}
        
        inline long int getPriority(void) const {return priority;}

        inline void setAttribute(const std::string &attr_name, int attr_value) { attributeLock.lockWrite(); attribute[attr_name] = attr_value; attributeLock.unlockWrite(); }

        inline int getAttribute(const std::string &attr_name) { attributeLock.lockRead(); int i = attribute[attr_name]; attributeLock.unlockRead(); return i; }

        inline int getAttribute(const char* attr_name) { return getAttribute(std::string(attr_name));}

        void deleteAttribute(const std::string &attr_name);


        void setSceneFile(const std::string &sceneFileName);
        
        inline const std::string &getSceneFile() const { return *sceneFile; }



        virtual void preInitialize(void) {};

        virtual void postInitialize(void) {};

        virtual bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *) {return true;}

        virtual bool loadXMLParameters(const char *xmlString);

        InputPinBase* getInputPin(const char *strName);

        OutputPinBase* getOutputPin(const char *strName);

        RequestInputPinBase* getRequestInputPin(const char *strName);


        RequestOutputPinBase* getRequestOutputPin(const char *strName);

        
    protected:
        std::string senderString;

        struct NOTIFICATION_DESCRIPTION {
            BaseClass *receiver;
            unsigned long notificationTypes;
        };

        MTLock notificationsLock;
        std::vector<NOTIFICATION_DESCRIPTION> notifications;


//      /// Pointer to the World.
//      World *pWorld; OBSOLETE, use [world] from World.h
        
        long int priority;

        const std::string * sceneFile;

        typedef std::vector<osg::ref_ptr<IOPinBase>> PinList;


        PinList inputPinsList;

        PinList outputPinsList; // we know that all of them are of type OutputPinBase

        PinList requestInputPinsList;

        PinList requestOutputPinsList;

        bool sendNotifications(unsigned long notificationType, void *notificationData);

        virtual int processNotification(BaseClass *sender, unsigned long notificationType,
            void *notificationData) { return 0; }

        inline IOPinBase* findPinInList(const char *strName, PinList* pinList) {
            for (auto itr = pinList->begin(); itr != pinList->end(); ++itr) {
                if ((*itr)->getPinName() == strName)
                    return (*itr);
            }
            return NULL;
        }
};

}

#endif