Work on serializaing multiple arguments

Author: KredeGC

include/bitstream/stream/bit_reader.h

@@ -271,6 +271,13 @@ namespace bitstream
 			return true;
 		}
 
+		/**
+		 * @brief Reads from the buffer into mulitple variables.
+		 * @note Pass multi<T>(...) to this in place of multiple calls to the regular serialize functions.
+		 * @tparam ...Args The types of the arguments to pass to the serialize function
+		 * @param ...args The arguments to pass to the serialize function
+		 * @return Whether successful or not
+		*/
 		template<typename... Args, typename = std::enable_if_t<(utility::has_instance_serialize_v<Args, bit_reader> && ...)>>
 		[[nodiscard]] bool serialize(Args&&... args)
 			noexcept((noexcept(std::declval<Args&>().serialize(std::declval<bit_reader&>())) && ...))

include/bitstream/stream/bit_writer.h

@@ -316,6 +316,13 @@ namespace bitstream
 			return true;
 		}
 
+		/**
+		 * @brief Writes to the buffer from multiple variables.
+		 * @note Pass multi<T>(...) to this in place of multiple calls to the regular serialize functions.
+		 * @tparam ...Args The types of the arguments to pass to the serialize function
+		 * @param ...args The arguments to pass to the serialize function
+		 * @return Whether successful or not
+		*/
 		template<typename... Args, typename = std::enable_if_t<(utility::has_instance_serialize_v<Args, bit_writer> && ...)>>
 		[[nodiscard]] bool serialize(Args&&... args)
 			noexcept((noexcept(std::declval<Args&>().serialize(std::declval<bit_writer&>())) && ...))

include/bitstream/stream/multi.h

@@ -8,22 +8,8 @@
 
 namespace bitstream
 {
-	namespace utility
-	{
-		// Check if type has a serializable trait
-		template<typename T, typename Stream, typename Void = void>
-		struct has_instance_serialize : std::false_type {};
-
-		template<typename T, typename Stream>
-		struct has_instance_serialize<T, Stream, std::void_t<decltype(std::declval<T&>().serialize(std::declval<Stream&>()))>> : std::true_type {};
-
-		template<typename T, typename Stream>
-		constexpr bool has_instance_serialize_v = has_instance_serialize<T, Stream>::value;
-	}
-
-
 	template<typename T, typename... Ts>
-	struct multi_tuple
+	struct multi_args
 	{
 		std::tuple<Ts...> Args;
 
@@ -35,8 +21,8 @@ namespace bitstream
 	};
 
 	template<typename T, typename... Args>
-	multi_tuple<T, Args&&...> multi(Args&&... args) noexcept
+	multi_args<T, Args&&...> multi(Args&&... args) noexcept
 	{
-		return multi_tuple<T, Args&&...>{ std::forward_as_tuple(std::forward<Args>(args) ...) };
+		return multi_args<T, Args&&...>{ std::forward_as_tuple(std::forward<Args>(args) ...) };
 	}
 }

include/bitstream/utility/meta.h

@@ -6,6 +6,17 @@
 
 namespace bitstream::utility
 {
+	// Check if instance has a serializable trait
+	template<typename T, typename Stream, typename Void = void>
+	struct has_instance_serialize : std::false_type {};
+
+	template<typename T, typename Stream>
+	struct has_instance_serialize<T, Stream, std::void_t<decltype(std::declval<T&>().serialize(std::declval<Stream&>()))>> : std::true_type {};
+
+	template<typename T, typename Stream>
+	constexpr bool has_instance_serialize_v = has_instance_serialize<T, Stream>::value;
+
+
 	// Check if type has a serializable trait
 	template<typename Void, typename T, typename Stream, typename... Args>
 	struct has_serialize : std::false_type {};

src/test/serialize_multi_test.cpp

@@ -5,39 +5,42 @@
 #include <bitstream/stream/bit_writer.h>
 
 #include <bitstream/traits/integral_traits.h>
+#include <bitstream/traits/quantization_traits.h>
 
 namespace bitstream::test::multi_serialize
 {
 	BS_ADD_TEST(test_serialize_multi)
 	{
 		// Test serializing multiple values at once
 		uint32_t in_value1 = 511;
-		uint32_t in_value2 = 99;
+		float in_value2 = 99.12345f;
+
+		bounded_range range(-1000.0f, 1000.0f, 0.001f);
 
 		// Write some values
 		byte_buffer<16> buffer;
 		fixed_bit_writer writer(buffer);
 
 		BS_TEST_ASSERT(writer.serialize(
 			multi<uint32_t>(in_value1, 328, 611),
-			multi<uint32_t>(in_value2, 11, 111)
+			multi<bounded_range>(range, in_value2)
 		));
 
 		uint32_t num_bits = writer.flush();
 
-		BS_TEST_ASSERT(num_bits == 16);
+		BS_TEST_ASSERT(num_bits == 30);
 
 		// Read the values back and validate
 		uint32_t out_value1;
-		uint32_t out_value2;
+		float out_value2;
 		fixed_bit_reader reader(buffer, num_bits);
 
 		BS_TEST_ASSERT(reader.serialize(
 			multi<uint32_t>(out_value1, 328U, 611U),
-			multi<uint32_t>(out_value2, 11U, 111U)
+			multi<bounded_range>(range, out_value2)
 		));
 
 		BS_TEST_ASSERT(out_value1 == in_value1);
-		BS_TEST_ASSERT(out_value2 == in_value2);
+		BS_TEST_ASSERT(std::abs(in_value2 - out_value2) <= range.get_precision());
 	}
 }