Add trait deduction for serializables

Add compile-time asserts for serializable traits

Author: KredeGC

README.md

@@ -348,11 +348,13 @@ These examples can also be seen in [`src/test/examples_test.cpp`](https://github
 # Extensibility
 The library is made with extensibility in mind.
 The `bit_writer` and `bit_reader` use a template trait specialization of the given type to deduce how to serialize and deserialize the object.
+The only requirements of the trait is that it has (or can deduce) 2 static functions which take a bit_writer& and a bit_reader& respectively as their first argument.
+The 2 functions must also return a bool indicating whether the serialization was a success or not, but can otherwise take any number of additional arguments.
 The general structure of a trait looks like the following:
 
 ```cpp
 template<>
-struct serialize_traits<TRAIT_TYPE> // The type to use when serializing
+struct serialize_traits<TRAIT_TYPE> // The type to use when referencing this specific trait
 {
     // Will be called when writing the object to a stream
     static bool serialize(bit_writer& stream, ...)

include/bitstream/stream/bit_reader.h

@@ -2,6 +2,7 @@
 #include "../utility/assert.h"
 #include "../utility/crc.h"
 #include "../utility/endian.h"
+#include "../utility/meta.h"
 
 #include "byte_buffer.h"
 #include "serialize_traits.h"
@@ -39,7 +40,7 @@ namespace bitstream
 		 * @param bytes The byte array to read from. Should be 4-byte aligned if possible. The size of the array must be a multiple of 4
 		 * @param num_bytes The maximum number of bytes that we can read
 		*/
-		bit_reader(const void* bytes, uint32_t num_bytes) noexcept :
+		explicit bit_reader(const void* bytes, uint32_t num_bytes) noexcept :
 			m_Buffer(static_cast<const uint32_t*>(bytes)),
 			m_NumBitsRead(0),
 			m_TotalBits(num_bytes * 8),
@@ -309,18 +310,40 @@ namespace bitstream
 		}
 
 		/**
-		 * @brief Reads from the buffer, using the given `Trait`.
+		 * @brief Reads from the buffer, using the given @p Trait.
+		 * @note The Trait type in this function must always be explicitly declared
 		 * @tparam Trait A template specialization of serialize_trait<>
 		 * @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 Trait, typename... Args>
-		bool serialize(Args&&... args) noexcept(noexcept(serialize_traits<Trait>::serialize(*this, std::forward<Args>(args)...)))
+		bool serialize(Args&&... args) noexcept(utility::is_noexcept_serialize_v<Trait, bit_reader, Args...>)
 		{
+			static_assert(utility::has_serialize_v<Trait, bit_reader, Args...>, "Could not find serializable trait for the given type. Remember to specialize serializable_traits<> with the given type");
+
 			return serialize_traits<Trait>::serialize(*this, std::forward<Args>(args)...);
 		}
 
+		/**
+		 * @brief Reads from the buffer, by trying to deduce the trait.
+		 * @note The Trait type in this function is always implicit and will be deduced from the first argument if possible.
+		 * If the trait cannot be deduced it will not compile.
+		 * @tparam Trait A template specialization of serialize_trait<>
+		 * @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 Trait, typename... Args>
+		bool serialize(Trait&& arg, Args&&... args) noexcept(utility::is_noexcept_serialize_v<utility::deduce_trait_t<Trait, bit_reader, Args...>, bit_reader, Trait, Args...>)
+		{
+			using deduce_t = utility::deduce_trait_t<Trait, bit_reader, Args...>;
+
+			static_assert(utility::has_serialize_v<deduce_t, bit_reader, Trait, Args...>, "Could not deduce serializable trait for the given arguments. Remember to specialize serializable_traits<> with the given type");
+
+			return serialize_traits<deduce_t>::serialize(*this, std::forward<Trait>(arg), std::forward<Args>(args)...);
+		}
+
 	private:
 		const uint32_t* m_Buffer;
 		uint32_t m_NumBitsRead;

include/bitstream/stream/bit_writer.h

@@ -2,6 +2,7 @@
 #include "../utility/assert.h"
 #include "../utility/crc.h"
 #include "../utility/endian.h"
+#include "../utility/meta.h"
 
 #include "byte_buffer.h"
 #include "serialize_traits.h"
@@ -44,7 +45,7 @@ namespace bitstream
 		 * @param bytes The byte array to write to. Should be 4-byte aligned if possible
 		 * @param num_bytes The number of bytes in the array. Must be a multiple of 4
 		*/
-		bit_writer(void* bytes, uint32_t num_bytes) noexcept :
+		explicit bit_writer(void* bytes, uint32_t num_bytes) noexcept :
 			m_Buffer(static_cast<uint32_t*>(bytes)),
 			m_NumBitsWritten(0),
 			m_TotalBits(num_bytes * 8),
@@ -354,18 +355,40 @@ namespace bitstream
 		}
 
 		/**
-		 * @brief Writes to the buffer, using the given `Trait`.
+		 * @brief Writes to the buffer, using the given @p Trait.
+		 * @note The Trait type in this function must always be explicitly declared
 		 * @tparam Trait A template specialization of serialize_trait<>
 		 * @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 Trait, typename... Args>
-		bool serialize(Args&&... args) noexcept(noexcept(serialize_traits<Trait>::serialize(*this, std::forward<Args>(args)...)))
+		bool serialize(Args&&... args) noexcept(utility::is_noexcept_serialize_v<Trait, bit_writer, Args...>)
 		{
+			static_assert(utility::has_serialize_v<Trait, bit_writer, Args...>, "Could not find serializable trait for the given type. Remember to specialize serializable_traits<> with the given type");
+
 			return serialize_traits<Trait>::serialize(*this, std::forward<Args>(args)...);
 		}
 
+		/**
+		 * @brief Writes to the buffer, by trying to deduce the trait.
+		 * @note The Trait type in this function is always implicit and will be deduced from the first argument if possible.
+		 * If the trait cannot be deduced it will not compile.
+		 * @tparam ...Args The types of the arguments to pass to the serialize function
+		 * @tparam Trait A template specialization of serialize_trait<>
+		 * @param ...args The arguments to pass to the serialize function
+		 * @return Whether successful or not
+		*/
+		template<typename Trait, typename... Args>
+		bool serialize(Trait&& arg, Args&&... args) noexcept(utility::is_noexcept_serialize_v<utility::deduce_trait_t<Trait, bit_writer, Args...>, bit_writer, Trait, Args...>)
+		{
+			using deduce_t = utility::deduce_trait_t<Trait, bit_writer, Args...>;
+
+			static_assert(utility::has_serialize_v<deduce_t, bit_writer, Trait, Args...>, "Could not deduce serializable trait for the given arguments. Remember to specialize serializable_traits<> with the given type");
+
+			return serialize_traits<deduce_t>::serialize(*this, std::forward<Trait>(arg), std::forward<Args>(args)...);
+		}
+
 	private:
 		uint32_t* m_Buffer;
 		uint32_t m_NumBitsWritten;

include/bitstream/utility/meta.h

@@ -0,0 +1,86 @@
+#pragma once
+
+#include "../stream/serialize_traits.h"
+
+#include <type_traits>
+
+namespace bitstream::utility
+{
+	// Check if type has a serializable trait
+	template<typename Void, typename T, typename Stream, typename... Args>
+	struct has_serialize : std::false_type {};
+
+	template<typename T, typename Stream, typename... Args>
+	struct has_serialize<std::void_t<decltype(serialize_traits<T>::serialize(std::declval<Stream&>(), std::declval<Args>()...))>, T, Stream, Args...> : std::true_type {};
+
+	template<typename T, typename Stream, typename... Args>
+	constexpr bool has_serialize_v = has_serialize<void, T, Stream, Args...>::value;
+
+
+	// Check if type is noexcept, if it exists
+	template<typename Void, typename T, typename Stream, typename... Args>
+	struct is_noexcept_serialize : std::false_type {};
+
+	template<typename T, typename Stream, typename... Args>
+	struct is_noexcept_serialize<std::enable_if_t<has_serialize_v<T, Stream, Args...>>, T, Stream, Args...> :
+		std::bool_constant<noexcept(serialize_traits<T>::serialize(std::declval<Stream&>(), std::declval<Args>()...))> {};
+
+	template<typename T, typename Stream, typename... Args>
+	constexpr bool is_noexcept_serialize_v = is_noexcept_serialize<void, T, Stream, Args...>::value;
+
+
+	// Get the underlying type without &, &&, * or const
+	template<typename T>
+	using base_t = typename std::remove_const_t<std::remove_pointer_t<std::decay_t<T>>>;
+
+
+	// Meta functions for guessing the trait type from the first argument
+	template<typename Void, typename Trait, typename Stream, typename... Args>
+	struct deduce_trait
+	{
+		using type = void;
+	};
+
+	// Non-const value
+	template<typename Trait, typename Stream, typename... Args>
+	struct deduce_trait<std::enable_if_t<
+		!std::is_pointer_v<std::decay_t<Trait>>&&
+		has_serialize_v<base_t<Trait>, Stream, Trait, Args...>>,
+		Trait, Stream, Args...>
+	{
+		using type = base_t<Trait>;
+	};
+
+	// Const value
+	template<typename Trait, typename Stream, typename... Args>
+	struct deduce_trait<std::enable_if_t<
+		!std::is_pointer_v<std::decay_t<Trait>>&&
+		has_serialize_v<std::add_const_t<base_t<Trait>>, Stream, Trait, Args...>>,
+		Trait, Stream, Args...>
+	{
+		using type = std::add_const_t<base_t<Trait>>;
+	};
+
+	// Non-const pointer
+	template<typename Trait, typename Stream, typename... Args>
+	struct deduce_trait<std::enable_if_t<
+		std::is_pointer_v<std::decay_t<Trait>>&&
+		has_serialize_v<std::add_pointer_t<base_t<Trait>>, Stream, Trait, Args...>>,
+		Trait, Stream, Args...>
+	{
+		using type = std::add_pointer_t<base_t<Trait>>;
+	};
+
+	// Const pointer
+	template<typename Trait, typename Stream, typename... Args>
+	struct deduce_trait<std::enable_if_t<
+		std::is_pointer_v<std::decay_t<Trait>>&&
+		has_serialize_v<std::add_pointer_t<std::add_const_t<base_t<Trait>>>, Stream, Trait, Args...>>,
+		Trait, Stream, Args...>
+	{
+		using type = std::add_pointer_t<std::add_const_t<base_t<Trait>>>;
+	};
+
+	template<typename Trait, typename Stream, typename... Args>
+	using deduce_trait_t = typename deduce_trait<void, Trait, Stream, Args...>::type;
+}

src/test/serialize_deduction_test.cpp

@@ -0,0 +1,111 @@
+#include "../shared/assert.h"
+#include "../shared/test.h"
+
+#include <bitstream/stream/bit_reader.h>
+#include <bitstream/stream/bit_writer.h>
+#include <bitstream/utility/bits.h>
+
+#include <bitstream/traits/integral_traits.h>
+#include <bitstream/traits/quantization_traits.h>
+#include <bitstream/traits/string_traits.h>
+
+namespace bitstream::test::deduction
+{
+    BS_ADD_TEST(test_deduce_integrals)
+    {
+        // Create a writer, referencing the buffer and its size
+        byte_buffer<4> buffer;
+        bit_writer writer(buffer);
+
+        // Write the value
+        int32_t value = -45; // We can choose any value within the range below
+        BS_TEST_ASSERT(writer.serialize(value, -90, 40)); // A lower and upper bound which the value will be quantized between
+
+        // Flush the writer's remaining state into the buffer
+        uint32_t num_bytes = writer.flush();
+
+        BS_TEST_ASSERT_OPERATION(num_bytes, <= , 4);
+
+        // Create a reader by moving and invalidating the writer
+        bit_reader reader(buffer, num_bytes);
+
+        // Read the value back
+        int32_t out_value; // We don't have to initialize it yet
+        BS_TEST_ASSERT(reader.serialize(out_value, -90, 40)); // out_value should now have a value of -45
+
+        BS_TEST_ASSERT_OPERATION(out_value, == , value);
+    }
+
+    BS_ADD_TEST(test_deduce_chars)
+    {
+        // Create a writer, referencing the buffer and its size
+        byte_buffer<32> buffer;
+        bit_writer writer(buffer);
+
+        // Write the value
+        const char* value = "Hello world!";
+        BS_TEST_ASSERT(writer.serialize(value, 32U)); // The second argument is the maximum size we expect the string to be
+
+        // Flush the writer's remaining state into the buffer
+        uint32_t num_bytes = writer.flush();
+
+        // Create a reader by moving and invalidating the writer
+        bit_reader reader(buffer, num_bytes);
+
+        // Read the value back
+        char out_value[32]; // Set the size to the max size
+        BS_TEST_ASSERT(reader.serialize(out_value, 32U)); // out_value should now contain "Hello world!\0"
+
+        BS_TEST_ASSERT(strcmp(out_value, value) == 0);
+    }
+
+    BS_ADD_TEST(test_deduce_strings)
+    {
+        // Create a writer, referencing the buffer and its size
+        byte_buffer<32> buffer;
+        bit_writer writer(buffer);
+
+        // Write the value
+        std::string value = "Hello world!";
+        BS_TEST_ASSERT(writer.serialize(value, 32U)); // The second argument is the maximum size we expect the string to be
+
+        // Flush the writer's remaining state into the buffer
+        uint32_t num_bytes = writer.flush();
+
+        // Create a reader by moving and invalidating the writer
+        bit_reader reader(buffer, num_bytes);
+
+        // Read the value back
+        std::string out_value; // The string will be resized if the output doesn't fit
+        BS_TEST_ASSERT(reader.serialize(out_value, 32U)); // out_value should now contain "Hello world!"
+
+        BS_TEST_ASSERT_OPERATION(out_value, == , value);
+    }
+
+    BS_ADD_TEST(test_deduce_bounded_range)
+    {
+        // Create a writer, referencing the buffer and its size
+        byte_buffer<4> buffer;
+        bit_writer writer(buffer);
+
+        // Write the value
+        bounded_range range(1.0f, 4.0f, 1.0f / 128.0f); // Min, Max, Precision
+        float value = 1.2345678f;
+        writer.serialize(range, value);
+
+        // Flush the writer's remaining state into the buffer
+        uint32_t num_bytes = writer.flush();
+
+        BS_TEST_ASSERT_OPERATION(num_bytes, <= , 4);
+
+        // Create a reader by moving and invalidating the writer
+        bit_reader reader(buffer, num_bytes);
+
+        // Read the value back
+        float out_value;
+        reader.serialize(range, out_value); // out_value should now be a value close to 1.2345678f
+
+        BS_TEST_ASSERT_OPERATION(std::abs(value - out_value), <= , range.get_precision());
+        BS_TEST_ASSERT_OPERATION(range.get_bits_required(), < , 32);
+    }
+}