Disallow system create after manager init

* Also add tickIndex counter.

Author: cfnptr

README.md

@@ -39,14 +39,6 @@ class PhysicsSystem final : public ComponentSystem<RigidBodyComponent, false>
         auto manager = Manager::Instance::get();
         ECSM_SUBSCRIBE_TO_EVENT("Update", PhysicsSystem::update);
     }
-    ~PhysicsSystem() final
-    {
-        if (Manager::get()->isRunning)
-        {
-            auto manager = Manager::Instance::get();
-            ECSM_UNSUBSCRIBE_FROM_EVENT("Update", PhysicsSystem::update);
-        }
-    }
 
     void update()
     {
@@ -62,7 +54,7 @@ class PhysicsSystem final : public ComponentSystem<RigidBodyComponent, false>
     friend class ecsm::Manager;
 };
 
-void ecsmExample()
+void entryPoint()
 {
     auto manager = new ecsm::Manager();
     manager->createSystem<PhysicsSystem>();
@@ -75,8 +67,8 @@ void ecsmExample()
     auto rigidBodyView = manager->add<RigidBodyComponent>(rigidBody);
     rigidBodyView->size = 1.0f;
 
-    manager->start();
-
+    manager->enterLoop();
+    manager->terminate();
     delete manager;
 }
 ```

include/ecsm.hpp

@@ -354,6 +354,7 @@ class Manager final : public Singleton<Manager, false>
 	OrderedEvents orderedEvents;
 	GarbageComponents garbageComponents;
 	std::mutex locker;
+	uint64_t tickIndex = 0;
 	bool initialized = false;
 
 	#ifndef NDEBUG
@@ -364,7 +365,7 @@ class Manager final : public Singleton<Manager, false>
 public:
 	volatile bool isRunning = false; /**< Is manager update loop running. */
 
-	/**
+	/*******************************************************************************************************************
 	 * @brief Creates a new manager instance.
 	 * @param setSingleton set manager singleton instance
 	 */
@@ -374,11 +375,11 @@ class Manager final : public Singleton<Manager, false>
 	 */
 	~Manager();
 
-	/*******************************************************************************************************************
+	/**
 	 * @brief Creates a new system instance.
 	 * 
 	 * @details
-	 * Instantiates a new system and registers it component, 
+	 * Allocates a new system instance and registers it component, 
 	 * but initialization occurs only after the @ref initialize() call.
 	 * 
 	 * @tparam T target system type
@@ -391,6 +392,8 @@ class Manager final : public Singleton<Manager, false>
 	void createSystem(Args&&... args)
 	{
 		static_assert(std::is_base_of_v<System, T>, "Must be derived from the System class.");
+		if (initialized)
+			throw EcsmError("Manager is already initialized, can't create a new system.");
 		#ifndef NDEBUG
 		if (isChanging)
 			throw EcsmError("Creation of the system inside other create/destroy is not allowed.");
@@ -405,42 +408,6 @@ class Manager final : public Singleton<Manager, false>
 		#endif
 	}
 
-	/**
-	 * @brief Terminates and destroys system.
-	 * @param type target system typeid()
-	 * @throw EcsmError if system is not found.
-	 */
-	void destroySystem(std::type_index type);
-	/**
-	 * @brief Terminates and destroys system.
-	 * @tparam T target system type
-	 * @throw EcsmError if system is not found.
-	 */
-	template<class T>
-	void destroySystem()
-	{
-		static_assert(std::is_base_of_v<System, T>, "Must be derived from the System class.");
-		destroySystem(typeid(T));
-	}
-
-	/**
-	 * @brief Terminates and destroys system if exists.
-	 * @param type target system typeid()
-	 * @return True if system is destroyed, otherwise false.
-	 */
-	bool tryDestroySystem(std::type_index type);
-	/**
-	 * @brief Terminates and destroys system if exists.
-	 * @tparam T target system type
-	 * @return True if system is destroyed, otherwise false.
-	 */
-	template<class T>
-	bool tryDestroySystem()
-	{
-		static_assert(std::is_base_of_v<System, T>, "Must be derived from the System class.");
-		return tryDestroySystem(typeid(T));
-	}
-
 	/*******************************************************************************************************************
 	 * @brief Adds specified system to the system group.
 	 * 
@@ -1323,28 +1290,37 @@ class Manager final : public Singleton<Manager, false>
 	 * @note Use manager functions to check if component is garbage.
 	 */
 	const GarbageComponents& getGarbageComponents() const noexcept { return garbageComponents; }
+	/**
+	 * @brief Returns current tick index since manager creation. (Total update count)
+	 */
+	uint64_t getTickIndex() const noexcept { return tickIndex; }
 	/**
 	 * @brief Returns true if manager is initialized.
+	 * @note You can't add more systems after manager initialization.
 	 */
 	bool isInitialized() const noexcept { return initialized; }
 
 	/*******************************************************************************************************************
-	 * @brief Initializes all created systems.
+	 * @brief Initializes all manager created systems.
 	 * @throw EcsmError if manager is already initialized.
 	 */
 	void initialize();
+	/**
+	 * @brief Terminates all manager created systems.
+	 * @throw EcsmError if manager is already terminated.
+	 */
+	void terminate();
 
 	/**
-	 * @brief Runs ordered events and disposes destroyed resources on each tick.
+	 * @brief Runs ordered events and disposes destroyed resources.
 	 * @throw EcsmError if manager is not initialized.
 	 */
 	void update();
-
 	/**
-	 * @brief Enters update loop. Executes @ref update() on each tick.
+	 * @brief Enters update loop. Executes @ref Manager::update() on each tick.
 	 * @throw EcsmError if manager is not initialized.
 	 */
-	void start();
+	void enterLoop();
 
 	/*******************************************************************************************************************
 	 * @brief Actually destroys garbage components.

include/singleton.hpp

@@ -58,6 +58,15 @@ class Singleton
 		if (set)
 			setSingleton();
 	}
+	/**
+	 * @brief Destroys singleton class instance.
+	 * @note It also unsets singleton if it's the same as this system.
+	 */
+	virtual ~Singleton()
+	{
+		if (this == singletonInstance)
+			unsetSingleton();
+	}
 
 	/**
 	 * @brief Sets a new class singleton instance.

source/ecsm.cpp

@@ -76,13 +76,6 @@ Manager::Manager(bool setSingleton) : Singleton(setSingleton)
 }
 Manager::~Manager()
 {
-	if (initialized)
-	{
-		runEvent("PreDeinit");
-		runEvent("Deinit");
-		runEvent("PostDeinit");
-	}
-
 	entities.clear(false);
 
 	#ifndef NDEBUG
@@ -128,93 +121,6 @@ void Manager::addSystem(System* system, std::type_index type)
 
 	if (!systems.emplace(type, system).second)
 		throw EcsmError("System is already created. (name: " + typeToString(type) + ")");
-
-	if (isRunning)
-	{
-		runEvent("PreInit");
-		runEvent("Init");
-		runEvent("PostInit");
-	}
-}
-
-//**********************************************************************************************************************
-void Manager::destroySystem(std::type_index type)
-{
-	#ifndef NDEBUG
-	if (isChanging)
-		throw EcsmError("Destruction of the system inside other create/destroy is not allowed.");
-	isChanging = true;
-	#endif
-
-	auto searchResult = systems.find(type);
-	if (searchResult == systems.end())
-		throw EcsmError("System is not created. (type: " + typeToString(type) + ")");
-
-	if (isRunning)
-	{
-		runEvent("PreDeinit");
-		runEvent("Deinit");
-		runEvent("PostDeinit");
-	}
-
-	auto system = searchResult->second;
-	systems.erase(searchResult);
-	
-	auto componentName = system->getComponentName();
-	if (!componentName.empty())
-	{
-		auto eraseResult = componentNames.erase(componentName);
-		if (eraseResult != 1)
-		{
-			throw EcsmError("Failed to erase system component name. ("
-				"componentName: " + std::string(componentName) + ", "
-				"systemType: " + typeToString(type) + ")");
-		}
-	}
-
-	auto componentType = system->getComponentType();
-	if (componentType != typeid(Component))
-	{
-		auto eraseResult = componentTypes.erase(componentType);
-		if (eraseResult != 1)
-		{
-			throw EcsmError("Failed to erase system component type. ("
-				"componentType: " + typeToString(componentType) + ", "
-				"systemType: " + typeToString(type) + ")");
-		}
-	}
-
-	delete system;
-
-	#ifndef NDEBUG
-	isChanging = false;
-	#endif
-}
-bool Manager::tryDestroySystem(std::type_index type)
-{
-	#ifndef NDEBUG
-	if (isChanging)
-		throw EcsmError("Destruction of the system inside other create/destroy is not allowed.");
-	isChanging = true;
-	#endif
-
-	auto result = systems.find(type);
-	if (result != systems.end())
-	{
-		#ifndef NDEBUG
-		isChanging = false;
-		#endif
-		return false;
-	}
-
-	auto system = result->second;
-	systems.erase(result);
-	delete system;
-
-	#ifndef NDEBUG
-	isChanging = false;
-	#endif
-	return true;
 }
 
 //**********************************************************************************************************************
@@ -664,6 +570,16 @@ void Manager::initialize()
 	runEvent("PostInit");
 	initialized = true;
 }
+void Manager::terminate()
+{
+	if (!initialized)
+		throw EcsmError("Manager is already terminated.");
+
+	runEvent("PreDeinit");
+	runEvent("Deinit");
+	runEvent("PostDeinit");
+	initialized = false;
+}
 
 void Manager::update()
 {
@@ -675,15 +591,15 @@ void Manager::update()
 	disposeGarbageComponents();
 	disposeEntities();
 	disposeSystemComponents();
+	tickIndex++;
 	locker.unlock();
 }
-void Manager::start()
+void Manager::enterLoop()
 {
 	if (!initialized)
 		throw EcsmError("Manager is not initialized.");
 
 	isRunning = true;
-
 	while (isRunning)
 		update();
 }

tests/test-ecsm.cpp

@@ -40,18 +40,6 @@ class TestSystem final : public ComponentSystem<TestComponent>, public Singleton
 		ECSM_SUBSCRIBE_TO_EVENT("Update", TestSystem::update);
 		ECSM_SUBSCRIBE_TO_EVENT("PostUpdate", TestSystem::postUpdate);
 	}
-	~TestSystem() override
-	{
-		if (Manager::Instance::get()->isRunning)
-		{
-			auto manager = Manager::Instance::get();
-			ECSM_UNSUBSCRIBE_FROM_EVENT("Init", TestSystem::init);
-			ECSM_UNSUBSCRIBE_FROM_EVENT("Update", TestSystem::update);
-			ECSM_UNSUBSCRIBE_FROM_EVENT("PostUpdate", TestSystem::postUpdate);
-		}
-
-		unsetSingleton();
-	}
 
 	void copyComponent(View<Component> source, View<Component> destination) override
 	{
@@ -186,12 +174,10 @@ static void testCommonFlow()
 	if (componentMemory->ID != 0) // WARNING! You should't do this, it's just safety check!
 		throw runtime_error("Bad test component data after dispose.");
 
-	manager->destroySystem<TestSystem>();
-
-	if (manager->has<TestSystem>())
-		throw runtime_error("Test system is not destroyed.");
-
 	manager->unregisterEvent("PostUpdate");
+	if (manager->hasEvent("PostUpdate"))
+		throw runtime_error("PostUpdate not unregistered.");
+
 	delete manager;
 }