Update some actions' versions in .github/workflows

Ensure gh-pages only runs on origin Github repo

Fix minor typo

Add .gitignore for conan_usage_example/

Fix conanfile.py, add example usage conan project

Update README.md

UnitTests: make counters atomic

Add conanfile.py, publish conan package

Inihbit warning when building UnitTests

Ignore "-Wsign-compare"

Remove dependency on GTest for UnitTests

Update LICENSE year

Enable tests on "any_archLinux" act runners

Revert "Enable another act runner for unit tests"

This reverts commit 654ddac9430a6814dcf8c6a37943cc1efee8347c.

Enable another act runner for unit tests

Add github action to run UnitTests

Update CMakeLists.txt cmake version

Add forgejo action to run unit tests

Update README.md

Add forgejo action to generate doxygen docs

Update LICENSE year

Merge branch 'nested_threads'

clang-format EC/ThreadPool.hpp

Apply minor fix and documentation to ThreadPool

Reformat EC/Manager.hpp

Undo change of temporary struct in Manager

Remove zero-ing of atomic_uint in ThreadPool

Setting the current "stacks" atomic_uint to zero is unnecessary once all
the threads have finished execution.

Add atomic_bool to ThreadPool to ensure validity

The new deque<atomic_bool> ensures that values are not dropped from the
deque until the entry's threads have finished execution.

Fix ThreadPool::easyStartAndWait()

Previously, the "waiting" part wasn't implemented.

Impl nested threaded calls

More testing is probably required to make sure it works properly.

WIP nestable threads via ThreadPool

Currently has a race-condition-like memory corruption bug where function
contexts are deleted before child-functions complete (probably).

Impl deferring deletions allowing for delete in fn

deleteEntity() is now allowed during a "forMatching" call, since it is deferred
until the "forMatching" call(s) end.

Fix possible data-race with isAlive() calls

Removed isAlive() calls from functions passed to ThreadPool, and instead use an
unordered_set prior to using ThreadPool to "cache" which entities are not alive.
This is so that if a function passed to ThreadPool modifies the ECManager (e.g.
creating a new entity), then there will be no data race from also calling
isAlive(). (Note that this does not protect against "deleting" entities from the
ECManager during use of ThreadPool. It is expected for the caller to do the
"deleting" after use of stored/called functions is finished.)

Add easyWakeAndWait() to ThreadPool

Changed usage of ThreadPool in EC::Manager to use easyWakeAndWait().

Update doxygen main page to link to EC::Manager

Update Doxygen and README.md

Attempt to use github actions for Doxygen docs

Double the number of tasks given to ThreadPool

Previous implementation only enqueued "ThreadCount" tasks to ThreadPool.
For more efficiency, this has been changed to "ThreadCount * 2" tasks.

Update README.md

Update doxygen documentation

Remove redundant function

"deleteForMatchingFunction()" was exactly the same as
"removeForMatchingFunction()", so it was removed.

Rename a UnitTest for ThreadPool

Fix UnitTests for ThreadPool

Make ThreadPool::getThreadCount() constexpr

Add tests for ThreadPool::getThreadCount()

Add ThreadPool::getThreadCount()

Without the previously removed THREADCOUNT constant, there was no way to
query the ThreadCount from outside the class. This function provides
this.

Remove "THREADCOUNT" from ThreadPool

Redundant because "SIZE" provides the same value.

Add missing include for "array"

Add .clangd specifying use of C++14

Merge branch 'refactoring'

Workaround for gcc debug build fail

Instead of defining temporary structs in functions, the temporary
structs are defined as part of the Manager class.

Heavy refactorings

Use temporary structs instead of tuples.
Enforce max line width of 80 characters.
Fix warning related to ECTest.cpp .

Note that currently this commit appears to be unable to be built by GCC,
but compiles OK with Clang.

Fix failing to wait for ThreadPool to finish

Fix CMakeLists.txt to use FindThreads

Merge branch 'threadpool'

Update documentation

Allow ThreadPool to be created with < 2 ThreadCount

Add isQueueEmpty() to ThreadPool

Tweak sleep times for threadpool to finish

Remove debug print

Usage of ThreadPool fixes

WIP convert Manager to use ThreadPool

valgrind seems to report memory issues, and documentation may need more
updating.

Impl ThreadPool

Add UnitTest for previously fixed bug

Update LICENSE year

Fix bug using callForMatchingFunction(s)

Fixed bug where invalid entity ids were used when using the
callForMatchingFunction(s) functions.

Update LICENSE year

Add forMatchingSimple, refactorings

Replace vector with deque for Component storage

When reallocating more data, vector moves the original data to a new
buffer. Deque preserves the location of the original data, preventing
invalidated pointers to existing data when additional allocation is
required.

Add fn to Manager allowing iterable indices as sig

As an alternative to forMatchingSignatures, which calls the given
function on entities matching the given Components/Tags in the
signature, forMatchingIterable allows filtering entities by an iterable
of indices that corresponds to Components/Tags.

Minor whitespace fixes, minor .gitignore change

Fix stored functions not being called in order

Manager::callForMatchingFunctions should now call all functions in the
order they were added.

Add static_assert, components must be def-const

EC::Manager will fail to compile if any given Component is not default
constructible, so a static_assert and ctest was added.

API change: context/userdata provided to functions

All functions called by EC/Manager now accept an additional parameter
as a void* to support user-provided data (or context) for functions
(useful when the function is not a lambda function and doesn't have any
other data stored with it).

Fix C++14 requirement in CMakeLists.txt

Update README.md

Update LICENSE year

Minor fixes/improvements

Update documentation

Add ability to handle unknown types

EC/Manager and EC/Bitset can now handle types that are not known
(Components or Tags not in the given Components or Tags when created).

Manager::getEntityData now returns a pointer instead of a reference.
Functions passed to Manager::forMatchingFunction (and other similar fns)
should now accept Component fields as pointer types, not reference
types.

Fix warning about unused capture for lambda fn

Add type reference to Components/Tags in Manager

Fix bug with multiple sig/func call

Fixed bug where if an entity is deleted during a multiple
signature/function call but matched a later signature/function, it would
still be called in that later function.

Minor fixes as well.

Remove .gitlab-ci.yml

Replace garbage-collection-like cleanup

Entity IDs are now guaranteed to not change for a living entity.
Cleanup is replaced by using a std::unordered_set to store deleted
Entity IDs to be reclaimed on later calls to addEntity().

Minor fixes to documentation

Change CleanupReturnType to std::vector

Fix bug with duplicate signatures

Fixed bug where if forMatchingSignatures and forMatchingSignaturesPtr
was called with some signatures in the TypeList being duplicates, then
only the first duplicate and function pair would be called, and all
other functions paired with other duplicate signatures would not be
called.

Improve efficiency of stored function calling

Previously, every called function iterated through all entities for
calling the function on matching entities.

Now, callForMatchingFunctions iterates through all entities once,
stores matching entities for each function, then calls the functions on
the matching entities.

Add ptr versions of forMatchingSignature fns

Fix crash bug, improve Unit Test

Crash bug from improperly implemented std::lock_guard for multi-threaded
usage of forMatchingSignatures fixed.

Implement forMatchingSignatures for efficiency

EC::Manager::forMatchingSignatures is different from
EC::Manager::forMatchingSignature in that it takes multiple signatures
and functions and iterates through all entities once. The trade-off is
that a vector of vectors is created to store matching entities.
This function can be called to use multiple threads as well, similar
to the "non-plural" version of this function.

See the doxygen-style documentation in src/EC/Manager.hpp for
forMatchingSignatures (or the generated doxygen html) for how to use.
Usage example is in the last unit test function in src/test/ECTest.hpp .

Add getCurrentSize and getCurrentCapacity

Fix minor typo

Fix cleanup function's return value

Unordered map does not preserve order in which items were inserted.
This is a problem because an entity id relocated to a previously deleted
one could be read as deleted when iterating through the unordered map.
Thus, it has been replaced with a queue.

Fix unit test

Replace variable length arrays with std::vector

Implement multithreading for function calls

Each of the EC::Manager's function calls over entities can now be
multi-threaded.

Add feature to cleanup function in manager

ECManager's cleanup function now returns a map detailing info on all
entities changed by cleanup.

Add const fns to Manager, obey 80 char line limit

Add a test to unit tests

Fixed keepSomeMatchingFunctions

Previous implementation would fail if functionIndex had wrapped around