jaus++/2.0/include/jaus/core/control/accesscontrol.h

Go to the documentation of this file.

#ifndef __JAUS_CORE_ACCESS_CONTROL__H
#define __JAUS_CORE_ACCESS_CONTROL__H

#include "jaus/core/discovery/discovery.h"
#include "jaus/core/control/confirmcontrol.h"
#include "jaus/core/control/queryauthority.h"
#include "jaus/core/control/querycontrol.h"
#include "jaus/core/control/querytimeout.h"
#include "jaus/core/control/rejectcontrol.h"
#include "jaus/core/control/releasecontrol.h"
#include "jaus/core/control/reportauthority.h"
#include "jaus/core/control/reportcontrol.h"
#include "jaus/core/control/reporttimeout.h"
#include "jaus/core/control/requestcontrol.h"
#include "jaus/core/control/setauthority.h"

namespace JAUS
{
    class JAUS_CORE_DLL AccessControl : public Events::Child
    {
    public:
        class JAUS_CORE_DLL Callback : public Discovery::Callback
        {
        public:
            typedef std::set<Callback* > Set;
            Callback() {}
            virtual ~Callback() {}
            // Method called when we lose control of a component.
            virtual void ProcessLossOfControl(const Address& controlledComponent) {}
            // Method called when we gain, or re-gain control of a component.
            virtual void ProcessAcquisitionfControl(const Address& controlledComponent) {}
            // Method called when when the controller release control of this service.
            virtual void ProcessReleaseOfControl(const Address& controllerID) {}
        };
        class JAUS_CORE_DLL Child : public Events::Child
        {
        public:
            Child(const ID& serviceIdentifier, 
                  const ID& parentServiceIdentifier) : Events::Child(serviceIdentifier, 
                                                                     parentServiceIdentifier) {}
            virtual ~Child() {}
            virtual bool RequestControl() { return true; }
            virtual bool ReleaseControl() { return true; }
            virtual void ProcessAcquisitionOfControl(const Address& controlledComponent) {}
        };
        const static std::string Name; 
        // Constructor.
        AccessControl();
        // Destructor.
        ~AccessControl();
        // Method called to check if the command can be processed.
        bool AcceptCommandMessage(const Message* commandMessage) const;
        // Loads settings from XML specific to the Service.
        virtual bool LoadSettings(const std::string& filename);
        // Shutsdown the Service.
        virtual void Shutdown();
        // Method called to take control of a component.
        bool RequestComponentControl(const Address& id, 
                                     const bool reacquire = true,
                                     const unsigned int waitTimeMs = Service::DefaultWaitMs);
        // Method to release control
        bool ReleaseComponentControl(const Address& id,
                                     const unsigned int waitTimeMs = Service::DefaultWaitMs);
        // 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;
        // Method to turn off control abilities from other compoments (default is on).
        void SetControllable(const bool on = true);
        // Is the Control of Service available?
        inline bool IsControllable() const { return mControllableFlag; }
        // Access Control is always discoverable.
        virtual bool IsDiscoverable() const { return true; }
        // Processes messages associated with the Access Control Services.
        virtual void Receive(const Message* message);
        // Creates messages associated with the Access Control Service.
        virtual Message* CreateMessage(const UShort messageCode) const;
        // Sets the authority level of the Service.
        void SetAuthorityCode(const Byte authorityCode);
        // Gets the authority level of the Service.
        inline Byte GetAuthorityCode() const { return mAuthorityCode; }
        // Method to check if control has been established.
        bool HaveControl(const Address& id) const;
        // Method to check if Service/Component is being controlled.
        bool IsControlled() const;
        // Method to force control of the component.
        void SetControllerID(const Address& id);
        // Method to get the ID of the controlling component.
        Address GetControllerID() const;
        // Method to get the authority code of controllign component.
        Byte GetControllerAuthorityCode() const;
        // Gets the components being controlled by the Component.
        Address::List GetControlledComponents() const;
        // When called verifies status of controlled components.
        virtual void CheckServiceStatus(const unsigned int timeSinceLastCheckMs);  
        // Get the amount of time before a timeout occurs (seconds).
        Byte GetTimeoutPeriod() const;
        // Sets the amount of time before a timeout occurs (seconds).
        void SetTimeoutPeriod(const Byte timeSeconds);
        // Get the amount of time between checks for control of components.
        Time::Stamp GetControlCheckPeriod() const;
        // Get the last time a command was recived from the controlling component.
        Time GetControllerUpdateTime() const { return mControllerUpdateTime; }
        // Register to receive updates of subsystems (add or removes callback).
        void RegisterCallback(Callback* callback, const bool add = true);   
        // Prints status about the service.
        virtual void PrintStatus() const;
    protected:
        bool mControllableFlag;                 
        Byte mAuthorityCode;                    
        Mutex mControlMutex;                    
        Address::Set mControlledComponents;     
        Address::Set mToReleaseControl;         
        std::map<Address, bool> mMaintainFlags; 
        std::map<Address, bool> mControlFlags;  
        Address mControllerID;                  
        Byte mControllerAuthorityCode;          
        Time mControllerUpdateTime;             
        Time mControllerCheckTime;              
        Byte mTimeoutPeriod;                    
        double mTimeoutThreshold;               
        std::map<Address, Byte> mTimeoutPeriods;
        std::map<Address, Time> mControlCheckTimes;     
        std::map<Address, Time> mControlConfirmTimes;   
        Callback::Set mCallbacks;                       
        Mutex mCallbacksMutex;                          
    private:
        void EraseComponentControlInfo(const Address& id);
    };
}

#endif
/*  End of File */