Added support for c-style array (#7)

* Added support for c-style array

* updated header files to .hpp

* updated clang-format

.clang-format

@@ -7,9 +7,11 @@ BinPackArguments: false
 BinPackParameters: false
 BreakConstructorInitializers: BeforeComma
 ConstructorInitializerAllOnOneLineOrOnePerLine: false
-ColumnLimit: 120
-IndentWidth: '4'
-IndentPPDirectives: AfterHash
+ColumnLimit: 80
+IndentWidth: 4
+TabWidth: 4
+UseTab: Never
+IndentPPDirectives: None
 IndentCaseLabels: false
 IncludeBlocks: Regroup
 IncludeCategories:
@@ -19,6 +21,4 @@ IncludeCategories:
     Priority:     1
   - Regex:        '".*"'
     Priority:     3
-Language: Cpp
-TabWidth: '4'
-UseTab: ForIndentation
+Language: Cpp

dubu_serialize/CMakeLists.txt

@@ -1,16 +1,16 @@
 set(target_name "dubu_serialize")
 
 set(src_buffer
-    "src/dubu_serialize/buffer/Buffer.h"
-    "src/dubu_serialize/buffer/FileBuffer.h"
-    "src/dubu_serialize/buffer/MemoryBuffer.h")
+    "src/dubu_serialize/buffer/Buffer.hpp"
+    "src/dubu_serialize/buffer/FileBuffer.hpp"
+    "src/dubu_serialize/buffer/MemoryBuffer.hpp")
 
 set(src_serializer
-    "src/dubu_serialize/serializer/Endian.h"
-    "src/dubu_serialize/serializer/Serializer.h")
+    "src/dubu_serialize/serializer/Endian.hpp"
+    "src/dubu_serialize/serializer/Serializer.hpp")
 
 set(src_serialize
-    "src/dubu_serialize/dubu_serialize.h"
+    "src/dubu_serialize/dubu_serialize.hpp"
     "src/dummy.cpp")
 
 set(src_files

dubu_serialize/src/dubu_serialize/buffer/Buffer.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <cstdint>
+
+namespace dubu::serialize {
+
+class ReadBuffer {
+public:
+    virtual ~ReadBuffer()                            = default;
+    virtual void Read(char* data, uint32_t numBytes) = 0;
+};
+
+class WriteBuffer {
+public:
+    virtual ~WriteBuffer()                                  = default;
+    virtual void Write(const char* data, uint32_t numBytes) = 0;
+};
+
+}  // namespace dubu::serialize

dubu_serialize/src/dubu_serialize/buffer/FileBuffer.hpp

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <filesystem>
+#include <fstream>
+
+#include "Buffer.hpp"
+
+namespace dubu::serialize {
+
+class FileBuffer : public ReadBuffer, public WriteBuffer {
+public:
+    enum class Mode { Read, Write };
+
+public:
+    FileBuffer(std::filesystem::path filePath, Mode mode)
+        : mMode(mode) {
+        if (mMode == Mode::Read) {
+            mStream.open(filePath, std::ios::in | std::ios::binary);
+        } else {
+            mStream.open(filePath, std::ios::out | std::ios::binary);
+        }
+    }
+    ~FileBuffer() { mStream.close(); }
+
+    template <typename T>
+    T Tell() {
+        if (mMode == Mode::Read) {
+            return static_cast<T>(mStream.tellg());
+        } else {
+            return static_cast<T>(mStream.tellp());
+        }
+    }
+
+    template <typename T>
+    void Seek(T position) {
+        if (mMode == Mode::Read) {
+            mStream.seekg(static_cast<std::streampos>(position));
+        } else {
+            mStream.seekp(static_cast<std::streampos>(position));
+        }
+    }
+
+    void Read(char* data, uint32_t size) override {
+        mStream.read(data, static_cast<std::streamsize>(size));
+    }
+    void Write(const char* data, uint32_t size) override {
+        mStream.write(data, static_cast<std::streamsize>(size));
+    }
+
+    template <typename T>
+    void Write(const std::basic_istream<T>& stream) {
+        mStream << stream.rdbuf();
+    }
+
+private:
+    std::fstream mStream;
+    Mode         mMode = Mode::Read;
+};
+
+}  // namespace dubu::serialize

dubu_serialize/src/dubu_serialize/buffer/MemoryBuffer.hpp

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <sstream>
+
+#include "Buffer.hpp"
+
+namespace dubu::serialize {
+
+class MemoryBuffer : public ReadBuffer, public WriteBuffer {
+public:
+    MemoryBuffer() {}
+
+    /**
+     * Get the position of the write pointer in the stream.
+     * @return The position of the write pointer.
+     */
+    template <typename T>
+    T TellP() {
+        return static_cast<T>(mStream.tellp());
+    }
+    /**
+     * Get the position of the read pointer in the stream.
+     * @return The position of the read pointer.
+     */
+    template <typename T>
+    T TellG() {
+        return static_cast<T>(mStream.tellg());
+    }
+
+    /**
+     * Set the position of the write pointer in the stream.
+     * @param position The desired position for the write pointer.
+     */
+    template <typename T>
+    void SeekP(T position) {
+        mStream.seekp(static_cast<std::streampos>(position));
+    }
+    /**
+     * Set the position of the read pointer in the stream.
+     * @param position The desired position for the read pointer.
+     */
+    template <typename T>
+    void SeekG(T position) {
+        mStream.seekg(static_cast<std::streampos>(position));
+    }
+
+    void Read(char* data, uint32_t size) override {
+        mStream.read(data, static_cast<std::streamsize>(size));
+    }
+    void Write(const char* data, uint32_t size) override {
+        mStream.write(data, static_cast<std::streamsize>(size));
+    }
+
+private:
+    std::stringstream mStream;
+};
+
+}  // namespace dubu::serialize

dubu_serialize/src/dubu_serialize/dubu_serialize.hpp

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "dubu_serialize/buffer/FileBuffer.hpp"
+#include "dubu_serialize/buffer/MemoryBuffer.hpp"
+#include "dubu_serialize/serializer/Serializer.hpp"