change(buffer): rename buffer.{c,h} to buffer.hpp

CMakeLists.txt

@@ -65,7 +65,6 @@ set(KERNEL_MAIN_SOURCES src/fs/fat.cpp
                         src/kernel/hw/timer.c
                         src/kernel/event/event.cpp
                         src/types/bitmap.c
-                        src/types/buffer.c
                         src/types/elf.cpp
                         include/asm/boot.h
                         include/asm/port_io.h
@@ -92,7 +91,7 @@ set(KERNEL_MAIN_SOURCES src/fs/fat.cpp
                         include/kernel/input/input_event.h
                         include/types/assert.h
                         include/types/bitmap.h
-                        include/types/buffer.h
+                        include/types/buffer.hpp
                         include/types/elf.hpp
                         include/types/hash_map.hpp
                         include/types/map.hpp

include/types/buffer.h

@@ -1,31 +0,0 @@
-#pragma once
-
-#include "stdint.h"
-
-#define MAKE_RING_BUFFER(BUF_PTR, SIZE)        \
-    {                                          \
-        .buf_start_pos = (BUF_PTR),            \
-        .buf_end_pos = ((BUF_PTR) + (SIZE)-1), \
-        .base = (BUF_PTR),                     \
-        .head = (BUF_PTR),                     \
-        .count = 0,                            \
-    }
-
-struct ring_buffer {
-    char* const buf_start_pos;
-    char* const buf_end_pos;
-    char* base;
-    char* head;
-    size_t count;
-};
-
-int32_t
-ring_buffer_empty(struct ring_buffer* buf);
-
-int32_t
-ring_buffer_full(struct ring_buffer* buf);
-
-char ring_buffer_read(struct ring_buffer* buf);
-
-int32_t
-ring_buffer_write(struct ring_buffer* buf, char c);

include/types/buffer.hpp

@@ -0,0 +1,108 @@
+#pragma once
+
+#include <types/allocator.hpp>
+#include <types/stdint.h>
+
+namespace types {
+
+template <template <typename> class Allocator>
+class buffer {
+public:
+    using allocator_type = Allocator<char>;
+
+private:
+    char* const start;
+    char* const end;
+    char* base;
+    char* head;
+    size_t count;
+
+private:
+    constexpr char _get_char(void)
+    {
+        --count;
+        return *base;
+    }
+
+    constexpr void _put_char(char c)
+    {
+        *head = c;
+        ++count;
+    }
+
+    constexpr void _forward(char*& ptr)
+    {
+        if (ptr == end)
+            ptr = start;
+        else
+            ++ptr;
+    }
+
+public:
+    constexpr buffer(size_t size)
+        : start { types::allocator_traits<allocator_type>::allocate(size) }
+        , end { start + size - 1 }
+        , base { start }
+        , head { start }
+        , count { 0 }
+    {
+    }
+
+    constexpr buffer(const buffer& buf)
+        : start { types::allocator_traits<allocator_type>::allocate(buf.end + 1 - buf.start) }
+        , end { start + buf.end - buf.start }
+        , base { start + buf.base - buf.start }
+        , head { start + buf.base - buf.start }
+        , count { buf.count }
+    {
+    }
+
+    constexpr buffer(buffer&& buf)
+        : start { buf.start }
+        , end { buf.end }
+        , base { buf.base }
+        , head { buf.head }
+        , count { buf.count }
+    {
+    }
+
+    constexpr ~buffer()
+    {
+        if (start)
+            types::allocator_traits<allocator_type>::deallocate(start);
+    }
+
+    constexpr bool empty(void) const
+    {
+        return count == 0;
+    }
+
+    constexpr bool full(void) const
+    {
+        return count == static_cast<size_t>(end - start + 1);
+    }
+
+    constexpr char get(void)
+    {
+        // TODO: set error flag
+        if (empty())
+            return 0xff;
+
+        char c = _get_char();
+        _forward(base);
+        return c;
+    }
+
+    constexpr char put(char c)
+    {
+        // TODO: set error flag
+        if (full())
+            return 0xff;
+
+        _put_char(c);
+        _forward(head);
+        return c;
+    }
+};
+
+} // namespace types

include/types/types.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "bitmap.h"
-#include "buffer.h"
 #include "size.h"
 #include "status.h"
 #include "stdint.h"

src/types/buffer.c

@@ -1,77 +0,0 @@
-#include <types/buffer.h>
-#include <types/stdint.h>
-
-int32_t
-ring_buffer_empty(struct ring_buffer* buf)
-{
-    return (buf->count == 0);
-}
-
-int32_t
-ring_buffer_full(struct ring_buffer* buf)
-{
-    return (buf->count == (size_t)(buf->buf_end_pos - buf->buf_start_pos + 1));
-}
-
-static inline void
-ring_buffer_move_base_ptr_forward(struct ring_buffer* buf)
-{
-    if (buf->base == buf->buf_end_pos) {
-        buf->base = buf->buf_start_pos;
-    } else {
-        ++buf->base;
-    }
-}
-
-static inline void
-ring_buffer_move_head_ptr_forward(struct ring_buffer* buf)
-{
-    if (buf->head == buf->buf_end_pos) {
-        buf->head = buf->buf_start_pos;
-    } else {
-        ++buf->head;
-    }
-}
-
-static inline char
-ring_buffer_get_data(struct ring_buffer* buf)
-{
-    --buf->count;
-    return *buf->base;
-}
-
-static inline void
-ring_buffer_put_data(struct ring_buffer* buf, char c)
-{
-    *buf->head = c;
-    ++buf->count;
-}
-
-char ring_buffer_read(struct ring_buffer* buf)
-{
-    if (ring_buffer_empty(buf)) {
-        // TODO: set error flag
-        return 0xff;
-    }
-
-    char c = ring_buffer_get_data(buf);
-
-    ring_buffer_move_base_ptr_forward(buf);
-
-    return c;
-}
-
-int32_t
-ring_buffer_write(struct ring_buffer* buf, char c)
-{
-    if (ring_buffer_full(buf)) {
-        // TODO: set error flag
-        return 1;
-    }
-
-    ring_buffer_put_data(buf, c);
-
-    ring_buffer_move_head_ptr_forward(buf);
-
-    return 0;
-}