Restructure project

1 files changed, 233 insertions, 0 deletions

diff --git a/app/source/Cplt/Utils/Sigslot.cpp b/app/source/Cplt/Utils/Sigslot.cpp
new file mode 100644
index 0000000..1132dfb
--- /dev/null
+++ b/app/source/Cplt/Utils/Sigslot.cpp
@@ -0,0 +1,233 @@
+#include "Sigslot.hpp"
+
+#include <doctest/doctest.h>
+
+bool SignalStub::Connection::IsOccupied() const
+{
+	return id != InvalidId;
+}
+
+SignalStub::SignalStub(IWrapper& wrapper)
+	: mWrapper{ &wrapper }
+{
+}
+
+SignalStub::~SignalStub()
+{
+	RemoveAllConnections();
+}
+
+std::span<const SignalStub::Connection> SignalStub::GetConnections() const
+{
+	return mConnections;
+}
+
+SignalStub::Connection& SignalStub::InsertConnection(SlotGuard* guard)
+{
+	Connection* result;
+	int size = static_cast<int>(mConnections.size());
+	for (int i = 0; i < size; ++i) {
+		auto& conn = mConnections[i];
+		if (!conn.IsOccupied()) {
+			result = &conn;
+			result->id = i;
+			goto setup;
+		}
+	}
+
+	mConnections.push_back(Connection{});
+	result = &mConnections.back();
+	result->id = size;
+
+setup:
+	if (guard) {
+		result->guard = guard;
+		result->slotId = guard->InsertConnection(*this, result->id);
+	}
+	return *result;
+}
+
+void SignalStub::RemoveConnection(int id)
+{
+	if (id >= 0 && id < mConnections.size()) {
+		auto& conn = mConnections[id];
+		if (conn.IsOccupied()) {
+			mWrapper->RemoveFunction(conn.id);
+			if (conn.guard) {
+				conn.guard->RemoveConnection(conn.slotId);
+			}
+
+			conn.guard = nullptr;
+			conn.slotId = SignalStub::InvalidId;
+			conn.id = SignalStub::InvalidId;
+		}
+	}
+}
+
+void SignalStub::RemoveConnectionFor(SlotGuard& guard)
+{
+	guard.RemoveConnectionFor(*this);
+}
+
+void SignalStub::RemoveAllConnections()
+{
+	for (size_t i = 0; i < mConnections.size(); ++i) {
+		RemoveConnection(i);
+	}
+}
+
+SlotGuard::SlotGuard()
+{
+}
+
+SlotGuard::~SlotGuard()
+{
+	DisconnectAll();
+}
+
+void SlotGuard::DisconnectAll()
+{
+	for (auto& conn : mConnections) {
+		if (conn.stub) {
+			// Also calls SlotGuard::removeConnection, our copy of the data will be cleared in it
+			conn.stub->RemoveConnection(conn.stubId);
+		}
+	}
+}
+
+int SlotGuard::InsertConnection(SignalStub& stub, int stubId)
+{
+	int size = static_cast<int>(mConnections.size());
+	for (int i = 0; i < size; ++i) {
+		auto& conn = mConnections[i];
+		if (!conn.stub) {
+			conn.stub = &stub;
+			conn.stubId = stubId;
+			return i;
+		}
+	}
+
+	mConnections.push_back(Connection{});
+	auto& conn = mConnections.back();
+	conn.stub = &stub;
+	conn.stubId = stubId;
+	return size;
+}
+
+void SlotGuard::RemoveConnectionFor(SignalStub& stub)
+{
+	for (auto& conn : mConnections) {
+		if (conn.stub == &stub) {
+			conn.stub->RemoveConnection(conn.stubId);
+		}
+	}
+}
+
+void SlotGuard::RemoveConnection(int slotId)
+{
+	mConnections[slotId] = {};
+}
+
+TEST_CASE("Signal connect and disconnect")
+{
+	Signal<> sig;
+
+	int counter = 0;
+	int id = sig.Connect([&]() { counter++; });
+
+	sig();
+	CHECK(counter == 1);
+
+	sig();
+	CHECK(counter == 2);
+
+	sig.Disconnect(id);
+	sig();
+	CHECK(counter == 2);
+}
+
+TEST_CASE("Signal with parameters")
+{
+	Signal<int> sig;
+
+	int counter = 0;
+	int id = sig.Connect([&](int i) { counter += i; });
+
+	sig(1);
+	CHECK(counter == 1);
+
+	sig(0);
+	CHECK(counter == 1);
+
+	sig(4);
+	CHECK(counter == 5);
+
+	sig.Disconnect(id);
+	sig(1);
+	CHECK(counter == 5);
+}
+
+TEST_CASE("Signal disconnectAll()")
+{
+	Signal<> sig;
+
+	int counter1 = 0;
+	int counter2 = 0;
+	sig.Connect([&]() { counter1++; });
+	sig.Connect([&]() { counter2++; });
+
+	sig();
+	CHECK(counter1 == 1);
+	CHECK(counter2 == 1);
+
+	sig();
+	CHECK(counter1 == 2);
+	CHECK(counter2 == 2);
+
+	sig.DisconnectAll();
+	sig();
+	CHECK(counter1 == 2);
+	CHECK(counter2 == 2);
+}
+
+TEST_CASE("SlotGuard auto-disconnection")
+{
+	int counter1 = 0;
+	int counter2 = 0;
+	Signal<> sig;
+
+	{
+		SlotGuard guard;
+		sig.Connect(guard, [&]() { counter1 += 1; });
+		sig.Connect(guard, [&]() { counter2 += 1; });
+
+		sig();
+		CHECK(counter1 == 1);
+		CHECK(counter2 == 1);
+
+		sig();
+		CHECK(counter1 == 2);
+		CHECK(counter2 == 2);
+	}
+
+	sig();
+	CHECK(counter1 == 2);
+	CHECK(counter2 == 2);
+}
+
+TEST_CASE("Signal destruct before SlotGuard")
+{
+	int counter = 0;
+	SlotGuard guard;
+
+	{
+		Signal<> sig2;
+		sig2.Connect(guard, [&]() { counter++; });
+
+		sig2();
+		CHECK(counter == 1);
+	}
+
+	// Shouldn't error
+	guard.DisconnectAll();
+}