composable_entity.h

Go to the documentation of this file.

 
#ifndef COMPOSABLE_ENTITY_H
#define COMPOSABLE_ENTITY_H
 
namespace argos {
   class CComposableEntity;
}
 
#include <argos3/core/simulator/entity/entity.h>
#include <argos3/core/simulator/space/space.h>
 
namespace argos {
 
   class CComposableEntity : public CEntity {
 
   public:
 
      ENABLE_VTABLE();
 
   public:
 
      CComposableEntity(CComposableEntity* pc_parent);
 
      CComposableEntity(CComposableEntity* pc_parent,
                        const std::string& str_id);
 
      virtual ~CComposableEntity() {}
 
      virtual void Reset();
 
      virtual void Update();
 
      virtual std::string GetTypeDescription() const {
         return "composite";
      }
 
      virtual void SetEnabled(bool b_enabled);
 
      virtual void UpdateComponents();
 
      void AddComponent(CEntity& c_component);
 
      CEntity& RemoveComponent(const std::string& str_component);
 
      CEntity& GetComponent(const std::string& str_component);
 
      template <class E>
      E& GetComponent(const std::string& str_component) {
         E* pcComponent = dynamic_cast<E*>(&GetComponent(str_component));
         if(pcComponent != NULL) {
            return *pcComponent;
         }
         else {
            THROW_ARGOSEXCEPTION("Type conversion failed for component type \"" << str_component << "\" of entity \"" << GetId());
         }
      }
 
      bool HasComponent(const std::string& str_component);
 
      CEntity::TMultiMap::iterator FindComponent(const std::string& str_component);
 
      inline CEntity::TMultiMap& GetComponentMap() {
         return m_mapComponents;
      }
 
      inline CEntity::TVector& GetComponentVector() {
         return m_vecComponents;
      }
 
   private:
 
      CEntity::TMultiMap m_mapComponents;
      CEntity::TVector m_vecComponents;
 
   };
 
#define SPACE_OPERATION_ADD_COMPOSABLE_ENTITY(ENTITY)                                                               \
   class CSpaceOperationAdd ## ENTITY : public CSpaceOperationAddEntity {                                           \
   public:                                                                                                          \
   void ApplyTo(CSpace& c_space, ENTITY& c_entity) {                                                                \
      c_space.AddEntity(c_entity);                                                                                  \
      for(size_t i = 0; i < c_entity.GetComponentVector().size(); ++i) {                                         \
         CallEntityOperation<CSpaceOperationAddEntity, CSpace, void>(c_space, *(c_entity.GetComponentVector()[i])); \
      }                                                                                                             \
   }                                                                                                                \
   };
 
#define SPACE_OPERATION_REMOVE_COMPOSABLE_ENTITY(ENTITY)                \
   class CSpaceOperationRemove ## ENTITY : public CSpaceOperationRemoveEntity { \
   public:                                                              \
   void ApplyTo(CSpace& c_space, ENTITY& c_entity) {                    \
      CEntity* pcToRemove;                                              \
      while(!c_entity.GetComponentVector().empty()) {                   \
         pcToRemove = c_entity.GetComponentVector().back();             \
         c_entity.RemoveComponent(pcToRemove->GetTypeDescription() + "[" + pcToRemove->GetId() + "]"); \
         CallEntityOperation<CSpaceOperationRemoveEntity, CSpace, void>(c_space, *pcToRemove); \
      }                                                                 \
      c_space.RemoveEntity(c_entity);                                   \
   }                                                                    \
   };
 
#define REGISTER_STANDARD_SPACE_OPERATION_ADD_COMPOSABLE(ENTITY)        \
   SPACE_OPERATION_ADD_COMPOSABLE_ENTITY(ENTITY)                        \
   REGISTER_SPACE_OPERATION(CSpaceOperationAddEntity,                   \
                            CSpaceOperationAdd ## ENTITY,               \
                            ENTITY);
 
#define REGISTER_STANDARD_SPACE_OPERATION_REMOVE_COMPOSABLE(ENTITY)        \
   SPACE_OPERATION_REMOVE_COMPOSABLE_ENTITY(ENTITY)                        \
   REGISTER_SPACE_OPERATION(CSpaceOperationRemoveEntity,                   \
                            CSpaceOperationRemove ## ENTITY,               \
                            ENTITY);
 
#define REGISTER_STANDARD_SPACE_OPERATIONS_ON_COMPOSABLE(ENTITY)  \
   REGISTER_STANDARD_SPACE_OPERATION_ADD_COMPOSABLE(ENTITY)       \
   REGISTER_STANDARD_SPACE_OPERATION_REMOVE_COMPOSABLE(ENTITY)
 
}
 
#endif