add byteutil library

src/coders/byte_utils.cpp

@@ -6,6 +6,10 @@
 
 #include "util/data_io.hpp"
 
+ByteBuilder::ByteBuilder(size_t size) {
+    buffer.reserve(size);
+}
+
 void ByteBuilder::put(ubyte b) {
     buffer.push_back(b);
 }
@@ -31,37 +35,37 @@ void ByteBuilder::put(const ubyte* arr, size_t size) {
     }
 }
 
-void ByteBuilder::putInt16(int16_t val) {
+void ByteBuilder::putInt16(int16_t val, bool bigEndian) {
     size_t size = buffer.size();
     buffer.resize(buffer.size() + sizeof(int16_t));
-    val = dataio::h2le(val);
+    val = bigEndian ? dataio::h2be(val) : dataio::h2le(val);
     std::memcpy(buffer.data()+size, &val, sizeof(int16_t));
 }
 
-void ByteBuilder::putInt32(int32_t val) {
+void ByteBuilder::putInt32(int32_t val, bool bigEndian) {
     size_t size = buffer.size();
     buffer.resize(buffer.size() + sizeof(int32_t));
-    val = dataio::h2le(val);
+    val = bigEndian ? dataio::h2be(val) : dataio::h2le(val);
     std::memcpy(buffer.data()+size, &val, sizeof(int32_t));
 }
 
-void ByteBuilder::putInt64(int64_t val) {
+void ByteBuilder::putInt64(int64_t val, bool bigEndian) {
     size_t size = buffer.size();
     buffer.resize(buffer.size() + sizeof(int64_t));
-    val = dataio::h2le(val);
+    val = bigEndian ? dataio::h2be(val) : dataio::h2le(val);
     std::memcpy(buffer.data()+size, &val, sizeof(int64_t));
 }
 
-void ByteBuilder::putFloat32(float val) {
+void ByteBuilder::putFloat32(float val, bool bigEndian) {
     int32_t i32_val;
     std::memcpy(&i32_val, &val, sizeof(int32_t));
-    putInt32(i32_val);
+    putInt32(i32_val, bigEndian);
 }
 
-void ByteBuilder::putFloat64(double val) {
+void ByteBuilder::putFloat64(double val, bool bigEndian) {
     int64_t i64_val;
     std::memcpy(&i64_val, &val, sizeof(int64_t));
-    putInt64(i64_val);
+    putInt64(i64_val, bigEndian);
 }
 
 void ByteBuilder::set(size_t position, ubyte val) {
@@ -95,6 +99,10 @@ ByteReader::ByteReader(const ubyte* data) : data(data), size(4), pos(0) {
     size = getInt32();
 }
 
+ByteReader::ByteReader(const std::vector<ubyte>& data)
+    : data(data.data()), size(data.size()), pos(0) {
+}
+
 void ByteReader::checkMagic(const char* data, size_t size) {
     if (pos + size >= this->size) {
         throw std::runtime_error("invalid magic number");
@@ -129,45 +137,51 @@ ubyte ByteReader::peek() {
     return data[pos];
 }
 
-int16_t ByteReader::getInt16() {
+int16_t ByteReader::getInt16(bool bigEndian) {
     if (pos + sizeof(int16_t) > size) {
         throw std::runtime_error("buffer underflow");
     }
     int16_t value;
     std::memcpy(&value, data + pos, sizeof(int16_t));
     pos += sizeof(int16_t);
-    return dataio::le2h(value);
+    return bigEndian ? dataio::be2h(value) : dataio::le2h(value);
 }
 
-int32_t ByteReader::getInt32() {
+int32_t ByteReader::getInt32(bool bigEndian) {
     if (pos + sizeof(int32_t) > size) {
         throw std::runtime_error("buffer underflow");
     }
     int32_t value;
     std::memcpy(&value, data + pos, sizeof(int32_t));
     pos += sizeof(int32_t);
-    return dataio::le2h(value);
+    return bigEndian ? dataio::be2h(value) : dataio::le2h(value);
 }
 
-int64_t ByteReader::getInt64() {
+int64_t ByteReader::getInt64(bool bigEndian) {
     if (pos + sizeof(int64_t) > size) {
         throw std::runtime_error("buffer underflow");
     }
     int64_t value;
     std::memcpy(&value, data + pos, sizeof(int64_t));
     pos += sizeof(int64_t);
-    return dataio::le2h(value);
+    return bigEndian ? dataio::be2h(value) : dataio::le2h(value);
 }
 
-float ByteReader::getFloat32() {
+float ByteReader::getFloat32(bool bigEndian) {
     int32_t i32_val = getInt32();
+    if (bigEndian) {
+        i32_val = dataio::be2h(i32_val);
+    }
     float val;
     std::memcpy(&val, &i32_val, sizeof(float));
     return val;
 }
 
-double ByteReader::getFloat64() {
+double ByteReader::getFloat64(bool bigEndian) {
     int64_t i64_val = getInt64();
+    if (bigEndian) {
+        i64_val = dataio::be2h(i64_val);
+    }
     double val;
     std::memcpy(&val, &i64_val, sizeof(double));
     return val;

src/coders/byte_utils.hpp

@@ -8,20 +8,23 @@
 class ByteBuilder {
     std::vector<ubyte> buffer;
 public:
+    ByteBuilder() = default;
+    ByteBuilder(size_t size);
+
     /// @brief Write one byte (8 bit unsigned integer)
     void put(ubyte b);
     /// @brief Write c-string (bytes array terminated with '\00')
     void putCStr(const char* str);
     /// @brief Write signed 16 bit little-endian integer
-    void putInt16(int16_t val);
+    void putInt16(int16_t val, bool bigEndian = false);
     /// @brief Write signed 32 bit integer
-    void putInt32(int32_t val);
+    void putInt32(int32_t val, bool bigEndian = false);
     /// @brief Write signed 64 bit integer
-    void putInt64(int64_t val);
+    void putInt64(int64_t val, bool bigEndian = false);
     /// @brief Write 32 bit floating-point number
-    void putFloat32(float val);
+    void putFloat32(float val, bool bigEndian = false);
     /// @brief Write 64 bit floating-point number
-    void putFloat64(double val);
+    void putFloat64(double val, bool bigEndian = false);
 
     /// @brief Write string (uint32 length + bytes)
     void put(const std::string& s);
@@ -50,6 +53,7 @@ class ByteReader {
 public:
     ByteReader(const ubyte* data, size_t size);
     ByteReader(const ubyte* data);
+    ByteReader(const std::vector<ubyte>& data);
 
     void checkMagic(const char* data, size_t size);
     /// @brief Get N bytes
@@ -59,15 +63,15 @@ public:
     /// @brief Read one byte (unsigned 8 bit integer) without pointer move
     ubyte peek();
     /// @brief Read signed 16 bit little-endian integer
-    int16_t getInt16();
+    int16_t getInt16(bool bigEndian = false);
     /// @brief Read signed 32 bit little-endian integer
-    int32_t getInt32();
+    int32_t getInt32(bool bigEndian = false);
     /// @brief Read signed 64 bit little-endian integer
-    int64_t getInt64();
+    int64_t getInt64(bool bigEndian = false);
     /// @brief Read 32 bit floating-point number
-    float getFloat32();
+    float getFloat32(bool bigEndian = false);
     /// @brief Read 64 bit floating-point number
-    double getFloat64();
+    double getFloat64(bool bigEndian = false);
     /// @brief Read C-String
     const char* getCString();
     /// @brief Read string with unsigned 32 bit number before (length)