Formatter

Author: SgtCoDFish

include/Ashley/core/ComponentMapper.hpp

@@ -76,7 +76,7 @@ template<typename T> class ComponentMapper {
 private:
 	const ashley::ComponentType componentType;
 	explicit ComponentMapper(std::type_index componentClass) :
-			componentType(ashley::ComponentType::getFor(componentClass)) {
+			        componentType(ashley::ComponentType::getFor(componentClass)) {
 	}
 };
 }

include/Ashley/core/Engine.hpp

@@ -179,7 +179,7 @@ class Engine {
 	void update(float deltaTime);
 
 	static bool systemPriorityComparator(const std::unique_ptr<EntitySystem> &one,
-			const std::unique_ptr<EntitySystem> &other);
+	        const std::unique_ptr<EntitySystem> &other);
 
 private:
 	std::vector<std::unique_ptr<Entity>> entities;
@@ -215,11 +215,10 @@ class Engine {
 	class AddedListener : public ashley::Listener<Entity> {
 	public:
 		AddedListener(Engine * const engine) :
-				engine(engine) {
+				        engine(engine) {
 		}
 
-		virtual void receive(ashley::Signal<ashley::Entity> * const signal, ashley::Entity *object)
-				override {
+		virtual void receive(ashley::Signal<ashley::Entity> * const signal, ashley::Entity *object) override {
 			engine->updateFamilyMembership(*object);
 		}
 
@@ -230,11 +229,10 @@ class Engine {
 	class RemovedListener : public ashley::Listener<Entity> {
 	public:
 		RemovedListener(Engine * const engine) :
-				engine(engine) {
+				        engine(engine) {
 		}
 
-		virtual void receive(ashley::Signal<ashley::Entity> * const signal, ashley::Entity *object)
-				override {
+		virtual void receive(ashley::Signal<ashley::Entity> * const signal, ashley::Entity *object) override {
 			engine->updateFamilyMembership(*object);
 		}
 
@@ -245,15 +243,14 @@ class Engine {
 	class EngineOperationHandler : public ashley::ComponentOperationHandler {
 	public:
 		EngineOperationHandler(Engine *engine) :
-				engine(engine) {
+				        engine(engine) {
 		}
 		virtual ~EngineOperationHandler() {
 		}
 
-		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;
+		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;
 
 	private:
 		Engine *engine = nullptr;

include/Ashley/core/Entity.hpp

@@ -106,7 +106,7 @@ class Entity {
 		const auto typeIndex = std::type_index(typeid(C));
 		auto component = std::unique_ptr<Component>(new C(args...));
 
-		if(operationHandler != nullptr) {
+		if (operationHandler != nullptr) {
 			operationHandler->add(this, std::move(component), typeIndex);
 		} else {
 			addInternal(std::move(component), typeIndex);

include/Ashley/core/EntitySystem.hpp

@@ -14,7 +14,6 @@
  * limitations under the License.
  ******************************************************************************/
 
-
 #ifndef ENTITYSYSTEM_HPP_
 #define ENTITYSYSTEM_HPP_
 
@@ -56,7 +55,7 @@ class EntitySystem {
 	 * Default constructor that will initialise an EntitySystem with priority 0.
 	 */
 	EntitySystem() :
-			EntitySystem(DEFAULT_PRIORITY) {
+			        EntitySystem(DEFAULT_PRIORITY) {
 	}
 
 	/**
@@ -65,7 +64,8 @@ class EntitySystem {
 	 */
 
 	explicit EntitySystem(uint64_t priority) :
-			processing(true), priority(priority) {
+			        processing(true),
+			        priority(priority) {
 	}
 
 	/**

include/Ashley/core/Family.hpp

@@ -73,8 +73,7 @@ class Family {
 	 * @param exclude entities cannot contain any of the components in the set. See {@link ComponentType#getBitsFor}.
 	 * @return The family
 	 */
-	static Family *getFor(ashley::BitsType all, ashley::BitsType one,
-			ashley::BitsType exclude);
+	static Family *getFor(ashley::BitsType all, ashley::BitsType one, ashley::BitsType exclude);
 
 	/**
 	 * @return This family's unique index
@@ -92,9 +91,9 @@ class Family {
 	 * <p>Note that use_getFor_not_constructor is a private struct defined in Family; this means you cannot call this constructor and shouldn't try to.</p>
 	 * <p>Use the various getFor methods to retrieve Family instances, not this.</p>
 	 */
-	explicit Family(const Family::use_getFor_not_constructor&, ashley::BitsType all,
-			ashley::BitsType one, ashley::BitsType exclude) :
-			Family(all, one, exclude) {
+	explicit Family(const Family::use_getFor_not_constructor&, ashley::BitsType all, ashley::BitsType one,
+	        ashley::BitsType exclude) :
+			        Family(all, one, exclude) {
 	}
 
 	/**
@@ -126,11 +125,13 @@ class Family {
 	uint64_t index;
 
 	Family(ashley::BitsType all, ashley::BitsType one, ashley::BitsType exclude) :
-			all(all), one(one), exclude(exclude), index(familyIndex++) {
+			        all(all),
+			        one(one),
+			        exclude(exclude),
+			        index(familyIndex++) {
 	}
 
-	static FamilyHashType getFamilyHash(ashley::BitsType all, ashley::BitsType one,
-			ashley::BitsType exclude);
+	static FamilyHashType getFamilyHash(ashley::BitsType all, ashley::BitsType one, ashley::BitsType exclude);
 
 	// friend to allow hash function to be calculated
 	friend struct std::hash<ashley::Family>;

include/Ashley/internal/ComponentOperations.hpp

@@ -35,7 +35,8 @@ class ComponentOperationHandler {
 	virtual ~ComponentOperationHandler() {
 	}
 
-	virtual void add(ashley::Entity * const entity, std::unique_ptr<Component> &&component, const std::type_index typeIndex) = 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;
 };
 
@@ -56,15 +57,17 @@ struct ComponentOperation : public ashley::Poolable {
 	std::unique_ptr<Component> component = nullptr;
 
 	ComponentOperation() :
-			type(Type::NONE), typeIndex{std::unique_ptr<std::type_index>(nullptr)} {
+			        type(Type::NONE),
+			        typeIndex { std::unique_ptr<std::type_index>(nullptr) } {
 	}
 
 	virtual ~ComponentOperation() {
 	}
 
 	// TODO: Remove use of "new" here
 
-	inline void makeAdd(ashley::Entity *entity, std::unique_ptr<Component> &&component, const std::type_index typeIndex) {
+	inline void makeAdd(ashley::Entity *entity, std::unique_ptr<Component> &&component,
+	        const std::type_index typeIndex) {
 		this->type = Type::ADD;
 
 		this->entity = entity;

include/Ashley/signals/Signal.hpp

@@ -59,7 +59,7 @@ template<typename T> class Signal {
 	 */
 	void remove(Listener<T> * listener) {
 		auto it = std::find_if(listeners.begin(), listeners.end(),
-				[&](ashley::Listener<T> *&found) {return listener == found;});
+		        [&](ashley::Listener<T> *&found) {return listener == found;});
 
 		if (it != listeners.end()) {
 			listeners.erase(it);

include/Ashley/systems/IntervalIteratingSystem.hpp

@@ -69,14 +69,14 @@ class IntervalIteratingSystem : public ashley::IntervalSystem {
 	void addedToEngine(Engine &engine) override;
 	void removedFromEngine(Engine &engine) override;
 
-    Family *getFamily() const {
-        return family;
-    }
+	Family *getFamily() const {
+		return family;
+	}
 
 protected:
 	void updateInterval() override;
 
-	virtual void processEntity(Entity *const &entity) = 0;
+	virtual void processEntity(Entity * const &entity) = 0;
 };
 
 }

include/Ashley/systems/IteratingSystem.hpp

@@ -41,7 +41,7 @@ class IteratingSystem : public ashley::EntitySystem {
 	 * @param family The family of entities iterated over in this System
 	 */
 	explicit IteratingSystem(Family *family) :
-			IteratingSystem(family, ashley::EntitySystem::DEFAULT_PRIORITY) {
+			        IteratingSystem(family, ashley::EntitySystem::DEFAULT_PRIORITY) {
 	}
 
 	/**
@@ -51,7 +51,9 @@ class IteratingSystem : public ashley::EntitySystem {
 	 * @param priority The priority to execute this system with (lower means higher priority)
 	 */
 	IteratingSystem(Family *family, uint64_t priority) :
-			EntitySystem(priority), family(family), entities() {
+			        EntitySystem(priority),
+			        family(family),
+			        entities() {
 	}
 
 	virtual ~IteratingSystem() = default;
@@ -78,9 +80,9 @@ class IteratingSystem : public ashley::EntitySystem {
 	 */
 	virtual bool checkProcessing() override;
 
-    Family *getFamily() const {
-        return family;
-    }
+	Family *getFamily() const {
+		return family;
+	}
 
 protected:
 	/**

include/Ashley/util/ObjectPools.hpp

@@ -54,7 +54,7 @@ template<typename T> class ObjectPool {
 
 public:
 	explicit ObjectPool(int64_t startEntities = 100) :
-			peakEntities(0) {
+			        peakEntities(0) {
 		if (startEntities < 1) {
 			throw std::invalid_argument("startEntities must be greater than or equal to 1!");
 		}