Add serialize_traits for enum types

Update integral trait to not allow const types
Update extension example in README

Author: KredeGC

README.md

@@ -386,12 +386,14 @@ struct serialize_traits<TRAIT_TYPE> // The type to use when serializing
 The specialization can also be templated to work with a number of types.
 It also works with `enable_if`:
 ```cpp
-// This trait will be used by any integral pointer type (char*, uint16_t* etc.)
+// This trait will be used by any non-const integral pointer type (char*, uint16_t* etc.)
 template<typename T>
-struct serialize_traits<T*, typename std::enable_if_t<std::is_integral_v<T>>>
+struct serialize_traits<T*, typename std::enable_if_t<std::is_integral_v<T> && !std::is_const_v<T>>>
 { ... };
-// An example which would use the above trait
+// An example which will use the above trait
 bool status = writer.serialize<int16_t*>(...);
+// An example which won't use it (and won't compile)
+bool status = writer.serialize<const int16_t*>(...);
 ```
 
 More concrete examples of traits can be found in the [`traits/`](https://github.com/KredeGC/BitStream/tree/master/include/bitstream/traits/) directory.

include/bitstream/bitstream.h

@@ -14,6 +14,7 @@
 // Traits
 #include "traits/array_traits.h"
 #include "traits/bool_trait.h"
+#include "traits/enum_trait.h"
 #include "traits/integral_traits.h"
 #include "traits/quantization_traits.h"
 #include "traits/string_traits.h"

include/bitstream/traits/enum_trait.h

@@ -0,0 +1,38 @@
+#pragma once
+#include "../utility/assert.h"
+
+#include "../stream/serialize_traits.h"
+#include "../stream/bit_reader.h"
+#include "../stream/bit_writer.h"
+
+#include "../traits/integral_traits.h"
+
+namespace bitstream
+{
+	/**
+	 * @brief A trait used to serialize an enum type
+	*/
+	template<typename T>
+	struct serialize_traits<T, typename std::enable_if_t<std::is_enum_v<T>>>
+	{
+        using value_type = std::underlying_type_t<T>;
+        
+		static bool serialize(bit_writer& writer, T value, value_type min = 0, value_type max = (std::numeric_limits<value_type>::max)()) noexcept
+		{
+			value_type unsigned_value = static_cast<value_type>(value);
+
+			return writer.serialize<value_type>(unsigned_value, min, max);
+		}
+
+		static bool serialize(bit_reader& reader, T& value, value_type min = 0, value_type max = (std::numeric_limits<value_type>::max)()) noexcept
+		{
+			value_type unsigned_value;
+
+			BS_ASSERT(reader.serialize<value_type>(unsigned_value, min, max));
+
+			value = static_cast<T>(unsigned_value);
+
+			return true;
+		}
+	};
+}

include/bitstream/traits/integral_traits.h

@@ -25,7 +25,7 @@ namespace bitstream
 	 * @tparam T A type matching an integer value
 	*/
 	template<typename T>
-	struct serialize_traits<T, typename std::enable_if_t<std::is_integral_v<T>>>
+	struct serialize_traits<T, typename std::enable_if_t<std::is_integral_v<T> && !std::is_const_v<T>>>
 	{
 		/**
 		 * @brief Writes an integer into the @p writer
@@ -126,7 +126,7 @@ namespace bitstream
 	 * @tparam Max The upper bound. Inclusive
 	*/
 	template<typename T, T Min, T Max>
-	struct serialize_traits<bounded_int<T, Min, Max>, typename std::enable_if_t<std::is_integral_v<T>>>
+	struct serialize_traits<bounded_int<T, Min, Max>, typename std::enable_if_t<std::is_integral_v<T> && !std::is_const_v<T>>>
 	{
 		/**
 		 * @brief Writes an integer into the @p writer

src/shared/test_types.h

@@ -19,4 +19,11 @@ namespace bitstream::test
             return values[index];
 		}
 	};
+    
+    enum class test_enum
+    {
+        FirstValue = 3,
+        SecondValue = 1,
+        ThirdValue
+    };
 }

src/test/serialize_enum_test.cpp

@@ -0,0 +1,34 @@
+#include "../shared/assert.h"
+#include "../shared/test.h"
+#include "../shared/test_types.h"
+
+#include <bitstream/stream/bit_reader.h>
+#include <bitstream/stream/bit_writer.h>
+
+#include <bitstream/traits/enum_trait.h>
+
+namespace bitstream::test::traits
+{
+	BS_ADD_TEST(test_serialize_enum_aligned)
+	{
+		// Test enums
+		test_enum value = test_enum::SecondValue;
+
+		// Write a char array, but make sure the word count isn't whole
+		byte_buffer<4> buffer;
+		bit_writer writer(buffer);
+        
+		BS_TEST_ASSERT(writer.serialize<test_enum>(value, 1, 3));
+		uint32_t num_bytes = writer.flush();
+
+		BS_TEST_ASSERT_OPERATION(num_bytes, == , 1);
+
+		// Read the enum back and validate
+		test_enum out_value;
+		bit_reader reader(buffer, num_bytes);
+
+		BS_TEST_ASSERT(reader.serialize<test_enum>(out_value, 1, 3));
+
+		BS_TEST_ASSERT_OPERATION(out_value, == , value);
+	}
+}