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