From 3575cbc543236abf6201b35a0c7020f03ae6b8f3 Mon Sep 17 00:00:00 2001
From: IlyaShurupov <ilusha.main@gmail.com>
Date: Tue, 25 Jul 2023 18:47:00 +0300
Subject: [PATCH] Archiver Initial

---
 CMakeLists.txt                       |   2 +-
 CMakeSettings.json                   |  15 ++
 CommandLine/private/CommandLine.cpp  |   2 +-
 CommandLine/public/CommandLine.hpp   |   2 +-
 Containers/public/Buffer.hpp         |  67 ++++++++-
 Containers/public/Buffer2D.hpp       |  34 ++++-
 Containers/public/List.hpp           |  27 ++--
 Containers/public/Map.hpp            |  33 ++---
 Containers/public/Tree.hpp           |  31 +++-
 Containers/tests/ListTest.cpp        |  14 +-
 Containers/tests/MapTest.cpp         |  10 +-
 Containers/tests/Tests.hpp           |  31 ----
 Math/private/Camera.cpp              |   2 +-
 Math/public/Vec.hpp                  |  32 ++---
 Modules/.vs/slnx.sqlite              | Bin 0 -> 90112 bytes
 Modules/CMakeLists.txt               |   3 +-
 Modules/public/Archiver.hpp          | 146 +++++++++++++++++++
 Modules/public/Common.hpp            |  29 +++-
 Modules/public/SizeCounter.hpp       |  50 +++++++
 Modules/tests/TestArchiver.cpp       | 202 +++++++++++++++++++++++++++
 Modules/tests/Tests.cpp              |  12 +-
 TODO                                 |  22 +--
 Tokenizer/public/RegularExpression.h |   4 +-
 Tokenizer/public/Tokenizer.hpp       |   4 +-
 Utils/tests/Tests.cpp                |   2 +-
 25 files changed, 652 insertions(+), 124 deletions(-)
 create mode 100644 CMakeSettings.json
 create mode 100644 Modules/.vs/slnx.sqlite
 create mode 100644 Modules/public/Archiver.hpp
 create mode 100644 Modules/public/SizeCounter.hpp
 create mode 100644 Modules/tests/TestArchiver.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d0d6658..147af07 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -25,4 +25,4 @@ add_subdirectory(Externals)
 add_subdirectory(Connection)
 add_subdirectory(Graphics)
 
-add_subdirectory(Objects)
+#add_subdirectory(Objects)
diff --git a/CMakeSettings.json b/CMakeSettings.json
new file mode 100644
index 0000000..03cbf8d
--- /dev/null
+++ b/CMakeSettings.json
@@ -0,0 +1,15 @@
+{
+	"configurations": [
+		{
+			"name": "x64-Debug",
+			"generator": "Ninja",
+			"configurationType": "Debug",
+			"inheritEnvironments": [ "msvc_x64_x64" ],
+			"buildRoot": "${projectDir}\\out\\build\\${name}",
+			"installRoot": "${projectDir}\\out\\install\\${name}",
+			"cmakeCommandArgs": "",
+			"buildCommandArgs": "",
+			"ctestCommandArgs": ""
+		}
+	]
+}
\ No newline at end of file
diff --git a/CommandLine/private/CommandLine.cpp b/CommandLine/private/CommandLine.cpp
index f937e2a..35bfb35 100644
--- a/CommandLine/private/CommandLine.cpp
+++ b/CommandLine/private/CommandLine.cpp
@@ -93,7 +93,7 @@ CommandLine::Arg::~Arg() {
 	}
 }
 
-CommandLine::CommandLine(const init_list<Arg>& args) {
+CommandLine::CommandLine(const InitialierList<Arg>& args) {
 	bool optional_start = false;
 
 	for (auto& arg : args) {
diff --git a/CommandLine/public/CommandLine.hpp b/CommandLine/public/CommandLine.hpp
index b0ad457..9573dc9 100644
--- a/CommandLine/public/CommandLine.hpp
+++ b/CommandLine/public/CommandLine.hpp
@@ -67,7 +67,7 @@ namespace tp {
 			operator bool() { return mDescr != nullptr; }
 		} mError;
 
-		CommandLine(const init_list<Arg>& args);
+		CommandLine(const InitialierList<Arg>& args);
 		~CommandLine();
 
 		void resetError() { mError.mDescr = nullptr; }
diff --git a/Containers/public/Buffer.hpp b/Containers/public/Buffer.hpp
index b889348..7888002 100644
--- a/Containers/public/Buffer.hpp
+++ b/Containers/public/Buffer.hpp
@@ -20,7 +20,7 @@ namespace tp {
 
 	template<typename tType, ualni tSize>
 	class ConstSizeBuffer {
-		typedef SelCopyArg<tType> Arg;
+		typedef SelectValueOrReference<tType> Arg;
 
 	private:
 		tType mBuff[tSize];
@@ -29,6 +29,12 @@ namespace tp {
 	public:
 		ConstSizeBuffer() = default;
 
+		~ConstSizeBuffer() {
+			for (auto i = 0; i < mLoad; i++) {
+				mBuff[i].~tType();
+			}
+		}
+
 	public:
 		[[nodiscard]] ualni size() const { return mLoad; }
 		[[nodiscard]] ualni getBuffSize() const { return tSize; }
@@ -75,13 +81,18 @@ namespace tp {
 			mLoad--;
 		}
 
-		ConstSizeBuffer& operator=(const tp::init_list<tType>& init) {
+		ConstSizeBuffer& operator=(const tp::InitialierList<tType>& init) {
 			for (auto arg : init) {
 				append(arg);
 			}
 			return *this;
 		}
 
+		void clear() {
+			this->~ConstSizeBuffer();
+			new (this) ConstSizeBuffer();
+		}
+
 	public:
 
 		class IteratorPointer {
@@ -125,6 +136,24 @@ namespace tp {
 		[[nodiscard]] Iterator end() const {
 			return Iterator(mBuff + mLoad);
 		}
+
+	public:
+		template<class tArchiver>
+		void archiveWrite(tArchiver& ar) const {
+			ar << mLoad;
+			for (auto item : *this) {
+				ar << item.data();
+			}
+		}
+
+		template<class tArchiver>
+		void archiveRead(tArchiver& ar) {
+			clear();
+			ar >> mLoad;
+			for (auto i = 0; i < mLoad; i++) {
+				ar >> mBuff[i];
+			}
+		}
 	};
 
 	template<
@@ -135,7 +164,7 @@ namespace tp {
 		ualni tMinSize = 4
 	>
 	class Buffer {
-		typedef SelCopyArg<tType> Arg;
+		typedef SelectValueOrReference<tType> Arg;
 
 	private:
 		tType* mBuff;
@@ -157,10 +186,14 @@ namespace tp {
 			for (ualni i = 0; i < mLoad; i++) new (&mBuff[i]) tType(in.mBuff[i]);
 		}
 
+		void clear() {
+			this->~Buffer();
+			new (this) Buffer();
+		}
+
 		Buffer& operator=(const Buffer& in) {
 			if (this == &in) return *this;
-			this->~Buffer();
-			new (this) Buffer(in);
+			clear();
 			return *this;
 		}
 
@@ -219,7 +252,7 @@ namespace tp {
 		}
 
 	public:
-		Buffer& operator=(const tp::init_list<tType>& init) {
+		Buffer& operator=(const tp::InitialierList<tType>& init) {
 			// TODO : optimize
 			for (auto arg : init) {
 				append(arg);
@@ -307,6 +340,28 @@ namespace tp {
 			return Iterator(mBuff + mLoad);
 		}
 
+	public:
+		template<class tArchiver>
+		void archiveWrite(tArchiver& ar) const {
+			ar << mLoad;
+			for (auto item : *this) {
+				ar << item.data();
+			}
+		}
+
+		template<class tArchiver>
+		void archiveRead(tArchiver& ar) {
+			clear();
+			decltype(mLoad) len;
+			ar >> len;
+			for (auto i = len; i; i--) {
+				// TODO : optimize
+				if (mLoad == mSize) resizeBuffer(tResizePolicy(mSize));
+				ar >> mBuff[mLoad];
+				mLoad++;
+			}
+		}
+
   private:
     void resizeBuffer(ualni newSize) {
       DEBUG_ASSERT(newSize >= mLoad)
diff --git a/Containers/public/Buffer2D.hpp b/Containers/public/Buffer2D.hpp
index d8e5205..32ab6cb 100644
--- a/Containers/public/Buffer2D.hpp
+++ b/Containers/public/Buffer2D.hpp
@@ -15,7 +15,7 @@ namespace tp {
 	public:
 		typedef ualni Index;
 		typedef Pair<Index, Index> Index2D;
-		typedef SelCopyArg<tType> tTypeArg;
+		typedef SelectValueOrReference<tType> tTypeArg;
 
 	private:
 		tAllocator mAlloc;
@@ -40,6 +40,7 @@ namespace tp {
 
 		~Buffer2D() {
 			deleteBuffer();
+			mSize = { 0, 0 };
 		}
 
 		explicit Buffer2D(Index2D aSize) {
@@ -55,17 +56,17 @@ namespace tp {
 		}
 
 		inline tType& get(const Index2D& at) {
-			DEBUG_ASSERT(at.x < mSize.x && at.y < mSize.y && at.x >= 0 && at.y >= 0)
+			DEBUG_ASSERT(mBuff && at.x < mSize.x && at.y < mSize.y && at.x >= 0 && at.y >= 0)
 			return *(mBuff + mSize.x * at.y + at.x);
 		}
 
 		inline const tType& get(const Index2D& at) const {
-			DEBUG_ASSERT(at.x < mSize.x && at.y < mSize.y && at.x >= 0 && at.y >= 0)
+			DEBUG_ASSERT(mBuff && at.x < mSize.x && at.y < mSize.y && at.x >= 0 && at.y >= 0)
 			return *(mBuff + mSize.x * at.y + at.x);
 		}
 
 		inline void set(const Index2D& at, tTypeArg value) {
-			DEBUG_ASSERT(at.x < mSize.x && at.y < mSize.y && at.x >= 0 && at.y >= 0)
+			DEBUG_ASSERT(mBuff && at.x < mSize.x && at.y < mSize.y && at.x >= 0 && at.y >= 0)
 			*(mBuff + mSize.x * at.y + at.x) = value;
 		}
 
@@ -77,10 +78,35 @@ namespace tp {
 		}
 
 		void assign(tType value) {
+			DEBUG_ASSERT(mBuff);
 			Index len = mSize.x * mSize.y;
 			for (Index i = 0; i < len; i++) {
 				mBuff[i] = value;
 			}
 		}
+
+	public:
+		template<class tArchiver>
+		void archiveWrite(tArchiver& ar) const {
+			ar << mSize;
+			for (auto i = 0; i < mSize.x; i++) {
+				for (auto j = 0; j < mSize.y; j++) {
+					ar << get(i, j);
+				}
+			}
+		}
+
+		template<class tArchiver>
+		void archiveRead(tArchiver& ar) {
+			decltype(mSize) size;
+			deleteBuffer();
+			ar >> size;
+			reserve(size);
+			for (auto i = 0; i < mSize.x; i++) {
+				for (auto j = 0; j < mSize.y; j++) {
+					ar >> get(i, j);
+				}
+			}
+		}
 	};
 }
\ No newline at end of file
diff --git a/Containers/public/List.hpp b/Containers/public/List.hpp
index 470781b..2da3168 100644
--- a/Containers/public/List.hpp
+++ b/Containers/public/List.hpp
@@ -10,7 +10,7 @@ namespace tp {
 	template <typename Type, class Allocator = DefaultAllocator>
 	class List {
 
-		typedef SelCopyArg<Type> TypeArg;
+		typedef SelectValueOrReference<Type> TypeArg;
 		typedef ualni Index;
 
 	public:
@@ -73,7 +73,7 @@ namespace tp {
 
 		List() = default;
 
-		List(const init_list<Type>& list) { operator=(list); }
+		List(const InitialierList<Type>& list) { operator=(list); }
 
 		[[nodiscard]] inline Node* first() const { return mFirst; }
 		[[nodiscard]] inline Node* last() const { return mLast; }
@@ -221,7 +221,7 @@ namespace tp {
 			return *this;
 		}
 
-		List& operator+=(const init_list<Type>& list) {
+		List& operator+=(const InitialierList<Type>& list) {
 			for (auto item : list) {
 				pushBack(item);
 			}
@@ -235,7 +235,7 @@ namespace tp {
 			return *this;
 		}
 
-		List& operator=(const init_list<Type>& list) {
+		List& operator=(const InitialierList<Type>& list) {
 			removeAll();
 			*this += list;
 			return *this;
@@ -295,22 +295,23 @@ namespace tp {
 			}
 		}
 
-		template<class Saver>
-		void write(Saver& file) const {
-			file.write(mLength);
+	public:
+		template<class tArchiver>
+		void archiveWrite(tArchiver& ar) const {
+			ar << mLength;
 			for (auto item : *this) {
-				file.write(item.data());
+				ar << item.data();
 			}
 		}
 
-		template<class Loader>
-		void read(Loader& file) {
+		template<class tArchiver>
+		void archiveRead(tArchiver& ar) {
 			removeAll();
-			ualni len;
-			file.read(len);
+			decltype(mLength) len;
+			ar >> len;
 			for (auto i = len; i; i--) {
 				auto node = newNodeNotConstructed();
-				file.read(node->data);
+				ar >> node->data;
 				pushBack(node);
 			}
 		}
diff --git a/Containers/public/Map.hpp b/Containers/public/Map.hpp
index cac899e..eb80279 100644
--- a/Containers/public/Map.hpp
+++ b/Containers/public/Map.hpp
@@ -7,11 +7,11 @@
 namespace tp {
 
 	template<typename Key>
-	ualni DefaultHashFunc(SelCopyArg<Key> key) {
+	ualni DefaultHashFunc(SelectValueOrReference<Key> key) {
 		return hash(key);
 	}
 
-	template<typename tKey, typename tVal, class tAllocator = DefaultAllocator, ualni(*tHashFunc)(SelCopyArg<tKey>) = DefaultHashFunc<tKey>, int tTableInitialSize = 4>
+	template<typename tKey, typename tVal, class tAllocator = DefaultAllocator, ualni(*tHashFunc)(SelectValueOrReference<tKey>) = DefaultHashFunc<tKey>, int tTableInitialSize = 4>
 	class Map {
 
 		enum {
@@ -20,8 +20,8 @@ namespace tp {
 			MAP_MAX_LOAD_PERCENTAGE = 66,
 		};
 
-		typedef SelCopyArg<tKey> KeyArg;
-		typedef SelCopyArg<tVal> ValArg;
+		typedef SelectValueOrReference<tKey> KeyArg;
+		typedef SelectValueOrReference<tVal> ValArg;
 
 	public:
 
@@ -35,7 +35,8 @@ namespace tp {
 
 		struct Idx {
 			alni idx = -1;
-			operator bool() { return idx != -1; }
+			[[nodiscard]] bool isValid() const { return bool(*this); }
+			explicit operator bool() const { return idx != -1; }
 		};
 
 	private:
@@ -365,24 +366,24 @@ namespace tp {
 			return mNSlots;
 		}
 
-		template<class Saver>
-		void write(Saver& file) {
-			file.write(mNEntries);
+		template<class Archiver>
+		void archiveWrite(Archiver& ar) const {
+			ar << mNEntries;
 			for (auto item : *this) {
-				file.write(item->val);
-				file.write(item->key);
+				ar << item->val;
+				ar << item->key;
 			}
 		}
 
-		template<class Loader>
-		void read(Loader& file) {
+		template<class Archiver>
+		void archiveRead(Archiver& ar) {
 			removeAll();
-			ualni len;
-			file.read(len);
+			decltype(mNSlots) len;
+			ar >> len;
 			for (auto i = len; i; i--) {
 				auto node = newNodeNotConstructed();
-				file.read(node->val);
-				file.read(node->key);
+				ar >> node->val;
+				ar >> node->key;
 				put(node);
 			}
 		}
diff --git a/Containers/public/Tree.hpp b/Containers/public/Tree.hpp
index dfeefc2..2dd1ec7 100644
--- a/Containers/public/Tree.hpp
+++ b/Containers/public/Tree.hpp
@@ -25,8 +25,8 @@ namespace tp {
 
 	template <typename Key, typename Data, class Allocator = DefaultAllocator>
 	class AvlTree {
-		typedef SelCopyArg<Key> KeyArg;
-		typedef SelCopyArg<Data> DataArg;
+		typedef SelectValueOrReference<Key> KeyArg;
+		typedef SelectValueOrReference<Data> DataArg;
 
 	public:
 		class Node {
@@ -369,5 +369,32 @@ namespace tp {
 		}
 
 		bool isValid() { return findInvalidNode(head()) == nullptr; }
+
+		template<typename tFunctor>
+		void traverse(Node* node, bool after, tFunctor functor) {
+			if (!after) functor(node);
+			if (node->mLeft) traverse(node->mLeft, after, functor);
+			if (node->mRight) traverse(node->mRight, after, functor);
+			if (after) functor(node);
+		}
+
+		void removeAll() {
+			traverse(mRoot, true, [this](Node* node) {
+				deleteNode(node);
+			});
+			mRoot = nullptr;
+			mSize = 0;
+		}
+
+	public:
+		template<class tArchiver>
+		void archiveWrite(tArchiver& file) const {
+			FAIL("not implemented")
+		}
+
+		template<class tArchiver>
+		void archiveRead(tArchiver&) {
+			FAIL("not implemented")
+		}
 	};
 }
\ No newline at end of file
diff --git a/Containers/tests/ListTest.cpp b/Containers/tests/ListTest.cpp
index e23deb4..394826f 100644
--- a/Containers/tests/ListTest.cpp
+++ b/Containers/tests/ListTest.cpp
@@ -2,6 +2,7 @@
 
 #include "Tests.hpp"
 #include "Testing.hpp"
+#include "Archiver.hpp"
 
 using namespace tp;
 
@@ -53,18 +54,19 @@ TEST_DEF_STATIC(Copy) {
 	list2.removeAll();
 }
 
-TEST_DEF_STATIC(SaveLoad) {
+TEST_DEF_STATIC(Serialization) {
 	tp::List<TestClass, HeapAlloc> list = { TestClass(1), TestClass(2), TestClass(3), TestClass(4) };
 
-	TestFile file;
+	ArchiverExample<1024, false> write;
+	ArchiverExample<1024, true> read;
 
-	list.write(file);
+	write % list;
 
 	list.removeAll();
 
-	file.setAddress(0);
+	memCopy(read.mBuff, write.mBuff, sizeof(write.mBuff));
 
-	list.read(file);
+	read % list;
 
 	ualni i = 0;
 	for (auto iter : list) {
@@ -79,5 +81,5 @@ TEST_DEF_STATIC(SaveLoad) {
 TEST_DEF(List) {
 	testSimplePointer();
 	testSimpleReference();
-	testSaveLoad();
+	testSerialization();
 }
\ No newline at end of file
diff --git a/Containers/tests/MapTest.cpp b/Containers/tests/MapTest.cpp
index d5ce1f7..1afd47e 100644
--- a/Containers/tests/MapTest.cpp
+++ b/Containers/tests/MapTest.cpp
@@ -3,6 +3,7 @@
 #include "Tests.hpp"
 #include "Testing.hpp"
 #include "Map.hpp"
+#include "Archiver.hpp"
 
 using namespace tp;
 
@@ -100,17 +101,18 @@ TEST_DEF_STATIC(SaveLoad) {
 		map.put(i, TestClass(i));
 	}
 
-	TestFile file;
+	ArchiverExample<1024, false> write;
+	ArchiverExample<1024, true> read;
 
-	map.write(file);
+	write % map;
 
 	map.removeAll();
 
 	TEST(map.size() == 0);
 
-	file.setAddress(0);
+	memCopy(read.mBuff, write.mBuff, sizeof(write.mBuff));
 
-	map.read(file);
+	read % map;
 
 	TEST(map.size() == 10);
 
diff --git a/Containers/tests/Tests.hpp b/Containers/tests/Tests.hpp
index 3e47e0b..20f09ef 100644
--- a/Containers/tests/Tests.hpp
+++ b/Containers/tests/Tests.hpp
@@ -28,37 +28,6 @@ public:
 	void setVal(tp::ualni val) { val1 = val; }
 };
 
-class TestFile {
-	tp::ualni mem[1024] = { 0 };
-	tp::ualni address = 0;
-
-public:
-	TestFile() = default;
-
-	template<typename Type>
-	void write(const Type& val) {
-		val.write(*this);
-	}
-
-	template<>
-	void write<tp::ualni>(const tp::ualni& val) {
-		mem[address] = val;
-		address++;
-	}
-
-	void setAddress(tp::ualni addr) { address = addr; }
-
-	template<typename Type>
-	void read(Type& val) {
-		val.read(*this);
-	}
-
-	template<>
-	void read<tp::ualni>(tp::ualni& val) {
-		val = mem[address];
-		address++;
-	}
-};
 
 void testList();
 void testMap();
diff --git a/Math/private/Camera.cpp b/Math/private/Camera.cpp
index d024aab..a2c6800 100644
--- a/Math/private/Camera.cpp
+++ b/Math/private/Camera.cpp
@@ -67,7 +67,7 @@ Vec3F Camera::project(Vec2F normalized) {
 	halnf w = halnf((mTarget - mPos).length());
 	Vec4<halnf> world_pos4(normalized.x * w, normalized.y * w, z, w);
 
-	return inv * world_pos4;
+	return Vec3F(inv * world_pos4);
 }
 
 Vec2F Camera::project(const Vec3F& world) {
diff --git a/Math/public/Vec.hpp b/Math/public/Vec.hpp
index 5c165e1..3f5b1d4 100644
--- a/Math/public/Vec.hpp
+++ b/Math/public/Vec.hpp
@@ -6,7 +6,7 @@ namespace tp {
 
 	template <typename Type, const ualni tSize>
 	class Vec {
-		typedef SelCopyArg<Type> TypeArg;
+		typedef SelectValueOrReference<Type> TypeArg;
 
 	private:
 		Type mBuff[tSize];
@@ -21,7 +21,7 @@ namespace tp {
 			MODULE_SANITY_CHECK(gModuleMath)
 		}
 
-		Vec(TypeArg val) {
+		explicit Vec(TypeArg val) {
 			assign(val);
 		}
 
@@ -185,7 +185,7 @@ namespace tp {
 			return dot(in);
 		}
 
-		alnf length2() const {
+		[[nodiscard]] alnf length2() const {
 			alnf sum = 0;
 			for (ualni i = 0; i < tSize; i++) {
 				Type val = get(i);
@@ -194,7 +194,7 @@ namespace tp {
 			return sum;
 		}
 
-		alnf length() const {
+		[[nodiscard]] alnf length() const {
 			return sqrt(length2());
 		}
 
@@ -250,18 +250,18 @@ namespace tp {
 		}
 
 		template <typename TypeIn>
-		Vec(TypeIn Vec[2]) {
+		explicit Vec(TypeIn Vec[2]) {
 			x = (Type) Vec[0];
 			y = (Type) Vec[1];
 		}
 
 		template <typename TypeIn>
-		Vec(TypeIn val) {
+		explicit Vec(TypeIn val) {
 			x = y = (Type) val;
 		}
 
 		template <typename TypeIn>
-		Vec(Vec<TypeIn, 2>& Vec) {
+		explicit Vec(Vec<TypeIn, 2>& Vec) {
 			x = (Type) Vec.x;
 			y = (Type) Vec.y;
 		}
@@ -381,11 +381,11 @@ namespace tp {
 			return { -y, x };
 		}
 
-		alnf length2() const {
+		[[nodiscard]] alnf length2() const {
 			return (x * x + y * y);
 		}
 
-		alnf length() const {
+		[[nodiscard]] alnf length() const {
 			Type const tmp = (Type) (x * x + y * y);
 			return sqrt(tmp);
 		}
@@ -419,9 +419,9 @@ namespace tp {
 		Type z;
 
 		// Initialization
-		Vec() {}
+		Vec() = default;
 
-		Vec(const Vec<Type, 4>& in) {
+		explicit Vec(const Vec<Type, 4>& in) {
 			x = in[0];
 			y = in[1];
 			z = in[2];
@@ -433,13 +433,13 @@ namespace tp {
 			z = aZ;
 		}
 
-		Vec(Type Vec[3]) {
+		explicit Vec(Type Vec[3]) {
 			x = Vec[0];
 			y = Vec[1];
 			z = Vec[2];
 		}
 
-		Vec(Type x) {
+		explicit Vec(Type x) {
 			assign(x);
 		}
 
@@ -584,7 +584,7 @@ namespace tp {
 			return (x * in.x + y * in.y + z * in.z);
 		}
 
-		alnf length() const {
+		[[nodiscard]] alnf length() const {
 			return sqrt((halnf) (x * x + y * y + z * z));
 		}
 
@@ -632,11 +632,11 @@ namespace tp {
 			z = (Type) (tmp * sinA + z * cosA);
 		}
 
-		halnf angelX() const {
+		[[nodiscard]] halnf angelX() const {
 			return (halnf) atan2(y, z);
 		}
 
-		halnf angelY() const {
+		[[nodiscard]] halnf angelY() const {
 			return (halnf) atan2(x, z);
 		}
 	};
diff --git a/Modules/.vs/slnx.sqlite b/Modules/.vs/slnx.sqlite
new file mode 100644
index 0000000000000000000000000000000000000000..7b621f2557188917c5604ecb8b552dbc0710bfff
GIT binary patch
literal 90112
zcmeI4Piz}kdcbEi6e&?6pAto84HfYONMNz{$l`x;gA}Eyk<FN*B$BdYs01;b8QMfB
zQV~ar1>_>TF|Zpn#rD=)+so#%heZ$V0=p=BD0)~FMYo3n4T>JRD1rh-fgaihn?v85
znaBA{Q!BSBtb7DC<h=L2_rCXg-}lY?L$SV7>1rz98656Q8lPeo7?x#zi{}}JnZ|!t
z@E?6G;tv6OgWp-(=W!pWnbo}%sfb0tBr>m~U(SCqzc6<%{Q2x>Ghc?d;12iwsjsJM
zQ}2(f0@7a@0y9L@)3>9c*aLw*-Rbrf^-29?zdh)!tDSDYt91wcmhrLwXrtRx%Sx;4
zCxl8hvDgs#a&=w&fZsb)9nDCX$FHrbSH8)w>^Yll#!r_bp;!s4dB<PPs<f~AD;J%h
zoK<pyN<^^9m$oVu(%0%%saO}|pT0LAiU|VyJwcP&J=NWH_kF}vrcu0I5q)|d39lGj
zJP^xD6Z36|cf=aMT`O-EYY+K*;zPc;+t?~sakZObwSl$5f4h~+O|zEm!@+S^Q4j5<
zsf-~)2B9Wyh&8cV66^dPEg|-`u6EK~871H<;#LtnZoAv-1O&!VDz1x;taY&>T3J*X
z17P)ju~xcUtgR$7nfORy7gt(j<EYm=**TJW-A-3k{3>vc2Q7CGTZzSs_L$}tWmz2#
zyX|g|ba8~$E#|U8kDS$IJ3!(n^^>8d?vD_<lL$)QDt#W7m4Pe~|Evu@9^U~fR2uY-
z_WNGBNH~6aYc3RPVZUnWex++FOZ~ojSd!$&YRjv-;bm^Yd8e1Tv&YtB^Er1JY<u3;
zoAGD6Vcp}NH+7G5mvZ0FIX%vujoYUl=gzYG%o#k+98f=<J(lC}IKAD;2J>?ELfzWl
zDQfQyZK&YLcxi&i|NWi3adLp8B#l(G3F>)`?!G$Ir2T^?Pl89Iyon<zj#tDIh1pQ-
zR-Ao`bW5bolKNWYLK6(d!sf8<R?9oPqbCoQ85Odb7tJ#}hMzGs#ZcK5NJhE$)x#ln
zG*9Gz%FKjf@i_bJUEL08Wk&VRyIH3VIx}q+NHgq%bOy^aEMugw(H$$yu1$=xwB1ox
z&r+BS*>^&rm?+R8a~pDNTRK$xT8o5jcixQe__?L*HQ0vIEk-5`eoyC{_;IGI;4VOH
z`Sf-$6#EcIz7s3**}Twf+FQ~V|7_wRvp?n($X#qgZ4>(Tf=(<=+owgIW(gI4g@Y3m
zwn|P=&JTS2+1-E<q)S$iw$XCyIqh^1cec$%+*#*y6+>ss%Fi$p89N46tkdHdnNN||
zIi>_J7val8!ludJE_<he6=|q#wTJ5Av5KcfR^&Bji~PE{QQWOGc=_m1_gIaFY3$?!
zE)+{Fv!~Z|H>s<d*6lyiecGIF8z}*&J$dDHGt#H~MuBlo8{eJ^#%|nTAL^Df{0Ps{
z)Yee_=t%A3S)22gbJ&e5bES`s|0XUOKfS|-V#~|yQ&q3i)XjXGa@4VBrrJ!-Ot~;i
zyD#;Q@Ho1xa~H4GUJFO?m5VMj=&NW7zrhO#00AHX1b_e#00KY&2mk>f00h2$1g>xa
z<`ycG^EteqM-DhjgQLEdc$S=+X5M{XAbS9Mu5l(+H+K1lDOHu%vPoG;q_Zg@oy)HY
zQc6|?HJeGOYlTcMtK#H#Dk*34IU$)($U<7qDuR@h5<*JJ=hE$tlvL7+kZY&fN=8Wu
z`BXM3q?0*C$QPuvkV_{!Ni~_wWaXq#Xm|33c0m@@f`V&W%cXElsjQGvbM0g<-^nE8
zoFHeD`D{*>g=|jB3+aNK6{Lc)CM4TxCzUNI`E~~jwL9s2CY=-3+G-Z-q$F{}xF2#N
zsdQ2qMO6z0K`A5?Njakkg<M9$HDO69mq`i9P9~piciNq`Tux9raxPOy6okAYVa3~N
zS!gTijF8A?lw@1(WINe}pk@-8Y+CII=}ew*>Li4GF4@5da-B>@QVUs3Mpg2Obh?le
zQfrxvkj}~pq0mv+1l*V`7c!}}RANo&<T7$T*IpA8C6gA?o$Q)W$YSEM(oxp3dEBXF
z@(LSZuE*;51ZH0{cV!c+sntvb{Sz~Ve$JquqksMOnK<+q2mk>f00e*l5C8%|00;m9
zAOHk_z^h7Nj^&nF^D71%?!?@z@fDXhrZ|Chf7@jtj3qeqQwIGM{T=%ESGCWeHxK{<
zKmZ5;0U!VbfB+Bx0zd!=0D((PV2QiMdcL2*EpzX(W4@a)wZL7Ub$khceE)wTy2qe@
zLw|$*4E-_sF4E9L^qc5S#6`b~{&n<+(ch0AVF7pn0U!VbfB+Bx0zd!=00AHX1b_e#
z@F(zV3qj@@I~#1^A7~k_$_EF*nJ<6$`n~r*nOjCd<{grQe}$#o?+jKS9~=Z|=GADB
zc?)N54wR#w>d1OC5@c@REU|ywJskA+@o#}R@~_StMN5PI{XyTEHD_cMhxkVeT&2Q}
z2C<?X)#c4uZ-e&yt22%U9a$kqgZ8Y&V33J1GeM1jp-si6F)d~`h=2HOeN$ZBS7^o?
zfgp1gOCKDydtI5PE^$F-nWP?ek0ni|$-h1oWa7A%(x&vGTImw-+7pfDzQzWbMO<k0
zc+@O8|6f2?81yyz0zE?ig8l$~fIda*=on?tKj1xqzd(PAuAsO5hZs_U01yBIKmZ5;
z0U!VbfB+Bx0zd!=yvhV3+%<NzZLzSxy~EnKDo~Vri?y~VqKn)O*0m)OAtKf`#5}pR
zwjSne72u75u)6}BHfyT@-_F=7z_+1UF2?HH2SK9hXwP6e%w1)Tje@`&{x<+~cYu4H
zi?hxxfvF(3IE(iIjP?Hy81xPLFZ3VyTL537e@6d^{vQ1;`WgC5^ylcu=uglO(GOnb
z(FEOr01yBIKmZ5;0U!VbfB+Bx0zd!=ydngqIhGABkZS<x*QkDt=+}AuI!CTtSijEd
z*BSj93UCY?B$sJ&36Kj%E>j%G%<Aj^=r;`dZ}f-g0r~~{J+y&N&>DJ-uHjvPpP`?i
zA4R`G^REaeP!k9M0U!VbfB+Bx0zd!=00AHX1b~2t018}Vtz-V+!s~%|@V)(i63{~6
zE!K9_ABZjmZm{md{y;<*vyS@%^Lm1H;2)T?SA-Anxv-}qk~(Xzh$PI|D<TP@a3IE*
zNB_~lHO6-KKNq;l(8K@vz%u@9{BHoa7>G0O<Nr`#ks;^*<p2Mf1rHiX00KY&2mk>f
z00e*l5C8%|00;m9AOHj|5dm`k59|L+G@#HGAOHk_01yBIKmZ5;0U!VbfB+Bx0zL%b
z{ND!(Bmn^+00e*l5C8%|00;m9AOHk_01&uj1mOJtk_{+y2M7QGAOHk_01yBIKmZ5;
z0U!VbfPfDHIRE#70!css2mk>f00e*l5C8%|00;m9AOHj|838!|zhnan-2nnX00;m9
zAOHk_01yBIKmZ5;0U+Q*0M`FLP#_5i00AHX1b_e#00KY&2mk>f00e-*B_jae|G#7d
z3f%z$KmZ5;0U!VbfB+Bx0zd!=00AK2Lx8OR!y%4A+2}8#!}%}f7v}DTKcD?<=F1Ql
z+~K}I_4QP3>V2PrkOTzA5D5Gz_CR1yce;H=eNsQ!Zx4FwYNy-pYTZG<Wqj;E+UWMw
zveGL1387L=EH*^GTwNDG;P=i{M>7)U@oTH<m2dJZd(LK?@zbS9C|1I1-tkwnD($QO
z%0(wAXO*0w5)o|jrL9VZ^tHNGD%QpLr|->&VuHYaPtc@xPjz?QeIGHEX%uf)M4z5V
z!Yc+B55%(4#C#j#9kIr5*UFp4+C%=H_>eE|Hnz%DT<xY<ZD6hN-)^OH)2wCtaB$pJ
z)I)n|Dr1O{L8yrvVoj`;#5%u6ONf1~tDQ7gMhUozxK#v?+wS%{0f8};itC~yYhA2}
zRu)yp09d_Wtd;H-Yb(i2CO%Tw#g!J>IO_FIc8;W8x6@S>zY3h=LCf94R$}p@J*K%u
zSyqR`ZoAtfT^wO`i@9vjBWHEl4v;uX{bZ=A`y+(zB!ZH+N}q>iWgtt$KWl@J$9I4V
zl?J_|{k~T&5{{qVnhV8R*sof;U+J34QopYrmL&PH+VZMyc$r&p-sxrT?6LLOe9m14
z+n%@eX8hT1SogT+P2J<%rQG*(PLFeE<Mye?xwGs(a|Vwy2h>kzkL5T#PH%Uz!MvQk
zP`9>sirTwF8!9+5UYg+Xe}5-$oE+dNNh1|)f_h$~yRQy4Y5$<fli<-PZ{kRb;}x+)
zVKx-I6=$C!-4bcDq`nrp&;&!VusN)|)$-2n=*dH6MulwVMf1##;b#m@F;sR1l2Pt`
z^>BzC%@g^bGBcrAJkCCQSGPl2nNhv-Zq{jo&P<yH(hU0`ox$=9%NQwabjJ#_YZId^
zZFkhwvlJ#n_MK2DCJJ=O+=krRmJZdv)*@lsoj2n<er_py4Yr|li;)R~-_!Xfew^tl
zxC;<lKD`|b#XiK5@5G9HHZL@r_Lj88Kbv^S?2kDGau=IW+l0Qopc6~e_Gyu)Swh8M
z;ot;?t&$Uz^8+7$b~j)I>5>(sZM58aPCFgMoo#awch>n_#n9QZ@-xgt#*Tp%>-0EA
z=2PT#jw!**MfmcNuxawQ%id{VMH*^b?V);jtm0{r6?x6sBEK$f6n85PUOqb1JyxS(
z8aw%b3&j%4?CCY#P3o$qb^DKWpEl>)MoPeGPhL6QjP&WgQDB_Y#<!<}u^Ttohq~nq
zKf-e~wKY^fI#T<1*5<tB9CqW%T<K%uzllr6Pw%jy*zz*_RMqP=bu-_l9ChrOsWy`{
zQ!dQX?n}KRJdQ5wG#--r`k(onLDl)s=l*kUYbFu;B=}c>3in4i@xouv7v2ah3Bt^0
z501O)$7HU)EoqPSCtz0{y6;WS_sik~-krxw!$|l+xp5c!O=-7QFW(ovGR3+%RU`gY
z$4iV-gZIV*zF6mPOGC#TysX^h$2l;OFBx`kh!{_BQiOyFN4EBu->7YEdRnzS7tcqw
zs@AQcrFBm<-(K}m&ndD|U;Wk9^;Ds&|H&u(_20hE<G1bAQ8#fv?7h|=TV;*@xrUNR
zZ(B0uY89_S-^c4t4+$c<QOC=AOB#2^XO!Nv>qCML#g0QxBuq!QzWN(CU3w2kh7k$B
zNZGR}iB%n^n|F+`f!@W-WPfAf%XNJsd%Ch1itWYO(}%8E#k!<PV^={IA0l?e8A_d*
zW9#sJOq1$Jptb6tn49t6dGfkGf&K0c*E5<FvI>y9C1;FuX4*ofGvj;_)2d^ns`ZF9
zA6S-go#Qe4k}GdIS+@6%E^{1DeJW^l<3&3uFIq`ikAcba_;XBa%!f@w{J^<!)Q}Dz
zshZzYXv|JcY0%fyCub=^77oeR@UBD3vFo5u4{K^i#lb*UTcc0J9_YrSWgDaHH^w>3
zNW#A=Uw0Xm!J{?$Y$$*i49SH_O0TO2YG0B1+61K+CoAn+)kLLTrJC{Q%P15}rP$AG
zyCqK2K1>(Jx%-HTug{Niy^ec^RV>{<p>E^nU;chiOH6jOUwO;Y&GUaZ5?S3j&lcba
zw`ri3ZvVdv5r<x6LfGU-;blzl_&<y`qn#(`zLdG=^ma4^haY8freg~&?n8^QD>XR$
zfWwb-?R3246pWs0eESYR;Q#+Ge3Jtj1Oh++2mk>f00e*l5C8%|00;m9AaLOXVEupL
z$e}?X00e*l5C8%|00;m9AOHk_01yBI7ft|v|L?+)LxVs72mk>f00e*l5C8%|00;m9
pAOHj|oB*8vUpR7T5C{MPAOHk_01yBIKmZ5;0U!VbfWU<l_#dBh8fX9j

literal 0
HcmV?d00001

diff --git a/Modules/CMakeLists.txt b/Modules/CMakeLists.txt
index c3c6221..519f53f 100644
--- a/Modules/CMakeLists.txt
+++ b/Modules/CMakeLists.txt
@@ -12,7 +12,8 @@ target_include_directories(${PROJECT_NAME} PUBLIC ./public/)
 
 ### -------------------------- Tests  --------------------------  ###
 enable_testing()
-add_executable(${PROJECT_NAME}Tests ${CMAKE_CURRENT_SOURCE_DIR}/tests/Tests.cpp)
+file(GLOB SOURCES_TEST "./tests/*.cpp")
+add_executable(${PROJECT_NAME}Tests ${SOURCES_TEST})
 target_link_libraries(${PROJECT_NAME}Tests  ${PROJECT_NAME})
 add_test(NAME ${PROJECT_NAME}Tests COMMAND ${PROJECT_NAME}Tests)
 
diff --git a/Modules/public/Archiver.hpp b/Modules/public/Archiver.hpp
new file mode 100644
index 0000000..825bb1b
--- /dev/null
+++ b/Modules/public/Archiver.hpp
@@ -0,0 +1,146 @@
+#pragma once
+
+#include "Common.hpp"
+
+namespace tp {
+
+	// Used to transfer data to or from some sort of archive
+	// Abstracts interface so that actual archive must only overload readBytes and writeBytes
+	// The main idea is that it transfers data as bytes only if this type of data does not have special API functions
+	template <bool tRead>
+	class ArchiverTemplate {
+	public:
+		struct HasFunc {
+			typedef ArchiverTemplate& ArchRef;
+			template <typename T, typename = void> struct Write : FalseType {};
+			template <typename T> struct Write<T, VoidType<decltype(DeclareValue<T>()().archiveWrite(DeclareValue<ArchRef>()()))>> : TrueType {};
+
+			template <typename T, typename = void> struct Read : FalseType {};
+			template <typename T> struct Read<T, VoidType<decltype(DeclareValue<T>()().archiveRead(DeclareValue<ArchRef>()()))>> : TrueType {};
+
+			template <typename T, typename = void> struct Archive : FalseType {};
+			template <typename T> struct Archive<T, VoidType<decltype(DeclareValue<T>()().archive(DeclareValue<ArchRef>()()))>> : TrueType {};
+
+			template <typename T>
+			struct AssertCombinations {
+				static constexpr auto assert() {
+					if (HasFunc::template Read<T>::value != HasFunc::template Write<T>::value) return false;
+					if (HasFunc::template Read<T>::value) {
+						if (HasFunc::template Read<T>::value == HasFunc::template Archive<T>::value) return false;
+					}
+					return true;
+				}
+			};
+		};
+
+	public:
+		virtual void writeBytes(const int1* val, ualni size) = 0;
+		virtual void readBytes(int1* val, ualni size)  = 0;
+
+	public:
+		ArchiverTemplate() = default;
+
+		// check if type has explicit write method. if not write as bytes
+		template<typename Type>
+		void operator <<(const Type& val) {
+			static_assert(!tRead);
+			static_assert(HasFunc::template AssertCombinations<Type>::assert());
+			if constexpr (HasFunc::template Write<Type>::value) {
+				val.archiveWrite(*this);
+			} else {
+				writeBytes((const int1*) &val, sizeof(val));
+			}
+		}
+
+		// check if type has explicit read method. if not read as bytes
+		template<typename Type>
+		void operator >>(Type& val) {
+			static_assert(tRead);
+			static_assert(HasFunc::template AssertCombinations<Type>::assert());
+			if constexpr (HasFunc::template Read<Type>::value) {
+				val.archiveRead(*this);
+			} else {
+				readBytes((int1*) &val, sizeof(val));
+			}
+		}
+
+		// check if type has explicit archive method. if not read/write as bytes
+		template<typename Type>
+		void operator %(Type& val) {
+			static_assert(HasFunc::template AssertCombinations<Type>::assert());
+			if constexpr (HasFunc::template Archive<Type>::value) {
+				val.archive(*this);
+			} else {
+				if constexpr (tRead) {
+					operator>>(val);
+				} else {
+					operator<<(val);
+				}
+			}
+		}
+
+		template<typename Type>
+		void operator %(const Type& val) {
+			static_assert(HasFunc::template AssertCombinations<Type>::assert());
+			if constexpr (HasFunc::template Archive<Type>::value) {
+				((Type&)val).archive(*this);
+			} else {
+				if constexpr (tRead) {
+					operator>>(val);
+				} else {
+					operator<<(val);
+				}
+			}
+		}
+	};
+
+	template<ualni tMaxMemory, bool tRead>
+	class ArchiverExample : public ArchiverTemplate<tRead> {
+	public:
+		ArchiverExample() = default;
+
+	protected:
+		void incrementAddresses(ualni size) {
+			if (mFirstNotWritten == mAddress) mFirstNotWritten += size;
+			mAddress += size;
+		}
+
+		void writeBytes(const int1* val, ualni size) override {
+			for (auto i = 0; i < size; i++) mBuff[mAddress + i] = val[i];
+			incrementAddresses(size);
+		}
+
+		void readBytes(int1* val, ualni size) override {
+			for (auto i = 0; i < size; i++) val[i] = mBuff[mAddress + i];
+			incrementAddresses(size);
+		}
+
+		template<typename tType>
+		static void test() {
+			const tType val;
+			tType res;
+
+			res.change();
+
+			ArchiverExample<tMaxMemory, false> write;
+			ArchiverExample<tMaxMemory, true> read;
+
+			write % val;
+
+			for (auto i = 0; i < tMaxMemory; i++) read.mBuff[i] = write.mBuff[i];
+
+			read % res;
+
+			if (val != res) {
+				throw "test failed";
+			}
+		}
+
+	public:
+		int1 mBuff[tMaxMemory]{};
+
+	private:
+		ualni mAddress = 0;
+		ualni mFirstNotWritten = 0;
+	};
+}
\ No newline at end of file
diff --git a/Modules/public/Common.hpp b/Modules/public/Common.hpp
index 047f964..06c94ca 100644
--- a/Modules/public/Common.hpp
+++ b/Modules/public/Common.hpp
@@ -4,15 +4,40 @@
 #include "Environment.hpp"
 #include "TypeInfo.hpp"
 #include <initializer_list>
+#include <typeinfo>
+#include <utility>
 
 namespace tp {
 	template<typename Type>
-	using init_list = std::initializer_list<Type>;
+	using InitialierList = std::initializer_list<Type>;
 
 	// Selects whether to pass by constant reference or by value
 	template <typename tType>
-	using SelCopyArg = typename TypeSelect<(sizeof(tType) > sizeof(tp::alni)), const tType&, tType>::Result;
+	using SelectValueOrReference = typename TypeSelect<(sizeof(tType) > sizeof(tp::alni)), const tType&, tType>::Result;
 
+	template <typename tType>
+	using VoidType = void;
+
+	template <typename tType>
+	struct Reference {
+		tType& operator()() {}
+	};
+
+	template <typename tType>
+	struct DeclareValue {
+			tType operator()() {}
+	};
+
+	struct TrueType {
+			static constexpr auto value = true;
+	};
+
+	struct FalseType {
+			static constexpr auto value = false;
+	};
+}
+
+namespace tp {
 	ualni next2pow(ualni v);
 	uhalni next2pow(uhalni v);
 	ufalni next2pow(ufalni v);
diff --git a/Modules/public/SizeCounter.hpp b/Modules/public/SizeCounter.hpp
new file mode 100644
index 0000000..a44895d
--- /dev/null
+++ b/Modules/public/SizeCounter.hpp
@@ -0,0 +1,50 @@
+#pragma once
+
+#include "Common.hpp"
+
+namespace tp {
+
+	// TODO
+	template <bool tRecursive>
+	class SizeCounter {
+		typedef SizeCounter& ArchRef;
+		template <typename T, typename = void> struct HasSizeCounter : FalseType {};
+		template <typename T> struct HasSizeCounter<T, VoidType<decltype(DeclareValue<T>()().count(DeclareValue<ArchRef>()()))>> : TrueType {};
+
+	public:
+		SizeCounter() = default;
+
+		template<typename Type>
+		void count(const Type& val) {
+			if constexpr (HasSizeCounter<Type>::value) {
+				val.count(*this);
+			} else {
+				if constexpr (tRecursive) {
+					count(sizeof(val));
+				} else {
+					mSize += sizeof(Type);
+				}
+			}
+		}
+
+		void countSizeUnused(ualni size) {
+			mSizeUnused += size;
+		}
+
+		void countSize(ualni size) {
+			mSize += size;
+		}
+
+		[[nodiscard]] ualni getSizeUnused() const {
+			return mSizeUnused;
+		}
+
+		[[nodiscard]] ualni getSize() const {
+			return mSize;
+		}
+
+	private:
+		ualni mSize = 0;
+		ualni mSizeUnused = 0;
+	};
+}
\ No newline at end of file
diff --git a/Modules/tests/TestArchiver.cpp b/Modules/tests/TestArchiver.cpp
new file mode 100644
index 0000000..3c9ee68
--- /dev/null
+++ b/Modules/tests/TestArchiver.cpp
@@ -0,0 +1,202 @@
+
+#include "Archiver.hpp"
+#include <cstdio>
+#include <cstdlib>
+
+using namespace tp;
+
+bool sFailed = false;
+
+struct Undef {
+	char character1 = 'a';
+	bool boolean = true;
+	ualni integer = 321;
+	char character2 = 'a';
+
+	void change() {
+		character1++;
+		character2--;
+		integer++;
+		boolean = !boolean;
+	}
+
+	[[nodiscard]] bool operator!=(const Undef& in) const {
+		if (character1 != in.character1) return true;
+		if (character2 != in.character2) return true;
+		if (integer != in.integer) return true;
+		if (boolean != in.boolean) return true;
+		return false;
+	}
+};
+
+
+struct SimpleArchive {
+	char character = 'a';
+	ualni integer = 123;
+	bool boolean = true;
+	Undef undef;
+
+	template<typename tArchiver>
+	void archive(tArchiver& ar) {
+		ar % character;
+		ar % integer;
+		ar % boolean;
+		ar % undef;
+	}
+
+	void change() {
+		character++;
+		integer++;
+		boolean = !boolean;
+		undef.change();
+	}
+
+	[[nodiscard]] bool operator!=(const SimpleArchive& in) const {
+		if (character != in.character) return true;
+		if (integer != in.integer) return true;
+		if (boolean != in.boolean) return true;
+		if (undef != in.undef) return true;
+		return false;
+	}
+};
+
+struct Simple {
+	char character = 'a';
+	ualni integer = 123;
+	bool boolean = true;
+	Undef undef;
+
+	template<typename tArchiver>
+	void archiveRead(tArchiver& ar) {
+		ar >> character;
+		ar >> integer;
+		ar >> boolean;
+		ar >> undef;
+	}
+
+	template<typename tArchiver>
+	void archiveWrite(tArchiver& ar) const {
+		ar << character;
+		ar << integer;
+		ar << boolean;
+		ar << undef;
+	}
+
+	void change() {
+		character++;
+		integer++;
+		boolean = !boolean;
+		undef.change();
+	}
+
+	[[nodiscard]] bool operator!=(const Simple& in) const {
+		if (character != in.character) return true;
+		if (integer != in.integer) return true;
+		if (boolean != in.boolean) return true;
+		if (undef != in.undef) return true;
+		return false;
+	}
+};
+
+template<typename tType>
+struct Set {
+	tType buff[10];
+	ualni len = 5;
+
+	template<typename tArchiver>
+	void archiveRead(tArchiver& ar) {
+		ar >> len;
+		for (auto i = 0; i < len; i++) {
+			ar >> buff[i];
+		}
+	}
+
+	template<typename tArchiver>
+	void archiveWrite(tArchiver& ar) const {
+		ar << len;
+		for (auto i = 0; i < len; i++) {
+			ar << buff[i];
+		}
+	}
+
+	void change() {
+		len = 2;
+		for (auto i = 0; i < len; i++) {
+			buff[i].change();
+		}
+	}
+
+	[[nodiscard]] bool operator!=(const Set& in) const {
+		for (auto i = 0; i < len; i++) {
+			if (buff[i] != in.buff[i]) return true;
+		}
+
+		if (len != in.len) return true;
+		return false;
+	}
+};
+
+
+template<typename tType>
+struct Complex {
+	Undef undef;
+	Set<tType> set;
+
+	template<typename tArchiver>
+	void archive(tArchiver& ar) {
+		ar % set;
+		ar % undef;
+	}
+
+	void change() {
+		undef.change();
+		set.change();
+	}
+
+	[[nodiscard]] bool operator!=(const Complex& in) const {
+		return undef != in.undef || set != in.set;
+	}
+};
+
+template<typename tType>
+void test() {
+	constexpr auto size = 1024;
+
+	const tType val;
+	tType res;
+
+	res.change();
+
+	ArchiverExample<size, false> write;
+	ArchiverExample<size, true> read;
+
+	write % val;
+
+	for (auto i = 0; i < size; i++) read.mBuff[i] = write.mBuff[i];
+
+	read % res;
+
+	if (val != res) {
+		printf("Test %s Failed\n", typeid(tType).name());
+		sFailed = true;
+	}
+}
+
+template <typename T, typename A, typename = void> struct HasArchive : FalseType {};
+template <typename T, typename A> struct HasArchive<T, A, VoidType<decltype(DeclareValue<T>()().archive(DeclareValue<A&>()()))>> : TrueType {};
+
+void testArchiver() {
+
+	printf("has archive method - %i\n", HasArchive<SimpleArchive, ArchiverExample<10, false>>::value);
+	printf("has archive method - %i\n", ArchiverExample<10, false>::HasFunc::Archive<SimpleArchive>::value);
+	printf("has archive method - %i\n", ArchiverExample<10, false>::HasFunc::Archive<Simple>::value);
+
+	test<SimpleArchive>();
+	test<Simple>();
+	test<Set<Simple>>();
+	test<Complex<Simple>>();
+
+	if (sFailed) {
+		exit(1);
+	}
+}
diff --git a/Modules/tests/Tests.cpp b/Modules/tests/Tests.cpp
index 5910731..474d6d7 100644
--- a/Modules/tests/Tests.cpp
+++ b/Modules/tests/Tests.cpp
@@ -1,7 +1,7 @@
 
 #include "Module.hpp"
 
-#include "Common.hpp"
+void testArchiver();
 
 int main() {
 	tp::ModuleManifest* ModuleDependencies[] = { &tp::gModuleBase, nullptr };
@@ -13,10 +13,12 @@ int main() {
 
 	ASSERT(tp::gEnvironment.mWidth == tp::Environment::ArchWidth::X64);
 
-	ASSERT(tp::max(2, 1) == 2);
-	ASSERT(tp::max(-1, 0) == 0);
-	ASSERT(tp::max(0, -1) == 0);
-	ASSERT(tp::min(0, -1) == -1);
+	ASSERT(tp::max(2, 1) == 2)
+	ASSERT(tp::max(-1, 0) == 0)
+	ASSERT(tp::max(0, -1) == 0)
+	ASSERT(tp::min(0, -1) == -1)
+
+	testArchiver();
 
 	TestModule.deinitialize();
 }
\ No newline at end of file
diff --git a/TODO b/TODO
index c37edc4..47a4ae9 100644
--- a/TODO
+++ b/TODO
@@ -1,7 +1,7 @@
-Testing !
-Serialization !
+Testing !!
 
 Objects:
+  Testing
   Serialization
   Alloc Size queries
   Compile !!
@@ -16,25 +16,29 @@ Objects:
   rename classes
   move functions around
 
-Storage:
-  Finish networking
-  Enable preloads
-
 Graphics:
   Window event system
   Graphics API
   FPS count & Performance control
 
-Utils:
-  Stack trace fixes
-
 Containers:
+  Test generatePermutations
   Add variant size buffer
   Buffer add resize function
   Buffer improvements
+  Buff serialization
+  Tree serialization
+  Write Traverse Avl test
   Add mem leakage tests
   Add check copy times
   AVL dont copy data just swap
 
+Storage:
+  Finish networking
+  Enable preloads
+
+Utils:
+  Stack trace fixes
+
 TextEditor:
   Implement
diff --git a/Tokenizer/public/RegularExpression.h b/Tokenizer/public/RegularExpression.h
index 07f7bbc..322cd6a 100644
--- a/Tokenizer/public/RegularExpression.h
+++ b/Tokenizer/public/RegularExpression.h
@@ -342,7 +342,7 @@ namespace tp::RegEx {
 				return compileUtil(regex, state);
 			}
 
-			Node compile(Graph& aGraph, init_list<Pair<const tAlphabetType*, tStateType>> aRules) {
+			Node compile(Graph& aGraph, InitialierList<Pair<const tAlphabetType*, tStateType>> aRules) {
 				mGraph = &aGraph;
 
 				auto left = mGraph->addVertex();
@@ -513,7 +513,7 @@ namespace tp::RegEx {
 		}
 
 		template <typename tAlphabetType, typename tStateType, tStateType tNoStateVal, tStateType tFailedStateVal>
-		CompileError<tStateType>	compile(NFA<tAlphabetType, tStateType, tNoStateVal, tFailedStateVal>& out, const init_list<Pair<const tAlphabetType*, tStateType>>& rules) {
+		CompileError<tStateType>	compile(NFA<tAlphabetType, tStateType, tNoStateVal, tFailedStateVal>& out, const InitialierList<Pair<const tAlphabetType*, tStateType>>& rules) {
 			Compiler<tAlphabetType, tStateType, tNoStateVal, tFailedStateVal> compiler;
 			compiler.compile(out, rules);
 			return compiler.mError;
diff --git a/Tokenizer/public/Tokenizer.hpp b/Tokenizer/public/Tokenizer.hpp
index cdee460..bf32739 100644
--- a/Tokenizer/public/Tokenizer.hpp
+++ b/Tokenizer/public/Tokenizer.hpp
@@ -25,7 +25,7 @@ namespace tp {
 			MODULE_SANITY_CHECK(gModuleTokenizer)
 		}
 
-		void build(const init_list<Pair<const tAlphabetType*, tTokType>>& rules) {
+		void build(const InitialierList<Pair<const tAlphabetType*, tTokType>>& rules) {
 			NFA<tAlphabetType, tTokType, tNoTokVal, tFailedTokVal> nfa;
 			
 			mError = RegEx::compile(nfa, rules);
@@ -89,7 +89,7 @@ namespace tp {
 
 		SimpleTokenizer() = default;
 
-		void build(const init_list<Pair<const tAlphabetType*, tTokType>>& rules) {
+		void build(const InitialierList<Pair<const tAlphabetType*, tTokType>>& rules) {
 			mTokenizer.build(rules);
 		}
 
diff --git a/Utils/tests/Tests.cpp b/Utils/tests/Tests.cpp
index 79c6c18..d3e1a49 100644
--- a/Utils/tests/Tests.cpp
+++ b/Utils/tests/Tests.cpp
@@ -17,7 +17,7 @@ void printSnapshot(const tp::CallStackCapture::CallStack* snapshot) {
 }
 
 void common() {
-	gCSCapture->getSnapshot();
+	auto tmp = gCSCapture->getSnapshot();
 }
 
 void first() {