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

Go to the documentation of this file.

#ifndef __JAUS_CORE_DISCOVERY__H
#define __JAUS_CORE_DISCOVERY__H

#include "jaus/core/discovery/vehicle.h"
#include "jaus/core/events/events.h"
#include "jaus/core/transport/transport.h"
#include "jaus/core/discovery/queryconfiguration.h"
#include "jaus/core/discovery/queryidentification.h"
#include "jaus/core/discovery/queryservices.h"
#include "jaus/core/discovery/querysubsystemlist.h"
#include "jaus/core/discovery/registerservices.h"
#include "jaus/core/discovery/reportconfiguration.h"
#include "jaus/core/discovery/reportidentification.h"
#include "jaus/core/discovery/reportservices.h"
#include "jaus/core/discovery/reportsubsystemlist.h"

namespace JAUS
{
    class JAUS_CORE_DLL Discovery : public Events::Child
    {
    public:
        const static std::string Name; 







        class JAUS_CORE_DLL Callback : public Transport::Callback
        {
        public:
            typedef std::set<Callback* > Set;
            Callback() {}
            virtual ~Callback() {}  
            virtual void ProcessSystemState(const Subsystem::Map& system){};
        };
        typedef std::map<UShort, std::string> List; 
        Discovery();
        ~Discovery();
        // Loads settings from XML specific to the Service.
        virtual bool LoadSettings(const std::string& filename);
        // Initializes the service.
        virtual void Initialize();
        // Shutsdown the Service.
        virtual void Shutdown();
        // Events service is always discoverable.
        virtual bool IsDiscoverable() const { return true; }
        // Processes messages associated with the Events service.
        virtual void Receive(const Message* message);  
        // Creates messages associated with the events service.
        virtual Message* CreateMessage(const UShort messageCode) const;
        // When called verifies that no subscriptions have been lost.
        virtual void CheckServiceStatus(const unsigned int timeSinceLastCheckMs);
        // Method called when an Event has been signaled, generates an Event message.
        virtual bool GenerateEvent(const Events::Subscription& info) const;
        // Method called to determine if an Event is supported by the service.
        virtual bool IsEventSupported(const Events::Type type,
                                      const double requestedPeriodicRate,
                                      const Message* queryMessage,
                                      double& confirmedPeriodicRate,
                                      std::string& errorMessage) const;
        // Sets the name of the component.
        void SetComponentIdentification(const std::string& identification) { mComponentIdentification = identification; }
        // Sets the name of the node.
        void SetNodeIdentification(const std::string& identification) { mNodeIdentification = identification; }
        // Sets the identification of the subsystem.
        void SetSubsystemIdentification(const Subsystem::Type type,
                                        const std::string& identification);
        // Sets how often to broadast messages for discovery.
        bool SetDiscoveryFrequency(const double frequencyHz);
        // Sets whether or not to perform a global query for other subsystems (default is on).
        void DiscoverSubsystems(const bool enable = true) { mDiscoverSubsystemsFlag = enable; }
        // Gets the subsystem type.
        Subsystem::Type GetSubsystemType() const { return mSubsystemType; }
        // Gets this subsystem identification.
        std::string GetSubsystemIdentification() const { return mSubsystemIdentification; }
        // Gets this subsystem identification.
        std::string GetNodeIdentification() const { return mNodeIdentification; }
        // Gets this subsystem identification.
        std::string GetComponentIdentification() const { return mComponentIdentification; }
        // Gets a list of subsystems by name and ID.
        List GetSubsystemList() const;
        // Gets a list of subsystems (that are Vehicles) by name and ID.
        List GetVehicleList() const;
        // Gets a list of component IDs with a service.
        Address::List GetComponentsWithService(const std::string& serviceName) const;
        // Gets a pointer to subsystem data that is thread safe.
        Subsystem::Ptr GetSubsystem(const UShort id);
        // Gets a pointer to subsystem data that is thread safe.
        Subsystem::Ptr GetSubsystem(const Address& id) { return GetSubsystem(id.mSubsystem); }
        // Gets a pointer to subsystem data that is thread safe.
        const Subsystem::Ptr GetSubsystem(const UShort id) const;
        // Gets a pointer to subsystem data that is thread safe.
        const Subsystem::Ptr GetSubsystem(const Address& id) const { return GetSubsystem(id.mSubsystem); }
        // Gets a pointer to subsystem data that is thread safe.
        Vehicle::Ptr GetVehicle(const UShort id);
        // Gets a pointer to subsystem data that is thread safe.
        Vehicle::Ptr GetVehicle(const Address& id) { return GetVehicle(id.mSubsystem); }
        // Gets a pointer to subsystem data that is thread safe.
        const Vehicle::Ptr GetVehicle(const UShort id) const;
        // Gets a pointer to subsystem data that is thread safe.
        const Vehicle::Ptr GetVehicle(const Address& id) const { return GetVehicle(id.mSubsystem); }
        // Gets copy of all the Subsystem data (YOU MUST DELETE THIS DATA WHEN DONE).
        void GetSubsystems(Subsystem::Map& subsystems) const;
        // Gets copy of all the Vehicle data (YOU MUST DELETE THIS DATA WHEN DONE).
        void GetVehicles(Vehicle::Map& vehicles) const;
        // Register to receive updates of subsystems (add or removes callback).
        void RegisterCallback(Callback* callback, const bool add = true);     
        // Prints system configuration information to the console.
        void PrintSystemConfiguration() const;
        // Prints information about the service.
        virtual void PrintStatus() const;
        // Triggers discovery callbacks.
        void TriggerDiscoveryCallbacks();
        // Sets a list of subsystems that you want Discovery to find (ignoring all others).
        void SetSubsystemsToDiscover(const std::set<UShort>& toDiscover);
        // Gets the set of subsystems you want to discover (if empty, all are discovered).
        std::set<UShort> GetSubsystemsToDiscover() const;
    private:
        volatile bool mDiscoverSubsystemsFlag;  
        Mutex mSubsystemDataMutex;              
        Mutex mCallbacksMutex;                  
        unsigned int mBroadcastDelayMs;         
        Time::Stamp mBroadcastTimeMs;           
        Subsystem::Map mSystem;                 
        Callback::Set mCallbacks;               
        std::string mComponentIdentification;   
        std::string mNodeIdentification;        
        std::string mSubsystemIdentification;   
        Subsystem::Type mSubsystemType;         
        Address::Set mSubsystemList;            
        std::set<UShort> mSubsystemsToDiscover; 
    };
}

#endif
/*  End of File */