entity.h

Go to the documentation of this file.

 
#ifndef ENTITY_H
#define ENTITY_H
 
namespace argos {
   class CEntity;
   class CComposableEntity;
   class CSpace;
}
 
#include <argos3/core/utility/datatypes/datatypes.h>
#include <argos3/core/utility/configuration/argos_configuration.h>
#include <argos3/core/utility/configuration/base_configurable_resource.h>
#include <argos3/core/utility/plugins/factory.h>
#include <argos3/core/utility/plugins/vtable.h>
 
#include <vector>
#include <map>
#include <string>
 
#if defined(__apple_build_version__ )
// We are on Apple, check compiler version
# if __clang_major__ >= 5
  // XCode 5.0.0 or later
#  include <unordered_map>
using std::unordered_map;
# else
  // XCode 4.6.3 or earlier
#  include <tr1/unordered_map>
using std::tr1::unordered_map;
# endif
#else
// We are on Linux, use c++03 standard
# include <tr1/unordered_map>
using std::tr1::unordered_map;
#endif
 
namespace argos {
 
   class CEntity : public CBaseConfigurableResource,
                   public EnableVTableFor<CEntity> {
 
   public:
 
      ENABLE_VTABLE();
 
      typedef std::vector<CEntity*> TVector;
 
      typedef unordered_map<std::string, CEntity*> TMap;
 
      typedef std::multimap<std::string, CEntity*> TMultiMap;
 
   public:
 
      CEntity(CComposableEntity* pc_parent);
 
      CEntity(CComposableEntity* pc_parent,
              const std::string& str_id);
 
      virtual ~CEntity() {}
 
      virtual void Init(TConfigurationNode& t_tree);
 
      virtual void Reset() {}
 
      virtual void Destroy() {}
 
      inline const std::string& GetId() const {
         return m_strId;
      }
 
      std::string GetContext() const;
 
      inline bool HasParent() const {
         return (m_pcParent != NULL);
      }
 
      CEntity& GetRootEntity();
 
      const CEntity& GetRootEntity() const;
 
      CComposableEntity& GetParent();
 
      const CComposableEntity& GetParent() const;
 
      inline void SetParent(CComposableEntity& c_parent) {
         m_pcParent = &c_parent;
      }
 
      virtual std::string GetTypeDescription() const {
         return "entity";
      }
 
      virtual void Update() {}
 
      ssize_t GetIndex() const {
         return m_nIndex;
      }
 
      void SetIndex(ssize_t n_idx) {
         m_nIndex = n_idx;
      }
 
      bool IsEnabled() const {
         return m_bEnabled;
      }
 
      inline void Enable() {
         SetEnabled(true);
      }
 
      inline void Disable() {
         SetEnabled(false);
      }
 
      virtual void SetEnabled(bool b_enabled);
 
      TConfigurationNode* GetConfigurationNode() {
         return m_ptConfNode;
      }
 
   private:
 
      CComposableEntity* m_pcParent;
 
      std::string m_strId;
 
      ssize_t m_nIndex;
 
      bool m_bEnabled;
 
      TConfigurationNode* m_ptConfNode;
 
   };
 
   struct SEntityComparator {
      bool operator()(const CEntity* pc_a, const CEntity* pc_b) const {
         return pc_a->GetIndex() < pc_b->GetIndex();
      }
      bool operator()(const CEntity& c_a, const CEntity& c_b) const {
         return c_a.GetIndex() < c_b.GetIndex();
      }
   };
 
   template <typename LABEL, typename PLUGIN, typename RETURN_TYPE>
   class CEntityOperation {
   public:
      template <typename DERIVED, typename OPERATION_IMPL>
      RETURN_TYPE Hook(PLUGIN& t_plugin, CEntity& c_entity) {
         return Dispatch<DERIVED, OPERATION_IMPL>(t_plugin, c_entity);
      }
   protected:
      template <typename DERIVED, typename OPERATION_IMPL>
      RETURN_TYPE Dispatch(PLUGIN& t_plugin, CEntity& c_entity) {
         /* First dispatch: cast this operation into the specific operation */
         OPERATION_IMPL& tOperation = static_cast<OPERATION_IMPL&>(*this);
         /* Second dispatch: cast t_base to DERIVED */
         DERIVED& tDerived = static_cast<DERIVED&>(c_entity);
         /* Perform visit */
         return tOperation.ApplyTo(t_plugin, tDerived);
      }
   };
 
   struct SOperationOutcome {
      bool Value;
      SOperationOutcome() : Value(false) {}
      SOperationOutcome(bool b_value) : Value(b_value) {}
      bool operator()() const { return Value; }
   };
 
   template <typename LABEL, typename PLUGIN, typename RETURN_TYPE>
   class CEntityOperationInstanceHolder {
   public:
      ~CEntityOperationInstanceHolder() {
         while(!m_vecOperationInstances.empty()) {
            if(m_vecOperationInstances.back() != NULL) {
               delete m_vecOperationInstances.back();
            }
            m_vecOperationInstances.pop_back();
         }
      }
      template <typename DERIVED>
      void Add(CEntityOperation<LABEL, PLUGIN, RETURN_TYPE>* pc_operation) {
         /* Find the slot */
         size_t unIndex = GetTag<DERIVED, CEntity>();
         /* Does the holder have a slot for this index? */
         if(unIndex >= m_vecOperationInstances.size()) {
            /* No, new slots must be created
             * Fill the slots with NULL
             */
            /* Create new slots up to index+1 and fill them with tDefaultFunction */
            m_vecOperationInstances.resize(unIndex+1, NULL);
         }
         m_vecOperationInstances[unIndex] = pc_operation;
      }
      CEntityOperation<LABEL, PLUGIN, RETURN_TYPE>* operator[](size_t un_index) const {
         if(un_index >= m_vecOperationInstances.size()) {
            return NULL;
         }
         return m_vecOperationInstances[un_index];
      }
   private:
      std::vector<CEntityOperation<LABEL, PLUGIN, RETURN_TYPE>*> m_vecOperationInstances;
   };
   template <typename LABEL, typename PLUGIN, typename RETURN_VALUE>
   CEntityOperationInstanceHolder<LABEL, PLUGIN, RETURN_VALUE>& GetEntityOperationInstanceHolder() {
      static CEntityOperationInstanceHolder<LABEL, PLUGIN, RETURN_VALUE> cHolder;
      return cHolder;
   }
   template<typename LABEL, typename PLUGIN, typename RETURN_VALUE>
   RETURN_VALUE CallEntityOperation(PLUGIN& t_plugin, CEntity& c_entity) {
      typedef RETURN_VALUE (CEntityOperation<LABEL, PLUGIN, RETURN_VALUE>::*TFunction)(PLUGIN& t_plugin, CEntity&);
      TFunction tFunction = GetVTable<LABEL, CEntity, TFunction>()[c_entity.GetTag()];
      if(tFunction != NULL) {
         CEntityOperation<LABEL, PLUGIN, RETURN_VALUE>* pcOperation = GetEntityOperationInstanceHolder<LABEL, PLUGIN, RETURN_VALUE>()[c_entity.GetTag()];
         if(pcOperation != NULL) {
            return (pcOperation->*tFunction)(t_plugin, c_entity);
         }
      }
      return RETURN_VALUE();
   }
 
}
 
#define REGISTER_ENTITY(CLASSNAME,                  \
                        LABEL,                      \
                        AUTHOR,                     \
                        VERSION,                    \
                        BRIEF_DESCRIPTION,          \
                        LONG_DESCRIPTION,           \
                        STATUS)                     \
   REGISTER_SYMBOL(CEntity,                         \
                   CLASSNAME,                       \
                   LABEL,                           \
                   AUTHOR,                          \
                   VERSION,                         \
                   BRIEF_DESCRIPTION,               \
                   LONG_DESCRIPTION,                \
                   STATUS)
 
#define REGISTER_ENTITY_OPERATION(LABEL, PLUGIN, OPERATION, RETURN_VALUE, DERIVED)                         \
   class C ## LABEL ## PLUGIN ## OPERATION ## RETURN_VALUE ## DERIVED {                                    \
      typedef RETURN_VALUE (CEntityOperation<LABEL, PLUGIN, RETURN_VALUE>::*TFunction)(PLUGIN&, CEntity&); \
   public:                                                                                                 \
      C ## LABEL ## PLUGIN ## OPERATION ## RETURN_VALUE ## DERIVED() {                                     \
         GetVTable<LABEL, CEntity, TFunction>().Add<DERIVED>(&OPERATION::Hook<DERIVED, OPERATION>);        \
         GetEntityOperationInstanceHolder<LABEL, PLUGIN, RETURN_VALUE>().Add<DERIVED>(new OPERATION());    \
      }                                                                                                    \
   } c ## LABEL ## PLUGIN ## OPERATION ## RETURN_VALUE ## DERIVED;
 
#endif