Add byte_buffer

Author: KredeGC

.github/workflows/main.yml

@@ -48,7 +48,7 @@ jobs:
       if: matrix.machine.os == 'windows-latest' && matrix.machine.toolset == 'msc'
       uses: microsoft/[email protected]
     - name: Install 32-bit gcc libs
-      if: matrix.machine.os == 'ubuntu-latest'
+      if: matrix.architecture == 'x86' && matrix.machine.os == 'ubuntu-latest'
       run: sudo apt-get install gcc-multilib g++-multilib
     - name: Run premake
       run: premake5 ${{ matrix.machine.action }} --toolset=${{ matrix.machine.toolset }} --dialect=${{ matrix.dialect }}

include/bitstream/bitstream.h

@@ -8,6 +8,7 @@
 // Stream
 #include "stream/bit_reader.h"
 #include "stream/bit_writer.h"
+#include "stream/byte_buffer.h"
 #include "stream/serialize_traits.h"
 
 // Traits

include/bitstream/stream/bit_reader.h

@@ -3,7 +3,7 @@
 #include "../utility/crc.h"
 #include "../utility/endian.h"
 
-#include "bit_writer.h"
+#include "byte_buffer.h"
 #include "serialize_traits.h"
 
 #include <cstdint>
@@ -22,6 +22,9 @@ namespace bitstream
 		static constexpr bool writing = false;
 		static constexpr bool reading = true;
 
+		/**
+		 * @brief Default construct a reader pointing to a null buffer
+		*/
 		bit_reader() noexcept :
 			m_Buffer(nullptr),
 			m_NumBitsRead(0),
@@ -30,29 +33,32 @@ namespace bitstream
 			m_ScratchBits(0),
 			m_WordIndex(0) {}
 
+		/**
+		 * @brief Construct a reader pointing to the given byte array with @p num_bytes size
+		 * @param bytes The byte array to read from
+		 * @param num_bytes The maximum number of bytes that we can read
+		*/
 		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),
 			m_Scratch(0),
 			m_ScratchBits(0),
 			m_WordIndex(0) {}
-        
-		explicit bit_reader(bit_writer&& other) noexcept :
-            m_Buffer(other.m_Buffer),
-            m_NumBitsRead(0),
-            m_TotalBits(other.m_NumBitsWritten),
-            m_Scratch(0),
-            m_ScratchBits(0),
-            m_WordIndex(0)
-        {
-            other.m_Buffer = nullptr;
-            other.m_NumBitsWritten = 0;
-            other.m_TotalBits = 0;
-            other.m_Scratch = 0;
-            other.m_ScratchBits = 0;
-            other.m_WordIndex = 0;
-        }
+
+		/**
+		 * @brief Construct a reader pointing to the given @p buffer
+		 * @param buffer The buffer to read from
+		 * @param num_bytes The maximum number of bytes that we can read
+		*/
+		template<size_t Size>
+		explicit bit_reader(byte_buffer<Size>& buffer, uint32_t num_bytes) noexcept :
+			m_Buffer(reinterpret_cast<uint32_t*>(buffer.Bytes)),
+			m_NumBitsRead(0),
+			m_TotalBits(num_bytes * 8),
+			m_Scratch(0),
+			m_ScratchBits(0),
+			m_WordIndex(0) {}
 
 		bit_reader(const bit_reader&) = delete;
 

include/bitstream/stream/bit_writer.h

@@ -3,6 +3,7 @@
 #include "../utility/crc.h"
 #include "../utility/endian.h"
 
+#include "byte_buffer.h"
 #include "serialize_traits.h"
 
 #include <cstdint>
@@ -26,6 +27,9 @@ namespace bitstream
 		static constexpr bool writing = true;
 		static constexpr bool reading = false;
 
+		/**
+		 * @brief Default construct a writer pointing to a null buffer
+		*/
 		bit_writer() noexcept :
 			m_Buffer(nullptr),
 			m_NumBitsWritten(0),
@@ -34,6 +38,11 @@ namespace bitstream
 			m_ScratchBits(0),
 			m_WordIndex(0) {}
 
+		/**
+		 * @brief Construct a writer pointing to the given byte array with @p num_bytes size
+		 * @param bytes The byte array to write to
+		 * @param num_bytes The number of bytes in the array
+		*/
 		bit_writer(void* bytes, uint32_t num_bytes) noexcept :
 			m_Buffer(static_cast<uint32_t*>(bytes)),
 			m_NumBitsWritten(0),
@@ -48,6 +57,19 @@ namespace bitstream
 #endif
 		}
 
+		/**
+		 * @brief Construct a writer pointing to the given @p buffer
+		 * @param buffer The buffer to write to
+		*/
+		template<size_t Size>
+		explicit bit_writer(byte_buffer<Size>& buffer) noexcept :
+			m_Buffer(reinterpret_cast<uint32_t*>(buffer.Bytes)),
+			m_NumBitsWritten(0),
+			m_TotalBits(Size * 8),
+			m_Scratch(0),
+			m_ScratchBits(0),
+			m_WordIndex(0) {}
+
 		bit_writer(const bit_writer&) = delete;
 
 		bit_writer(bit_writer&& other) noexcept :
@@ -66,6 +88,25 @@ namespace bitstream
             other.m_WordIndex = 0;
         }
 
+		bit_writer& operator=(const bit_writer&) = delete;
+
+		bit_writer& operator=(bit_writer&& rhs) noexcept
+		{
+			m_Buffer = rhs.m_Buffer;
+			m_NumBitsWritten = rhs.m_NumBitsWritten;
+			m_TotalBits = rhs.m_TotalBits;
+			m_Scratch = rhs.m_Scratch;
+			m_ScratchBits = rhs.m_ScratchBits;
+			m_WordIndex = rhs.m_WordIndex;
+
+			rhs.m_Buffer = nullptr;
+			rhs.m_NumBitsWritten = 0;
+			rhs.m_TotalBits = 0;
+			rhs.m_Scratch = 0;
+			rhs.m_ScratchBits = 0;
+			rhs.m_WordIndex = 0;
+		}
+
 		/**
 		 * @brief Returns the buffer that this writer is currently serializing into
 		 * @return The buffer

include/bitstream/stream/byte_buffer.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <cstdint>
+
+namespace bitstream
+{
+	/**
+	 * @brief A byte buffer aligned to 4 bytes
+	 * @note Can be used with bit_reader and bit_writer
+	*/
+	template<size_t Size>
+	struct byte_buffer
+	{
+		static_assert(Size % 4 == 0, "Buffer size must be a multiple of 4");
+
+		alignas(uint32_t) uint8_t Bytes[Size];
+	};
+}

src/test/stream_test.cpp

@@ -14,8 +14,8 @@ namespace bitstream::test::stream
 		uint32_t in_value2 = 99;
 
 		// Write some values with too many bits
-		uint8_t buffer[4]{ 0 };
-		bit_writer writer(buffer, 4);
+		byte_buffer<4> buffer;
+		bit_writer writer(buffer);
 
 		BS_TEST_ASSERT(writer.serialize_bits(in_value1, 11));
 		BS_TEST_ASSERT(writer.serialize_bits(in_value2, 11));
@@ -27,7 +27,7 @@ namespace bitstream::test::stream
 		// Read the values back and validate
 		uint32_t out_value1;
 		uint32_t out_value2;
-		bit_reader reader(std::move(writer));
+		bit_reader reader(buffer, num_bytes);
 
 		BS_TEST_ASSERT(reader.serialize_bits(out_value1, 11));
 		BS_TEST_ASSERT(reader.serialize_bits(out_value2, 11));
@@ -48,8 +48,8 @@ namespace bitstream::test::stream
 		constexpr uint32_t bits_required = utility::bits_to_represent(1111);
 
 		// Write some values with a few bits
-		uint8_t buffer[8]{ 0 };
-		bit_writer writer(buffer, 8);
+		byte_buffer<8> buffer;
+		bit_writer writer(buffer);
 
 		BS_TEST_ASSERT(writer.serialize_bits(in_value1, bits_required));
 		BS_TEST_ASSERT(writer.serialize_bits(in_value2, bits_required));
@@ -62,7 +62,7 @@ namespace bitstream::test::stream
 		uint32_t out_value1;
 		uint32_t out_value2;
 		uint32_t out_value3;
-		bit_reader reader(std::move(writer));
+		bit_reader reader(buffer, num_bytes);
 
 		BS_TEST_ASSERT(reader.serialize_bits(out_value1, bits_required));
 		BS_TEST_ASSERT(reader.serialize_bits(out_value2, bits_required));
@@ -80,16 +80,16 @@ namespace bitstream::test::stream
 		uint32_t value = 3;
 
 		// Write some initial values and finish with a checksum
-		uint8_t buffer[16]{ 0 };
-		bit_writer writer(buffer, 16);
+		byte_buffer<16> buffer;
+		bit_writer writer(buffer);
 
 		writer.prepend_checksum();
 		BS_TEST_ASSERT(writer.serialize_bits(value, 2));
 		uint16_t num_bytes = writer.serialize_checksum(protocol_version);
 
 		// Read the checksum and validate
 		uint32_t out_value;
-		bit_reader reader(std::move(writer));
+		bit_reader reader(buffer, num_bytes);
 
 		BS_TEST_ASSERT(reader.serialize_checksum(protocol_version));
 		BS_TEST_ASSERT(reader.serialize_bits(out_value, 2));
@@ -305,8 +305,8 @@ namespace bitstream::test::stream
 		uint32_t nested_value = 511;
 
 		// Write some initial value with a bit offset
-		uint8_t buffer[8]{ 0 };
-		bit_writer writer(buffer, 8);
+		byte_buffer<8> buffer;
+		bit_writer writer(buffer);
 
 		BS_TEST_ASSERT(writer.serialize_bits(value, 2));
 		BS_TEST_ASSERT(writer.serialize_bits(value, 3));