From: Mikko Rasa <tdb@tdb.fi>
Date: Mon, 28 Nov 2022 12:08:29 +0000 (+0200)
Subject: Enforce no creation or destruction of objects during tick
X-Git-Url: http://git.tdb.fi/?a=commitdiff_plain;h=48051ee2bab13f65e48c371e453b9ea65920921e;p=libs%2Fgame.git

Enforce no creation or destruction of objects during tick
---

diff --git a/source/game/accessguard.cpp b/source/game/accessguard.cpp
new file mode 100644
index 0000000..d4c2113
--- /dev/null
+++ b/source/game/accessguard.cpp
@@ -0,0 +1,61 @@
+#include "accessguard.h"
+
+namespace Msp::Game {
+
+thread_local AccessGuard *AccessGuard::instance = nullptr;
+
+AccessGuard::AccessGuard()
+{
+	if(!instance)
+		instance = this;
+}
+
+AccessGuard::AccessGuard(AccessGuard &&other):
+	flags(std::move(other.flags))
+{
+	if(&other==instance)
+		instance = this;
+}
+
+AccessGuard &AccessGuard::operator=(AccessGuard &&other)
+{
+	flags = std::move(other.flags);
+	if(&other==instance)
+		instance = this;
+	return *this;
+}
+
+AccessGuard::~AccessGuard()
+{
+	if(this==instance)
+		instance = nullptr;
+}
+
+AccessGuard &AccessGuard::get_instance()
+{
+	if(!instance)
+		throw std::logic_error("no AccessGuard instance");
+	return *instance;
+}
+
+void AccessGuard::block_all()
+{
+	default_flag = BLOCKED;
+	for(uint8_t &f: flags)
+		f = BLOCKED;
+}
+
+void AccessGuard::unblock_all()
+{
+	default_flag = UNBLOCKED;
+	for(uint8_t &f: flags)
+		f = UNBLOCKED;
+}
+
+unsigned AccessGuard::get_next_index()
+{
+	static unsigned next_index = 0;
+	return next_index++;
+}
+
+} // namespace Msp::Game
diff --git a/source/game/accessguard.h b/source/game/accessguard.h
new file mode 100644
index 0000000..c64efe7
--- /dev/null
+++ b/source/game/accessguard.h
@@ -0,0 +1,99 @@
+#ifndef MSP_GAME_ACCESSGUARD_H_
+#define MSP_GAME_ACCESSGUARD_H_
+
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+#include <vector>
+#include <msp/core/noncopyable.h>
+
+namespace Msp::Game {
+
+class invalid_access: public std::logic_error
+{
+public:
+	invalid_access(const std::string &w): logic_error(w) { }
+};
+
+
+class AccessGuard
+{
+public:
+	struct Create { static std::string describe() { return "create"; } };
+	struct Destroy { static std::string describe() { return "destroy"; } };
+
+	template<typename T = void>
+	struct BlockForScope: NonCopyable
+	{
+		BlockForScope() { get_instance().block<T>(); }
+		~BlockForScope() { get_instance().unblock<T>(); }
+	};
+
+private:
+	const uint8_t UNBLOCKED = 0;
+	const uint8_t BLOCKED = 1;
+
+	std::uint8_t default_flag = UNBLOCKED;
+	std::vector<std::uint8_t> flags;
+
+	static thread_local AccessGuard *instance;
+
+public:
+	AccessGuard();
+	AccessGuard(AccessGuard &&);
+	AccessGuard &operator=(AccessGuard &&);
+	~AccessGuard();
+
+	static AccessGuard &get_instance();
+
+	void block_all();
+	void unblock_all();
+
+private:
+	static unsigned get_next_index();
+
+	template<typename T>
+	static unsigned get_index();
+
+	template<typename T>
+	std::uint8_t &get();
+
+public:
+	template<typename T>
+	void block() { get<T>() = BLOCKED; }
+
+	template<typename T>
+	void unblock() { get<T>() = UNBLOCKED; }
+
+	template<typename T>
+	void check() { if(get<T>()!=UNBLOCKED) throw invalid_access(T::describe()); }
+};
+
+
+template<typename T>
+inline unsigned AccessGuard::get_index()
+{
+	static unsigned index = get_next_index();
+	return index;
+}
+
+template<typename T>
+inline std::uint8_t &AccessGuard::get()
+{
+	unsigned index = get_index<T>();
+	if(flags.size()<=index)
+		flags.resize(index+1, default_flag);
+	return flags[index];
+}
+
+template<>
+inline void AccessGuard::block<void>()
+{ block_all(); }
+
+template<>
+inline void AccessGuard::unblock<void>()
+{ unblock_all(); }
+
+} // namespace Msp::Game
+
+#endif
diff --git a/source/game/director.cpp b/source/game/director.cpp
index b06dff4..4a4c126 100644
--- a/source/game/director.cpp
+++ b/source/game/director.cpp
@@ -10,7 +10,11 @@ namespace Msp::Game {
 Director::Director(DataFile::Collection &r):
 	resources(r),
 	event_source(event_bus)
-{ }
+{
+#if DEBUG
+	access_guard.emplace();
+#endif
+}
 
 // Hide ~unique_ptr<Stage> from the header
 Director::~Director()
diff --git a/source/game/director.h b/source/game/director.h
index de19185..1be3e8f 100644
--- a/source/game/director.h
+++ b/source/game/director.h
@@ -2,10 +2,12 @@
 #define MSP_GAME_DIRECTOR_H_
 
 #include <memory>
+#include <optional>
 #include <vector>
 #include <msp/datafile/collection.h>
 #include <msp/time/timedelta.h>
 #include <msp/time/timestamp.h>
+#include "accessguard.h"
 #include "eventbus.h"
 #include "events.h"
 #include "eventsource.h"
@@ -20,6 +22,7 @@ public:
 	using EventSource = Game::EventSource<Events::StageCreated, Events::StageActivated, Events::StageDeactivated>;
 
 private:
+	std::optional<AccessGuard> access_guard;
 	DataFile::Collection &resources;
 	EventBus event_bus;
 	EventSource event_source;
diff --git a/source/game/owned.h b/source/game/owned.h
index 7159c7d..fc2acab 100644
--- a/source/game/owned.h
+++ b/source/game/owned.h
@@ -2,6 +2,7 @@
 #define MSP_GAME_OWNED_H_
 
 #include <stdexcept>
+#include "accessguard.h"
 #include "events.h"
 #include "handle.h"
 #include "stage.h"
@@ -43,6 +44,10 @@ template<typename T>
 template<typename P, typename... Args>
 Owned<T>::Owned(Handle<P> parent, Args &&... args)
 {
+#ifdef DEBUG
+	AccessGuard::get_instance().check<AccessGuard::Create>();
+#endif
+
 	if(!parent)
 		throw std::invalid_argument("Owned::Owned");
 
@@ -89,6 +94,10 @@ void Owned<T>::destroy()
 	if(!obj)
 		return;
 
+#ifdef DEBUG
+	AccessGuard::get_instance().check<AccessGuard::Destroy>();
+#endif
+
 	Stage &stage = get_stage(*obj);
 
 	if constexpr(std::is_base_of_v<Component, T>)
diff --git a/source/game/stage.cpp b/source/game/stage.cpp
index 81893e1..bdd0ed6 100644
--- a/source/game/stage.cpp
+++ b/source/game/stage.cpp
@@ -1,4 +1,5 @@
 #include "stage.h"
+#include "accessguard.h"
 #include "camera.h"
 #include "root.h"
 #include "system.h"
@@ -53,8 +54,14 @@ void Stage::synthesize_initial_events(Handle<Entity> entity, EventObserver &targ
 
 void Stage::tick(Time::TimeDelta dt)
 {
-	for(const auto &s: systems)
-		s->tick(dt);
+	{
+#ifdef DEBUG
+		AccessGuard::BlockForScope _block;;
+#endif
+		for(const auto &s: systems)
+			s->tick(dt);
+	}
+
 	for(const auto &s: systems)
 		s->deferred_tick();
 }