Added Doxygen comments

Slight change to EC::Manager::isAlive

.gitignore

@@ -1,4 +1,5 @@
 build*/
 *.o
 *.swp
+doxygen_html/
 

src/EC/Manager.hpp

@@ -89,7 +89,7 @@ namespace EC
 
         bool isAlive(std::size_t index) const
         {
-            return std::get<bool>(entities.at(index));
+            return hasEntity(index) && std::get<bool>(entities.at(index));
         }
 
         const EntitiesTupleType& getEntityInfo(std::size_t index) const
@@ -248,3 +248,155 @@ namespace EC
 
 #endif
 
+/*! \class EC::Manager
+    \brief Manages an EntityComponent system.
+*/
+
+/*! \fn EC::Manager::Manager()
+    \brief Initializes the manager with a default capacity.
+
+    The default capacity is set with macro EC_INIT_ENTITIES_SIZE,
+    and will grow by amounts of EC_GROW_SIZE_AMOUNT when needed.
+*/
+
+/*! \fn std::size_t EC::Manager::addEntity()
+    \brief Adds an entity to the system, returning the ID of the entity.
+
+    WARNING: The ID of an entity may change after calls to cleanup().
+    Only use the ID given during usage of forMatchingSignature().
+*/
+
+/*! \fn void EC::Manager::deleteEntity(std::size_t index)
+    \brief Marks an entity for deletion.
+
+    A deleted Entity is not actually deleted until cleanup() is called.
+    While an Entity is "deleted" but still in the system, calls to forMatchingSignature()
+    will ignore the Entity.
+*/
+
+/*! \fn bool EC::Manager::hasEntity(std::size_t index) const
+    \brief Checks if the Entity with the given ID is in the system.
+
+    Note that deleted Entities that haven't yet been cleaned up (via cleanup()) are
+    considered still in the system.
+*/
+
+/*! \fn bool EC::Manager::isAlive(std::size_t index) const
+    \brief Checks if the Entity is not marked as deleted.
+
+    Note that invalid Entities (Entities where calls to hasEntity() returns false)
+    will return false.
+*/
+
+/*! \fn const EntitiesTupleType& EC::Manager::getEntityInfo(std::size_t index) const
+    \brief Returns a const reference to an Entity's info.
+
+    An Entity's info is a std::tuple with a bool, std::size_t, and a bitset.
+    \n The bool determines if the Entity is alive.
+    \n The std::size_t is the ID to this Entity's data in the system.
+    \n The bitset shows what Components and Tags belong to the Entity.
+*/
+
+/*! \fn Component& EC::Manager::getEntityData(std::size_t index)
+    \brief Returns a reference to a component belonging to the given Entity.
+
+    This function will return a reference to a Component regardless of whether or
+    not the Entity actually owns the reference. If the Entity doesn't own the Component,
+    changes to the Component will not affect any Entity. It is recommended to use
+    hasComponent() to determine if the Entity actually owns that Component.
+*/
+
+/*! \fn bool EC::Manager::hasComponent(std::size_t index) const
+    \brief Checks whether or not the given Entity has the given Component.
+
+    Example:
+    \code{.cpp}
+        manager.hasComponent<C0>(entityID);
+    \endcode
+*/
+
+/*! \fn bool EC::Manager::hasTag(std::size_t index) const
+    \brief Checks whether or not the given Entity has the given Tag.
+
+    Example:
+    \code{.cpp}
+        manager.hasTag<T0>(entityID);
+    \endcode
+*/
+
+/*! \fn void EC::Manager::cleanup()
+    \brief Does garbage collection on Entities.
+
+    Does housekeeping on the vector containing Entities that will result in
+    entity IDs changing if some Entities were marked for deletion.
+    <b>This function should be called periodically to correctly handle deletion of entities.</b>
+*/
+
+/*! \fn void EC::Manager::addComponent(std::size_t entityID, Args&&... args)
+    \brief Adds a component to the given Entity.
+
+    Additional parameters given to this function will construct the Component with those
+    parameters.
+
+    Example:
+    \code{.cpp}
+        struct C0
+        {
+            C0(int a, char b) : a(a), b(b)
+            {}
+
+            int a;
+            char b;
+        }
+
+        manager.addComponent<C0>(entityID, 10, 'd');
+    \endcode
+*/
+
+/*! \fn void EC::Manager::removeComponent(std::size_t entityID)
+    \brief Removes the given Component from the given Entity.
+
+    If the Entity does not have the Component given, nothing will change.
+
+    Example:
+    \code{.cpp}
+        manager.removeComponent<C0>(entityID);
+    \endcode
+*/
+
+/*! \fn void EC::Manager::addTag(std::size_t entityID)
+    \brief Adds the given Tag to the given Entity.
+
+    Example:
+    \code{.cpp}
+        manager.addTag<T0>(entityID);
+    \endcode
+*/
+
+/*! \fn void EC::Manager::removeTag(std::size_t entityID)
+    \brief Removes the given Tag from the given Entity.
+
+    If the Entity does not have the Tag given, nothing will change.
+
+    Example:
+    \code{.cpp}
+        manager.removeTag<T0>(entityID);
+    \endcode
+*/
+
+/*! \fn void EC::Manager::forMatchingSignature(Function&& function)
+    \brief Calls the given function on all Entities matching the given Signature.
+
+    The function object given to this function must accept std::size_t as its first
+    parameter and Component references for the rest of the parameters. Tags specified in the
+    Signature are only used as filters and will not be given as a parameter to the function.
+
+    Example:
+    \code{.cpp}
+        manager.forMatchingSignature<TypeList<C0, C1, T0>>([] (std::size_t ID, C0& component0, C1& component1) {
+            // Lambda function contents here.
+        });
+    \endcode
+    Note, the ID given to the function is not permanent. An entity's ID may change when cleanup() is called.
+*/
+