Remove verify method to remove vtable on components

Author: SgtCoDFish

include/Ashley/core/Component.hpp

@@ -33,18 +33,14 @@ namespace ashley {
  */
 class Component {
 public:
-	Component() {
+	explicit Component() {
 	}
 
-	virtual ~Component() = default;
+	~Component() = default;
 	Component(const Component &other) = default;
 	Component(Component &&other) = default;
 	Component& operator=(const Component &other) = default;
 	Component& operator=(Component &&other) = default;
-
-	virtual std::type_index identify() const {
-		return std::type_index(typeid(*this));
-	}
 };
 }
 

include/Ashley/core/Engine.hpp

@@ -250,7 +250,7 @@ class Engine {
 		virtual ~EngineOperationHandler() {
 		}
 
-		virtual void add(ashley::Entity * const entity, std::unique_ptr<Component> &component)
+		virtual void add(ashley::Entity * const entity, std::unique_ptr<Component> &&component, const std::type_index typeIndex)
 				override;
 		virtual void remove(ashley::Entity * const entity, const std::type_index typeIndex)
 				override;

include/Ashley/core/Entity.hpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright 2014 See AUTHORS file.
+ * Copyright 2014, 2015 See AUTHORS file.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,21 +14,23 @@
  * limitations under the License.
  ******************************************************************************/
 
-#ifndef ENTITY_HPP_
-#define ENTITY_HPP_
+#ifndef ACPP_ENTITY_HPP_
+#define ACPP_ENTITY_HPP_
 
 #include <bitset>
 #include <cstdint>
 #include <memory>
 #include <typeindex>
 #include <unordered_map>
 #include <vector>
+#include <type_traits>
 
 #include "Ashley/AshleyConstants.hpp"
 #include "Ashley/core/Component.hpp"
 #include "Ashley/core/ComponentType.hpp"
-#include "Ashley/internal/ComponentOperations.hpp"
 #include "Ashley/signals/Signal.hpp"
+#include "Ashley/internal/ComponentOperations.hpp"
+#include "Ashley/internal/Helper.hpp"
 
 namespace ashley {
 
@@ -77,7 +79,19 @@ class Entity {
 	 * @param component the component to add.
 	 * @return this {@link Entity} for chaining.
 	 */
-	Entity &add(std::unique_ptr<Component> &&component);
+	template<typename C> Entity &add(std::unique_ptr<C> &&component) {
+		internal::verify_component_type<C>();
+
+		auto typeIndex = std::type_index(typeid(C));
+
+		if (operationHandler != nullptr) {
+			operationHandler->add(this, std::move(component), typeIndex);
+		} else {
+			addInternal(std::move(component), typeIndex);
+		}
+
+		return *this;
+	}
 
 	/**
 	 * <p>Constructs a new object of type C (subclassing ashley::Component) using <em>args...</em> for construction.</p>
@@ -87,15 +101,20 @@ class Entity {
 	 * @return This {@link Entity} for easy chaining
 	 */
 	template<typename C, typename ...Args> Entity &add(Args&&... args) {
-		auto mapPtr = std::unique_ptr<Component>(new C(args...));
+		internal::verify_component_type<C>();
 
-		if (operationHandler != nullptr) {
-			operationHandler->add(this, mapPtr);
+		const auto typeIndex = std::type_index(typeid(C));
+		auto component = std::unique_ptr<Component>(new C(args...));
+
+		if(operationHandler != nullptr) {
+			operationHandler->add(this, std::move(component), typeIndex);
 		} else {
-			addInternal(mapPtr);
+			addInternal(std::move(component), typeIndex);
 		}
 
 		return *this;
+
+//		return add<C>(std::unique_ptr<C>(new C(args...)));
 	}
 
 	/**
@@ -106,14 +125,6 @@ class Entity {
 	 */
 	std::unique_ptr<Component> remove(const std::type_index typeIndex);
 
-	/**
-	 * <p>Removes the given {@link Component}, if it's found attached to this {@link Entity}.
-	 * @param component the {@link Component} to remove.
-	 * @return the removed {@link Component}'s unique_ptr if the component was removed straight away; or nullptr if not
-	 * found or if the removal has been delayed (e.g. when we're already in update() and need to wait to the end)
-	 */
-	std::unique_ptr<Component> remove(Component * const component);
-
 	/**
 	 * <p>Removes the {@link Component} of the specified type. Since there is only ever one component of one type, we
 	 * don't need an instance, just the type.</p>
@@ -160,6 +171,8 @@ class Entity {
 	 * no such component.
 	 */
 	template<typename C> C* getComponent() {
+		internal::verify_component_type<C>();
+
 		auto type = std::type_index(typeid(C));
 		auto id = ashley::ComponentType::getIndexFor(type);
 
@@ -255,7 +268,7 @@ class Entity {
 
 	ComponentOperationHandler *operationHandler = nullptr, *operationHandlerTemp = nullptr;
 
-	void addInternal(std::unique_ptr<Component> &component);
+	void addInternal(std::unique_ptr<Component> &&component, std::type_index type);
 
 	std::unique_ptr<Component> removeImpl(std::type_index typeIndex);
 

include/Ashley/internal/ComponentOperations.hpp

@@ -14,8 +14,8 @@
  * limitations under the License.
  ******************************************************************************/
 
-#ifndef COMPONENTOPERATIONS_HPP_
-#define COMPONENTOPERATIONS_HPP_
+#ifndef ACPP_COMPONENTOPERATIONS_HPP_
+#define ACPP_COMPONENTOPERATIONS_HPP_
 
 #include <memory>
 
@@ -35,7 +35,7 @@ class ComponentOperationHandler {
 	virtual ~ComponentOperationHandler() {
 	}
 
-	virtual void add(ashley::Entity * const entity, std::unique_ptr<Component> &component) = 0;
+	virtual void add(ashley::Entity * const entity, std::unique_ptr<Component> &&component, const std::type_index typeIndex) = 0;
 	virtual void remove(ashley::Entity * const entity, const std::type_index typeIndex) = 0;
 };
 
@@ -62,11 +62,14 @@ struct ComponentOperation : public ashley::Poolable {
 	virtual ~ComponentOperation() {
 	}
 
-	inline void makeAdd(ashley::Entity *entity, std::unique_ptr<Component> &component) {
+	// TODO: Remove use of "new" here
+
+	inline void makeAdd(ashley::Entity *entity, std::unique_ptr<Component> &&component, const std::type_index typeIndex) {
 		this->type = Type::ADD;
 
 		this->entity = entity;
 		this->component = std::move(component);
+		this->typeIndex = std::unique_ptr<std::type_index>(new std::type_index(typeIndex));
 	}
 
 	inline void makeRemove(ashley::Entity *entity, const std::type_index typeIndex) {

include/Ashley/internal/Helper.hpp

@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * Copyright 2014, 2015 See AUTHORS file.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ ******************************************************************************/
+
+#ifndef INCLUDE_ASHLEY_INTERNAL_HELPER_HPP_
+#define INCLUDE_ASHLEY_INTERNAL_HELPER_HPP_
+
+#include <typeinfo>
+#include <typeindex>
+#include <type_traits>
+
+#include "Ashley/core/Component.hpp"
+
+namespace ashley {
+namespace internal {
+
+template<typename C> const char *get_friendly_type_name() {
+	return std::type_index(typeid(C)).name();
+}
+
+template<typename C> inline void verify_component_type() {
+	static_assert(std::is_base_of<ashley::Component, C>(), "Component verification failed.");
+}
+
+}
+}
+
+#endif /* INCLUDE_ASHLEY_INTERNAL_HELPER_HPP_ */

src/Engine.cpp

@@ -238,7 +238,7 @@ void ashley::Engine::processComponentOperations() {
 
 		switch (operation->type) {
 		case ComponentOperation::Type::ADD: {
-			operation->entity->addInternal(operation->component);
+			operation->entity->addInternal(std::move(operation->component), *(operation->typeIndex));
 			break;
 		}
 
@@ -247,9 +247,9 @@ void ashley::Engine::processComponentOperations() {
 			break;
 		}
 
-		default: {
-			throw std::bad_function_call();
-			return;
+		case ComponentOperation::Type::NONE: {
+			assert(false);
+			break;
 		}
 		}
 
@@ -327,15 +327,14 @@ void ashley::Engine::removeEntityInternal(Entity * const entity) {
 }
 
 void ashley::Engine::EngineOperationHandler::add(ashley::Entity * const entity,
-		std::unique_ptr<Component> &component) {
+		std::unique_ptr<Component> &&component, const std::type_index typeIndex) {
 	if (engine->updating) {
 		auto operation = engine->operationPool.obtain();
-		operation->makeAdd(entity, component);
+		operation->makeAdd(entity, std::move(component), typeIndex);
 		engine->operationVector.push_back(operation);
 	} else {
-		entity->addInternal(component);
+		entity->addInternal(std::move(component), typeIndex);
 	}
-
 }
 
 void ashley::Engine::EngineOperationHandler::remove(ashley::Entity * const entity,

src/Entity.cpp

@@ -35,27 +35,12 @@ ashley::Entity::Entity() :
 		index(nextIndex++) {
 }
 
-ashley::Entity &ashley::Entity::add(std::unique_ptr<Component> &&component) {
-	if (operationHandler != nullptr) {
-		operationHandler->add(this, component);
-	} else {
-		addInternal(component);
-	}
-
-	return *this;
-}
-
 std::unique_ptr<ashley::Component> ashley::Entity::remove(const std::type_index typeIndex) {
 	try {
 		return removeImpl(typeIndex);
 	} catch (std::out_of_range &oor) {
 		return std::unique_ptr<Component> { nullptr };
 	}
-
-}
-
-std::unique_ptr<ashley::Component> ashley::Entity::remove(Component * const component) {
-	return remove(component->identify());
 }
 
 void ashley::Entity::removeAll() {
@@ -79,8 +64,7 @@ const ashley::BitsType &ashley::Entity::getComponentBits() const {
 	return componentBits;
 }
 
-void ashley::Entity::addInternal(std::unique_ptr<Component> &component) {
-	auto type = component->identify();
+void ashley::Entity::addInternal(std::unique_ptr<Component> &&component, std::type_index type) {
 	auto typeID = ashley::ComponentType::getIndexFor(type);
 
 	if (componentBits[typeID]) {

test/AshleyTestCommon.hpp

@@ -33,11 +33,11 @@ class PositionComponent : public ashley::Component {
 	int64_t x;
 	int64_t y;
 
-	PositionComponent() :
+	explicit PositionComponent() :
 			PositionComponent(0, 0) {
 	}
 
-	PositionComponent(int64_t x, int64_t y) :
+	explicit PositionComponent(int64_t x, int64_t y) :
 			x(x), y(y) {
 	}
 };
@@ -50,11 +50,11 @@ class VelocityComponent : public ashley::Component {
 	int64_t x;
 	int64_t y;
 
-	VelocityComponent() :
+	explicit VelocityComponent() :
 			VelocityComponent(0, 0) {
 	}
 
-	VelocityComponent(int64_t x, int64_t y) :
+	explicit VelocityComponent(int64_t x, int64_t y) :
 			x(x), y(y) {
 	}
 };

test/core/ComponentTypeTest.cpp

@@ -25,8 +25,6 @@
 // Ensures a valid type is returned when a call is made to the various getFor() functions, and that this type is the same in the various functions.
 // Note that this covers both the validComponentType and sameComponentType tests in the Java version
 TEST(ComponentTypeTest, ValidComponentTypes) {
-	auto pos = ashley::test::PositionComponent(5, 2);
-
 	auto type1 = ashley::ComponentType::getFor(typeid(ashley::test::PositionComponent)); // std::type_info
 	auto type2 = ashley::ComponentType::getFor(
 			std::type_index(typeid(ashley::test::PositionComponent))); // std::type_index
@@ -38,8 +36,6 @@ TEST(ComponentTypeTest, ValidComponentTypes) {
 
 // Ensures a valid and consistent index is returned when a call is made to the various getIndexFor() functions
 TEST(ComponentTypeTest, ValidComponentIndexTypes) {
-	auto pos = ashley::test::PositionComponent(5, 2);
-
 	auto id1 = ashley::ComponentType::getIndexFor(typeid(ashley::test::PositionComponent));
 	auto id2 = ashley::ComponentType::getIndexFor(
 			std::type_index(typeid(ashley::test::PositionComponent)));