/home/fwph/code/wurde/rde/core/COMObject.H

Go to the documentation of this file.

#ifndef _ROBOOBJECTS_COMOBJECT_H
#define _ROBOOBJECTS_COMOBJECT_H

#include <Time.H>
#include <queue>

//$Id: COMObject.H 66 2007-01-23 20:53:23Z fwph $

namespace WURDE {

        class COMBase {
        public:
                COMBase(const std::string &name){};
                virtual ~COMBase(){};
        };

       template <class InfoType, class DataType>
       class COMObject : public COMBase {
       public:
              COMObject(const std::string & name) : COMBase(name), m_streamname(name),m_globalName(name){
                     m_newData=false;
                     m_newInfo=false;
                     m_supplier=false;
                     //              m_lastDataTime.now();
                     //m_lastInfoTime.now();
                     //m_lastRequestTime.now(); 
                     m_queue=false;
              }

               virtual ~COMObject(){};
              
               virtual void activateSupplier()=0;

               virtual void activateConsumer()=0;

               virtual void runUpdate(const bool & publishData,const bool & publishInfo)=0;

               virtual void disconnect()=0;

              void setAcceptAny(const bool & val) { m_acceptAny=true;}

               virtual void setQueueMode(const bool & val)=0;

               virtual void setStreamName(const std::string & name)=0;
              
               virtual void setGlobalName(const std::string & name)=0;

               //              virtual int getID()=0;

              //              void timestampData();
    
              /*
               * the autorequest stuff needs to be handled in the 
               * communication adapter object, since the data shouldn't be
               * passed through if we're doing autorequests, and it shouldn't
               * overwrite the current data in that case either.
               */

              void setAutoPing(const bool &val){m_doAutoPing=val;}
              void doPing(){m_doPing=true;}

              void setStaging(DataType *staging_){m_data=staging_;}
              void setInfo(InfoType *info){m_incoming=info;}
              void setRequests(InfoType *requests){m_outgoing=requests;}
              
              void setDataVector(std::queue<DataType> *dataVector){m_dataVector=dataVector;}
              void setInfoVector(std::queue<InfoType> *infoVector){m_incomingVector=infoVector;}
              void setRequestVector(std::queue<InfoType> *requestVector){m_outgoingVector=requestVector;}

              bool isSupplier(){return m_supplier;}
              bool newInfo(){return m_newInfo;}
              bool newData(){return m_newData;}
              void resetInfo(){m_newInfo=false;}
              void resetData(){m_newData=false;}

       protected:
              COMObject<InfoType,DataType>(){}
              COMObject<InfoType,DataType>(const COMObject<InfoType,DataType> &){}

              std::string m_streamname;
              std::string m_globalName;
              
              bool m_newData;
              bool m_newInfo;

              /* If true, respond to pings automatically(Suppliers). */
              bool m_doAutoPing;

              /* If true, send a ping (Consumers). */
              bool m_doPing;

              /* If true, this is a data supplier. */
              bool m_supplier;
              
              /* If true, we queue data and info rather than overwriting. */
              bool m_queue;

              /* If true, accept messages with target or streamname "Any" */
              bool m_acceptAny;

              InfoType *m_incoming;
              InfoType *m_outgoing;
              DataType *m_data;

              std::queue<InfoType> *m_incomingVector;
              std::queue<InfoType> *m_outgoingVector;
              std::queue<DataType> *m_dataVector;

              InfoType m_lastInfoIn;
              InfoType m_lastInfoOut;
              DataType m_lastData;

       };
       
       
};

#endif

---