Ability.h

Go to the documentation of this file.

#ifndef ABILITY_H
#define ABILITY_H

#include <osg/Vec3>

#include <vector>

#include <vrecko/BaseClass.h>

#include <vrecko/Message.h>
#include <vrecko/Scheduler.h>

#include <vrecko/MTLock.h>


//#include <xercesc/parsers/AbstractDOMParser.hpp>
//--------------------

namespace vrecko {


class VRECKO_EXPORT EnvironmentObject;
class VRECKO_EXPORT World;

class VRECKO_EXPORT Ability: public BaseClass {
    protected:
//      Ability() { pOwner = NULL; }; // no default constructor -> force to create Ability with a name
        
        Ability(const char* theAbilityName);

        //Ability(const char* abName, const char *plName) {abilityName = abName; pluginName = plName;}
    public:
        virtual ~Ability();

        const std::string &getName() const {return abilityName;}
        void setPluginName(const char *pName);

        const std::string &getPluginName(void) const {return pluginName;}
        
        const std::string &getID(void) const {return abilityID;}
        
        void setID(const char *pID);

        virtual void clean(void) {};

        void setOwner(BaseClass *owner) { pOwner = owner;}

        BaseClass *getOwner(void) {return pOwner;}

//        virtual std::string getAcceptableMessages(void) {return std::string("");}
        
 // VYHODIT -----------------------------------
        typedef struct {
            std::string name;
            std::string description;
//            IO_Type type;
            std::string range;
        } ParameterStruct;
        
        typedef std::vector<ParameterStruct> ParameterVector;
        
        virtual ParameterVector *getParameterVector(void) {return NULL;}
 // VYHODIT -----------------------------------
        
//      void setUpdateFlag(bool state) {updated = state;}


        bool isUpdated(void);
        
       
        
        virtual const std::string &getSenderString(void);
        
    protected:
        BaseClass *pOwner;
        
        std::vector<std::string> parameterString;
        
        bool updated;
        
    private:
        std::string pluginName;
        
        std::string abilityName;
        
        std::string abilityID;

        // last parent's senderString
        std::string lastParentSenderString;
};


class AbilityDispatcher: public BaseClass {
    public:
        AbilityDispatcher();
        ~AbilityDispatcher();

        void addAbility(Ability *pAbility);
        void removeAbility(Ability *pAbility);
        void removeAllAbilities();
        Ability *getAbility(const std::string &ab_id);
        typedef std::map<std::string, Ability*> AbilityMap;
        AbilityMap &getAbilityMap(void) {return ability_name_map;}

//        Ability *getAppropriateAbility(const std::string &message_ID);
        Ability *getAbilityWithInput(const std::string &input_name);
        Ability *getAbilityWithOutput(const std::string &output_name);
        
    protected:

        std::map<std::string, Ability*> ability_map;
        AbilityMap ability_name_map;

        MTLock mainLock;
};

}


#endif