Merge pull request #134 from zackthehuman/remove_components_on_destroy

Re-implement "Remove components on destroy" functionality

6 files changed, 214 insertions, 228 deletions

diff --git a/entityx/ComponentHandle.h b/entityx/ComponentHandle.h
deleted file mode 100644
index 9406705..0000000
--- a/entityx/ComponentHandle.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (C) 2012 Alec Thomas <alec@swapoff.org>
- * All rights reserved.
- *
- * This software is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.
- *
- * Author: Alec Thomas <alec@swapoff.org>
- */
-
-#pragma once
-
-namespace entityx {
-
-class EntityManager;
-
-/**
- * A ComponentHandle<C> is a wrapper around an instance of a component.
- *
- * It provides safe access to components. The handle will be invalidated under
- * the following conditions:
- *
- * - If a component is removed from its host entity.
- * - If its host entity is destroyed.
- */
-template <typename C, typename EM>
-class ComponentHandle {
-public:
-  typedef C ComponentType;
-
-  ComponentHandle() : manager_(nullptr) {}
-
-  bool valid() const;
-  operator bool() const;
-
-  C *operator -> ();
-  const C *operator -> () const;
-
-  C *get();
-  const C *get() const;
-
-  /**
-   * Remove the component from its entity and destroy it.
-   */
-  void remove();
-
-  bool operator == (const ComponentHandle<C> &other) const {
-    return manager_ == other.manager_ && id_ == other.id_;
-  }
-
-  bool operator != (const ComponentHandle<C> &other) const {
-    return !(*this == other);
-  }
-
-private:
-  friend class EntityManager;
-
-  ComponentHandle(EM *manager, Entity::Id id) :
-      manager_(manager), id_(id) {}
-
-  EM *manager_;
-  Entity::Id id_;
-};
-
-}
diff --git a/entityx/Entity.cc b/entityx/Entity.cc
index 5461ca7..ddb8df7 100644
--- a/entityx/Entity.cc
+++ b/entityx/Entity.cc
@@ -43,7 +43,11 @@ void EntityManager::reset() {
   for (BasePool *pool : component_pools_) {
     if (pool) delete pool;
   }
+  for (BaseComponentHelper *helper : component_helpers_) {
+    if (helper) delete helper;
+  }
   component_pools_.clear();
+  component_helpers_.clear();
   entity_component_mask_.clear();
   entity_version_.clear();
   free_list_.clear();
diff --git a/entityx/Entity.h b/entityx/Entity.h
index 5e9b17d..06854e3 100644
--- a/entityx/Entity.h
+++ b/entityx/Entity.h
@@ -27,14 +27,12 @@
 #include <utility>
 #include <vector>
 #include <type_traits>
-#include <functional>
+ #include <functional>
 
 #include "entityx/help/Pool.h"
-#include "entityx/EntityClass.h"
 #include "entityx/config.h"
 #include "entityx/Event.h"
 #include "entityx/help/NonCopyable.h"
-#include "entityx/ComponentHandle.h"
 
 namespace entityx {
 
@@ -43,6 +41,185 @@ typedef std::uint64_t uint64_t;
 
 class EntityManager;
 
+
+template <typename C, typename EM = EntityManager>
+class ComponentHandle;
+
+
+
+/** A convenience handle around an Entity::Id.
+ *
+ * If an entity is destroyed, any copies will be invalidated. Use valid() to
+ * check for validity before using.
+ *
+ * Create entities with `EntityManager`:
+ *
+ *     Entity entity = entity_manager->create();
+ */
+class Entity {
+public:
+  struct Id {
+    Id() : id_(0) {}
+    explicit Id(uint64_t id) : id_(id) {}
+    Id(uint32_t index, uint32_t version) : id_(uint64_t(index) | uint64_t(version) << 32UL) {}
+
+    uint64_t id() const { return id_; }
+
+    bool operator == (const Id &other) const { return id_ == other.id_; }
+    bool operator != (const Id &other) const { return id_ != other.id_; }
+    bool operator < (const Id &other) const { return id_ < other.id_; }
+
+    uint32_t index() const { return id_ & 0xffffffffUL; }
+    uint32_t version() const { return id_ >> 32; }
+
+  private:
+    friend class EntityManager;
+
+    uint64_t id_;
+  };
+
+
+  /**
+   * Id of an invalid Entity.
+   */
+  static const Id INVALID;
+
+  Entity() = default;
+  Entity(EntityManager *manager, Entity::Id id) : manager_(manager), id_(id) {}
+  Entity(const Entity &other) = default;
+  Entity &operator = (const Entity &other) = default;
+
+  /**
+   * Check if Entity handle is invalid.
+   */
+  operator bool() const {
+    return valid();
+  }
+
+  bool operator == (const Entity &other) const {
+    return other.manager_ == manager_ && other.id_ == id_;
+  }
+
+  bool operator != (const Entity &other) const {
+    return !(other == *this);
+  }
+
+  bool operator < (const Entity &other) const {
+    return other.id_ < id_;
+  }
+
+  /**
+   * Is this Entity handle valid?
+   *
+   * In older versions of EntityX, there were no guarantees around entity
+   * validity if a previously allocated entity slot was reassigned. That is no
+   * longer the case: if a slot is reassigned, old Entity::Id's will be
+   * invalid.
+   */
+  bool valid() const;
+
+  /**
+   * Invalidate Entity handle, disassociating it from an EntityManager and invalidating its ID.
+   *
+   * Note that this does *not* affect the underlying entity and its
+   * components. Use destroy() to destroy the associated Entity and components.
+   */
+  void invalidate();
+
+  Id id() const { return id_; }
+
+  template <typename C, typename ... Args>
+  ComponentHandle<C> assign(Args && ... args);
+
+  template <typename C>
+  ComponentHandle<C> assign_from_copy(const C &component);
+
+  template <typename C, typename ... Args>
+  ComponentHandle<C> replace(Args && ... args);
+
+  template <typename C>
+  void remove();
+
+  template <typename C, typename = typename std::enable_if<!std::is_const<C>::value>::type>
+  ComponentHandle<C> component();
+
+  template <typename C, typename = typename std::enable_if<std::is_const<C>::value>::type>
+  const ComponentHandle<C, const EntityManager> component() const;
+
+  template <typename ... Components>
+  std::tuple<ComponentHandle<Components>...> components();
+
+  template <typename ... Components>
+  std::tuple<ComponentHandle<const Components, const EntityManager>...> components() const;
+
+  template <typename C>
+  bool has_component() const;
+
+  template <typename A, typename ... Args>
+  void unpack(ComponentHandle<A> &a, ComponentHandle<Args> & ... args);
+
+  /**
+   * Destroy and invalidate this Entity.
+   */
+  void destroy();
+
+  std::bitset<entityx::MAX_COMPONENTS> component_mask() const;
+
+ private:
+  EntityManager *manager_ = nullptr;
+  Entity::Id id_ = INVALID;
+};
+
+
+/**
+ * A ComponentHandle<C> is a wrapper around an instance of a component.
+ *
+ * It provides safe access to components. The handle will be invalidated under
+ * the following conditions:
+ *
+ * - If a component is removed from its host entity.
+ * - If its host entity is destroyed.
+ */
+template <typename C, typename EM>
+class ComponentHandle {
+public:
+  typedef C ComponentType;
+
+  ComponentHandle() : manager_(nullptr) {}
+
+  bool valid() const;
+  operator bool() const;
+
+  C *operator -> ();
+  const C *operator -> () const;
+
+  C *get();
+  const C *get() const;
+
+  /**
+   * Remove the component from its entity and destroy it.
+   */
+  void remove();
+
+  bool operator == (const ComponentHandle<C> &other) const {
+    return manager_ == other.manager_ && id_ == other.id_;
+  }
+
+  bool operator != (const ComponentHandle<C> &other) const {
+    return !(*this == other);
+  }
+
+private:
+  friend class EntityManager;
+
+  ComponentHandle(EM *manager, Entity::Id id) :
+      manager_(manager), id_(id) {}
+
+  EM *manager_;
+  Entity::Id id_;
+};
+
+
 /**
  * Base component class, only used for insertion into collections.
  *
@@ -148,6 +325,22 @@ struct ComponentRemovedEvent : public Event<ComponentRemovedEvent<C>> {
   ComponentHandle<C> component;
 };
 
+/**
+ * Helper class to perform component operations in a typed manner.
+ */
+class BaseComponentHelper {
+public:
+  virtual ~BaseComponentHelper() {}
+  virtual void remove_component(Entity e) = 0;
+};
+
+template <typename C>
+class ComponentHelper : public BaseComponentHelper {
+public:
+  void remove_component(Entity e) override {
+    e.remove<C>();
+  }
+};
 
 /**
  * Manages Entity::Id creation and component assignment.
@@ -381,12 +574,10 @@ class EntityManager : entityx::help::NonCopyable {
     assert_valid(entity);
     uint32_t index = entity.index();
     auto mask = entity_component_mask_[entity.index()];
-    for (size_t i = 0; i < component_pools_.size(); i++) {
-      BasePool *pool = component_pools_[i];
-      if (pool && mask.test(i)) {
-        pool->remove_component(Entity(this, entity));
-        pool->destroy(index);
-      }
+    for (size_t i = 0; i < component_helpers_.size(); i++) {
+      BaseComponentHelper *helper = component_helpers_[i];
+      if (helper && mask.test(i))
+        helper->remove_component(Entity(this, entity));
     }
     event_manager_.emit<EntityDestroyedEvent>(Entity(this, entity));
     entity_component_mask_[index].reset();
@@ -685,6 +876,13 @@ class EntityManager : entityx::help::NonCopyable {
       pool->expand(index_counter_);
       component_pools_[family] = pool;
     }
+    if (component_helpers_.size() <= family) {
+      component_helpers_.resize(family + 1, nullptr);
+    }
+    if (!component_helpers_[family]) {
+      ComponentHelper<C> *helper = new ComponentHelper<C>();
+      component_helpers_[family] = helper;
+    }
     return static_cast<Pool<C>*>(component_pools_[family]);
   }
 
@@ -695,6 +893,9 @@ class EntityManager : entityx::help::NonCopyable {
   // Each element in component_pools_ corresponds to a Pool for a Component.
   // The index into the vector is the Component::family().
   std::vector<BasePool*> component_pools_;
+  // Each element in component_helpers_ corresponds to a ComponentHelper for a Component type.
+  // The index into the vector is the Component::family().
+  std::vector<BaseComponentHelper*> component_helpers_;
   // Bitmask of components associated with each entity. Index into the vector is the Entity::Id.
   std::vector<ComponentMask> entity_component_mask_;
   // Vector of entity version numbers. Incremented each time an entity is destroyed
diff --git a/entityx/EntityClass.h b/entityx/EntityClass.h
deleted file mode 100644
index 94a2a02..0000000
--- a/entityx/EntityClass.h
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- * Copyright (C) 2012 Alec Thomas <alec@swapoff.org>
- * All rights reserved.
- *
- * This software is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.
- *
- * Author: Alec Thomas <alec@swapoff.org>
- */
-
-#pragma once
-
-#include <bitset>
-#include "entityx/config.h"
-
-namespace entityx {
-
-class EntityManager;
-
-template <typename C, typename EM = EntityManager>
-class ComponentHandle;
-
-/** A convenience handle around an Entity::Id.
- *
- * If an entity is destroyed, any copies will be invalidated. Use valid() to
- * check for validity before using.
- *
- * Create entities with `EntityManager`:
- *
- *     Entity entity = entity_manager->create();
- */
-class Entity {
-public:
-  struct Id {
-    Id() : id_(0) {}
-    explicit Id(uint64_t id) : id_(id) {}
-    Id(uint32_t index, uint32_t version) : id_(uint64_t(index) | uint64_t(version) << 32UL) {}
-
-    uint64_t id() const { return id_; }
-
-    bool operator == (const Id &other) const { return id_ == other.id_; }
-    bool operator != (const Id &other) const { return id_ != other.id_; }
-    bool operator < (const Id &other) const { return id_ < other.id_; }
-
-    uint32_t index() const { return id_ & 0xffffffffUL; }
-    uint32_t version() const { return id_ >> 32; }
-
-  private:
-    friend class EntityManager;
-
-    uint64_t id_;
-  };
-
-
-  /**
-   * Id of an invalid Entity.
-   */
-  static const Id INVALID;
-
-  Entity() = default;
-  Entity(EntityManager *manager, Entity::Id id) : manager_(manager), id_(id) {}
-  Entity(const Entity &other) = default;
-  Entity &operator = (const Entity &other) = default;
-
-  /**
-   * Check if Entity handle is invalid.
-   */
-  operator bool() const {
-    return valid();
-  }
-
-  bool operator == (const Entity &other) const {
-    return other.manager_ == manager_ && other.id_ == id_;
-  }
-
-  bool operator != (const Entity &other) const {
-    return !(other == *this);
-  }
-
-  bool operator < (const Entity &other) const {
-    return other.id_ < id_;
-  }
-
-  /**
-   * Is this Entity handle valid?
-   *
-   * In older versions of EntityX, there were no guarantees around entity
-   * validity if a previously allocated entity slot was reassigned. That is no
-   * longer the case: if a slot is reassigned, old Entity::Id's will be
-   * invalid.
-   */
-  bool valid() const;
-
-  /**
-   * Invalidate Entity handle, disassociating it from an EntityManager and invalidating its ID.
-   *
-   * Note that this does *not* affect the underlying entity and its
-   * components. Use destroy() to destroy the associated Entity and components.
-   */
-  void invalidate();
-
-  Id id() const { return id_; }
-
-  template <typename C, typename ... Args>
-  ComponentHandle<C> assign(Args && ... args);
-
-  template <typename C>
-  ComponentHandle<C> assign_from_copy(const C &component);
-
-  template <typename C, typename ... Args>
-  ComponentHandle<C> replace(Args && ... args);
-
-  template <typename C>
-  void remove();
-
-  template <typename C, typename = typename std::enable_if<!std::is_const<C>::value>::type>
-  ComponentHandle<C> component();
-
-  template <typename C, typename = typename std::enable_if<std::is_const<C>::value>::type>
-  const ComponentHandle<C, const EntityManager> component() const;
-
-  template <typename ... Components>
-  std::tuple<ComponentHandle<Components>...> components();
-
-  template <typename ... Components>
-  std::tuple<ComponentHandle<const Components, const EntityManager>...> components() const;
-
-  template <typename C>
-  bool has_component() const;
-
-  template <typename A, typename ... Args>
-  void unpack(ComponentHandle<A> &a, ComponentHandle<Args> & ... args);
-
-  /**
-   * Destroy and invalidate this Entity.
-   */
-  void destroy();
-
-  std::bitset<entityx::MAX_COMPONENTS> component_mask() const;
-
- private:
-  EntityManager *manager_ = nullptr;
-  Entity::Id id_ = INVALID;
-};
-
-}
diff --git a/entityx/help/Pool.h b/entityx/help/Pool.h
index b28e4e7..f217ec2 100644
--- a/entityx/help/Pool.h
+++ b/entityx/help/Pool.h
@@ -14,8 +14,6 @@
 #include <cassert>
 #include <vector>
 
-#include "entityx/EntityClass.h"
-
 namespace entityx {
 
 /**
@@ -65,7 +63,6 @@ class BasePool {
   }
 
   virtual void destroy(std::size_t n) = 0;
-  virtual void remove_component(Entity entity) = 0;
 
  protected:
   std::vector<char *> blocks_;
@@ -93,10 +90,6 @@ class Pool : public BasePool {
     T *ptr = static_cast<T*>(get(n));
     ptr->~T();
   }
-
-  virtual void remove_component(Entity entity) override {
-    entity.remove<T>();
-  }
 };
 
 }  // namespace entityx
diff --git a/entityx/help/Pool_test.cc b/entityx/help/Pool_test.cc
index 1092068..56ca85a 100644
--- a/entityx/help/Pool_test.cc
+++ b/entityx/help/Pool_test.cc
@@ -13,7 +13,6 @@
 #include <vector>
 #include "entityx/3rdparty/catch.hpp"
 #include "entityx/help/Pool.h"
-#include "entityx/Entity.h"
 
 struct Position {
   explicit Position(int *ptr = nullptr) : ptr(ptr) {