behaviour_actuators.h

Go to the documentation of this file.

// Behaviour Control Framework - Actuator classes
// Author: Philipp Allgeuer <pallgeuer@ais.uni-bonn.de>

// Ensure header is only included once
#ifndef BEHAVIOUR_ACTUATORS_H
#define BEHAVIOUR_ACTUATORS_H

// Includes
#include <behaviour_control/classes/behaviour_common.h>

// Behaviour control namespace
namespace behaviourcontrol
{
    class ActuatorManager
    {
    public:
        // Constants
        static const index_t DEF_ALIST_CAPACITY; 

        // Constructors
        explicit ActuatorManager(BehaviourLayer* LBase); 
        virtual ~ActuatorManager(); 

        // Constant properties
        BehaviourManager* const MBase; 
        BehaviourLayer* const LBase; 

        // Initialisation functions
    protected:
        virtual ret_t init() { return RET_OK; } 
    private:
        ret_t initBase(); 

    private:
        // Update function
        void updateActuators(); 

        // Actuator declaration function
        template <class AClass> void declareActuator(AClass* actuator); 

        // Actuator list
        std::vector<ActuatorBase*> AList; 

    public:
        // Read data from an external source (used only in interface layers)
        virtual void readExternalData() {} 

        // Get functions
        ActuatorManager* getBasePtr() { return this; } 

        // Friend classes
        friend class BehaviourManager;
        friend class BehaviourLayer;
        friend class ActuatorBase;
    };

    class ActuatorBase
    {
    public:
        // Constants
        static const std::string DEF_ACTUATOR_SIGNAL_NAME; 

        // Constructors
        explicit ActuatorBase(ActuatorManager* AMBase, const std::string& signalName = nullString); 
        virtual ~ActuatorBase(); 

        // Constant properties
        BehaviourManager* const MBase; 
        BehaviourLayer* const LBase; 
        ActuatorManager* const AMBase; 
        const std::string signalName; 

    private:
        // Update function
        virtual void update() {}; 

    public:
        // Template type information
        virtual const std::type_info* getTypeInfo() const = 0; 
        virtual bool isCompatibleWith(const SensorBase* SBase) const = 0; 

        // Get functions
        std::string getUniqueName(const ActuatorManager* AMBase) const; 
        ActuatorBase* getBasePtr() { return this; } 

        // Friend classes
        friend class ActuatorManager;
    };

    template <class T>
    class Actuator : public ActuatorBase
    {
    public:
        // Constructors
        explicit Actuator(ActuatorManager* AMBase, const std::string& signalName = nullString, bool aggregatable = AGGREGATABLE); 
        virtual ~Actuator(); 

        // Template type information
        const bool aggregatable; 
        const std::type_info* const typeInfo; 
        virtual const std::type_info* getTypeInfo() const { return typeInfo; }
        virtual bool isCompatibleWith(const SensorBase* SBase) const;

        // Data read and write functions
        const T& read() const { return data; } 
        void write(const T& newdata, const Behaviour* BBase); 
        void writeAgg(const T& newdata, const Behaviour* BBase); 
        void writeHard(const T& newdata); 
        bool wasWrittenTo() const { return weightSum > 0.0; } 

    private:
        // Update function
        virtual void update() { weightSum = 0.0; lastModifier = NULL; };

        // Internal variables
        T data; 
        level_t weightSum; 
        const Behaviour* lastModifier; 
    };
}

#endif /* BEHAVIOUR_ACTUATORS_H */
// EOF