jaus++/2.0/include/jaus/core/service.h

Go to the documentation of this file.

#ifndef __JAUS_CORE_SERVICE__H
#define __JAUS_CORE_SERVICE__H

#include "jaus/core/message.h"
#include <string>
#include <set>
#include <map>

namespace JAUS
{
    class Transport;
    class Component;

    class JAUS_CORE_DLL Service
    {
        friend class Transport;
    public:
        class JAUS_CORE_DLL ID
        {
        public:
            typedef std::vector<ID> List;
            typedef std::set<ID> Set;
            ID(const std::string& name = "", const double verion = 1.0);
            ID(const ID& id);
            ~ID();
            int Write(Packet& packet) const;
            int Read(const Packet& packet);
            void Clear();
            std::string ToString(const bool nameOnly = true, const bool trim = true) const;
            ID& operator=(const ID& id);
            bool operator<(const ID& id) const { return mName < id.mName; }
            std::string mName;      
            double mVersion;        
        };
        static const int NoBroadcast     = 0;   // No broadcasting over IP (default)
        static const int LocalBroadcast  = 1;   // Use local broadcast transport layer options for sending.
        static const int GlobalBroadcast = 2;   // Use global broadcast transport layer options for sending.
        static const unsigned int DefaultWaitMs = 100;
        typedef std::map<std::string, Service*> Map;
        typedef Mutex::ScopedPtr<Service> Ptr;
        // Constructor, initializes ID, and any parent service we inherit from.
        Service(const ID& serviceIdentifier, const ID& parentServiceIdentifier);
        // Destructor.
        virtual ~Service();  
        // Called on component initialization.
        virtual void Initialize() {}
        // Shutsdown the Service.
        virtual void Shutdown() {}
        // Returns true if components are allowed to discover this serivice (used bye Discovery).
        virtual bool IsDiscoverable() const = 0;
        // Load settings from a file.
        virtual bool LoadSettings(const std::string& filename) { return true; }
        // Sends a message.
        virtual bool Send(const Message* message, const int broadcastFlags = NoBroadcast) const;
        // Sends a message, then waits for a response.
        virtual bool Send(const Message* message, 
                          Message* response, 
                          const unsigned int waitTimeMs = DefaultWaitMs) const;
        // Sends a message and waits for one of multiple responses.
        virtual bool Send(const Message* message,
                          Message::List& possibleResponses,
                          const unsigned int waitTimeMs = Service::DefaultWaitMs) const;
        // Method called whenever a message is received/given to the Service for processing.
        virtual void Receive(const Message* message);  
        // Create a message based on the message code.
        virtual Message* CreateMessage(const UShort messageCode) const = 0;
        // Gets the Service ID information.
        inline ID GetServiceID() const { return mServiceID; }
        // Sets the compondent ID.
        bool SetComponentID(const Address& id);
        // Gets the component ID.
        inline Address GetComponentID() const { return mComponentID; }
        // Checks if this Service inherits from another.
        bool InheritsFrom(const Service::ID& id) const;
        // Adds a child service connection if it inherits from this Service.
        bool AddChildService(Service* childService);
        // Sets the parent service (if this Service inherits from it).
        bool SetParentService(Service* parentService);
        // Gets the parent Service.
        Service* GetParentService();
        // Gets the parent Service.
        const Service* GetParentService() const;
        // Gets a pointer to a child Service.
        Service* GetChildService(const Service::ID& id = Service::ID());
        // Gets a pointer to a child Service.
        const Service* GetChildService(const Service::ID& id = Service::ID()) const;
        // Gets all the service information for this service and its children.
        Service::ID::Set GetServices() const;
        // Turn on Debug Messages.
        virtual void EnableDebugMessages(const bool on = true) { mDebugMessagesFlag = on; }
        // Method called periodically by Component or other Services, can be used for periodic udpdates.
        virtual void CheckServiceStatus(const unsigned int timeSinceLastCheckMs) { }
        // Toggles a service on or off.
        void EnableService(const bool enable) { mServiceEnabledFlag = enable; }
        // Turns a service on or off.
        bool IsEnabled() const { return mServiceEnabledFlag; }
        // Shutsdown all children of this Service first, followed by itself.
        virtual void RecursiveShutdown();
        // Sets a pointer to the component the service (and children) belong to.
        void SetComponent(Component* component);
        // Gets a pointer to the component the service belongs to.
        inline Component* GetComponent() { return mpComponent; }
        // Gets a pointer to the component the service belongs to.
        inline const Component* GetComponent() const { return mpComponent; }
        // Prints information about the service.
        virtual void PrintStatus() const {}
        // Signal to services they must shutdown.
        void SignalServiceToShutdown(const bool enable = true) { mShutdownServiceFlag = enable; }
        // Get the service shutdown flag.
        bool IsServiceShuttingDown() const { return mShutdownServiceFlag; }
    protected:        
        // Passes unsuported message to inheriting Services.
        void PushMessageToChildren(const Message* message);
        //Map* GetChildServices() { return &mJausChildServices; }
        Map GetChildServices();
        const Map GetChildServices() const;
        Transport* GetTransportService() { return mpTransportService; }
        const Transport* GetTransportService() const { return mpTransportService; }
        static Mutex mDebugMessagesMutex;   
        volatile bool mDebugMessagesFlag;   
        Address mComponentID;               
        Component* mpComponent;             
        volatile bool mShutdownServiceFlag; 
    private:
        volatile bool mServiceEnabledFlag;  
        Mutex mJausServiceMutex;      
        Service::ID mServiceID;       
        Service::ID mParentServiceID; 
        Map mJausChildServices;       
        Service* mpJausParentService; 
        Transport* mpTransportService;
    };
}

#endif
/*  End of File */