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

Go to the documentation of this file.

#ifndef _WURDE_COMMS_MANAGER_H
#define _WURDE_COMMS_MANAGER_H

#include <CommsHelper.H>
#include <Capability.H>
#include <WURDEConfiguration.H>
#include <Heartbeat.H>
#include <McpRequest.H>
#include <Trigger.H>
#include <vector>
#include <string>
#include <unistd.h>
#include <map>



//it pains me to define this number, but every solution is ugly.
#define MAX_INTERFACES 128

namespace WURDE {

        /* a few forward declarations are necessary here */
        class Capability;
        class CommsHelper;
        class Heartbeat;
        class McpRequest;
        
        class CommsManager {
                
        public:
                CommsManager(std::string name);
                
                CommsManager(std::string name,Protocols defaultProt);
                ~CommsManager(){};
                
                void setName(std::string name);
                
                void initialize();
                
                RunState runUpdate();
                
                void registerObject(Capability *someObject);
                
                void deregister(Capability *someObject);
                
                void registerSupplier(Capability *someObject);
                
                void registerConsumer(Capability *someObject);
                
                void cleanUp();
                
                RunState getState(){ return m_currState;};
                void setIdle();
                void setQuit();
                void setReset();
                void setRun();
                void setRestart();
                
                void setInfoState();
                
                void setGlobalConfigFile(std::string val){m_globalConfigFile=val;}
                
                std::string getName(){return m_name;};
                
                std::string getRealName(){ return m_realName;}
               
                void setRealName(std::string name){ m_realName=name;}
               
                void setHelpString(std::string helpstring){m_helpstring=helpstring;}
                void setNoSleep(){m_doSleep=false;};
                
                void setSleep(double seconds);
                
                void setMinSleep(double seconds);
                
                void setSleepOnly(double seconds);

                void setHeartbeatOnly(double seconds);

                void setNoHeartbeat(){m_doHeartbeat=false;};
                
                void setPreSleep(){preSleep=true;};

                void setPostSleep(){preSleep=false;};
                
                void setTriggerMode(bool val){onlyTrigger=val;};
                
                bool checkTriggers(Capability *someobject);
                
                bool activeTrigger();
                
                void addTrigger(Trigger someTrigger){triggerList.push_back(someTrigger);};
                
                void resetTriggers();
                
                void setMcpRequestMode(bool val){m_doMcpRequests=val;};
                
                void setIdleDataProcessing(bool val){m_doIdleProcessing=val;};
                
                void parseOptions(int argc, char *argv[]);
                
                void parseOptions(int argc, char *argv[],char *optstring);
                //multimap<char, string> parseOptions(int argc, char *argv[],char *optstring);
                
                void sendInfo();

                // needed when we fork MCP-- commshelpers must close any handles which might cause problems
                void closeConnections(){myCommsHelper->closeConnections();}
                
        protected:
                void handleMCPReply(McpRequestInfoStruct someinfo);
                
        private:
                
                void sleep();
                void updateObjects();
                void handleMCP();
                
                // Name as bound to WURDE. ie, TomRFlexServer
                string m_name;
                // General name of the module. ie, RFlexServer
                string m_realName;
                // usage string to be displayed after WURDE usage information when invoked with -h
                string m_helpstring;
                bool initialized;
                
                // the various commshelpers
                CommsHelper *myCommsHelper;
                
                RunState state;
                
                McpRequest m_mcpRequest;              
                Heartbeat m_heartbeat;
                Protocols defaultProtocol;
                //vector<CapabilityContainer> objectList;
                vector<Capability*> objectList;
                vector<Trigger> triggerList;
                
                //              std::map<std::string,int> m_counters;
                //              unsigned int m_counters[MAX_INTERFACES*2];
                
                //              std::map<std:string,int> m_supplyCounters;
                //              unsigned int m_supplyCounters[MAX_INTERFACES*2];
                
                struct timespec sleepInterval;
                bool m_doSleep;
                bool m_doHeartbeat;
                bool m_doMcpRequests;
                bool m_doIdleProcessing;
                bool m_laxRequests;
                bool m_nameServiceOverride;
                bool preSleep;
                bool onlyTrigger;
                
                std::string m_globalConfigFile;
                RunState m_currState;
                Time endsleep;
                Time minSleep;
        };

        extern CommsManager *g_globalCommsManager_ptr;

        bool registerSupplier(Capability *someObject);
        bool registerConsumer(Capability *someObject);          
}

typedef WURDE::CommsHelper *commshelperloader_ptr(std::string name);

extern std::map<std::string, commshelperloader_ptr *, std::less<std::string> > commsHelperFactory;      


#endif

---