Very very experimental buffer read from deserializer

CMakeLists.txt

@@ -6,4 +6,5 @@ set(CMAKE_CXX_STANDARD 23)
 add_library(file_read STATIC
         file_deserialising.h
         buffer.cpp
-        buffer.h)
+        buffer.h
+        file_read.h)

buffer.h

@@ -7,8 +7,8 @@
 struct buffer
 {
 	char *data;
-	int size;
-	int allocated;
+	size_t size;
+	size_t allocated;
 
 	void write(char *data_in, int data_size);
 	void remove(int offset, int remove_size);

file_deserialising.h

@@ -2,10 +2,12 @@
 #include <tuple>
 #include <cstring>
 #include <print>
+#include <type_traits>
 #include "buffer.h"
+#define read_comp(size, ptr, t, sizes) const_for_<size>([&](auto i){std::get<i.value>(t) = read_var<std::tuple_element_t<i.value, std::remove_cvref_t<decltype(t)>>>::call(&ptr, sizes[i.value]);});
 #ifdef __APPLE__
 #include <libkern/OSByteOrder.h>
-#define read_comp(size, ptr, t) const_for_<size>([&](auto i){std::get<i.value>(t) = read_var<std::tuple_element_t<i.value, decltype(t)>>::call(&ptr);});
+
 
 
 #define htobe16(x) OSSwapHostToBigInt16(x)
@@ -35,13 +37,13 @@ struct parsing_buffer
 };
 
 template <typename T>
-static T read_type(char *data)
+static T read_type(char *data, size_t size)
 {
 	T a;
 
-	std::memcpy(&a, data, sizeof(T));
+	std::memcpy(&a, data, size);
 
-	switch (sizeof(T))
+	switch (size)
 	{
 		case 1:
 			break;
@@ -61,40 +63,50 @@ static T read_type(char *data)
 }
 
 template <>
-float read_type<float>(char *data)
+float read_type<float>(char *data, size_t size)
 {
 	uint32_t num_as_uint32;
 	float num;
 
-	memcpy(&num_as_uint32, data, sizeof(uint32_t));
+	memcpy(&num_as_uint32, data, size);
 	num_as_uint32 = be32toh(num_as_uint32);
-	memcpy(&num, &num_as_uint32, sizeof(float));
+	memcpy(&num, &num_as_uint32, size);
 
 	return num;
 }
 
 template <>
-double read_type<double>(char *data)
+double read_type<double>(char *data, size_t size)
 {
 	uint64_t num_as_uint64;
 	double num;
 
-	memcpy(&num_as_uint64, data, sizeof(uint64_t));
+	memcpy(&num_as_uint64, data, size);
 	num_as_uint64 = be64toh(num_as_uint64);
-	memcpy(&num, &num_as_uint64, sizeof(double));
+	memcpy(&num, &num_as_uint64, size);
 
 	return num;
 }
 
+template<>
+buffer read_type<buffer>(char *data, size_t size)
+{
+	buffer ret;
+	ret.allocated = size + 1;
+	ret.size = size;
+	ret.data = (char *)malloc(size * sizeof(char) + 1);
+
+	return ret;
+}
 
 template<typename T>
 struct read_var
 {
-	static T call(parsing_buffer* v)
+	static T call(parsing_buffer* v, size_t size)
 	{
-		if (sizeof(T) + v->consumed_size > v->buf.size)
+		if (size + v->consumed_size > v->buf.size)
 			return T{};
-		T ret = read_type<T>(v->point);
+		T ret = read_type<T>(v->point, size);
 		v->point += sizeof(T);
 		v->consumed_size += sizeof(T);
 		return ret;

file_read.h

@@ -17,11 +17,24 @@ class file_reader
 		}
 
 		template<typename ...T>
-		std::tuple<T...> read_from_tuple(std::tuple<T...> in)
+		std::tuple<T...> read_from_tuple(std::tuple<T...> &in)
 		{
-			constexpr std::size_t size_tuple = std::tuple_size_v<decltype(in)>;
+			constexpr std::size_t size_tuple = sizeof...(T);
 			int size = 0;
-			const_for_<size_tuple>([&](auto i){size += sizeof(std::get<i.value>(in));});
+			std::array<size_t, size_tuple> sizes;
+			const_for_<size_tuple>([&](auto i)
+			{
+				if (typeid(std::get<i.value>(in)) == typeid(buffer))
+				{
+					size += std::get<i.value>(in).size;
+					sizes[i.value] = std::get<i.value>(in).size;
+				}
+				else
+				{
+					size += sizeof(std::get<i.value>(in));
+					sizes[i.value] = sizeof(std::get<i.value>(in));
+				}
+			});
 			if (size > buf.size)
 			{
 				int extra_size = 0;
@@ -47,7 +60,7 @@ class file_reader
 			parsing_buffer par_buf(buf);
 			par_buf.point = buf.data;
 			par_buf.consumed_size = 0;
-			read_comp(size_tuple, par_buf, in);
+			read_comp(size_tuple, par_buf, in, sizes);
 			buf.remove(0, size);
 			return in;
 		}