behaviour_layer.h

Go to the documentation of this file.

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

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

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

// Behaviour control namespace
namespace behaviourcontrol
{
    class BehaviourLayer
    {
    public:
        // Constants
        static const index_t DEF_BLIST_CAPACITY; 
        static const index_t DEF_ILIST_CAPACITY; 
        static const std::string DEF_LAYER_NAME; 

        // Structures
        struct BBasePair
        {
            BBasePair() : A(NULL), B(NULL) {} 
            BBasePair(Behaviour* BBaseA, Behaviour* BBaseB) : A(BBaseA), B(BBaseB) {} 
            Behaviour* A; 
            Behaviour* B; 
        }; 

        // Constructors
        explicit BehaviourLayer(BehaviourManager* MBase, const std::string& name = nullString, bool isInterface = false); 
        virtual ~BehaviourLayer(); 

        // Constant properties
        BehaviourManager* const MBase; 
        const std::string Mname; 
        const std::string name; 
        const bool isInterface; 

    private:
        // Sensor and actuator managers
        void setSensorManager(SensorManager* SMBase); 
        void setActuatorManager(ActuatorManager* AMBase); 
        SensorManager*   SMBase; 
        ActuatorManager* AMBase; 
        bool haveSM; 
        bool haveAM; 

        // Inhibition functions
    protected:
        void addInhibition(Behaviour* BBaseA, Behaviour* BBaseB); 
        void addChainInhibition(Behaviour* BBaseA, Behaviour* BBaseB); 
    private:
        std::vector<BBasePair> IList; 
        std::vector<BBasePair> CIList; 

    protected:
        // Initialisation function
        virtual ret_t init() { return RET_OK; } 

    private:
        // Internal initialisation functions
        ret_t initAll(); 
        ret_t initAllBase(); 
        ret_t initBase(); 

    public:
        // Get functions
        SensorManager*   getSMBase() { return (haveSM ? SMBase : NULL); } 
        ActuatorManager* getAMBase() { return (haveAM ? AMBase : NULL); } 
        bool hasSM() const { return haveSM; } 
        bool hasAM() const { return haveAM; } 

        // Step functions
    protected:
        virtual void update() {} 
        virtual void postExecuteCallback() {} 
    private:
        void step(); 
        void updateAll(); 
        void executeAll(); 

    private:
        // Actuator functions
        const ActuatorBase* findActuator(const std::string& signalName) const; 

        // Behaviour declaration function
        template <class BClass> void declareBehaviour(BClass* behaviour); 

        // Behaviour list
        std::vector<Behaviour*> BList; 

    public:
        // Get functions
        std::string getUniqueName(const BehaviourManager* MBase) const; 
        BehaviourLayer* getBasePtr() { return this; } 

        // Friend classes
        friend class BehaviourManager;
        friend class SensorManager;
        friend class ActuatorManager;
        friend class Behaviour;
    };
}

#endif /* BEHAVIOUR_LAYER_H */
// EOF