Types.hh

#pragma once
 
#include <Logger.hh>
 
#include <egg/core/Heap.hh>
 
#include <cstdint>
#include <span>
#include <type_traits>
#include <utility>
 
namespace Kinoko {
 
typedef int8_t s8;
typedef int16_t s16;
typedef int32_t s32;
typedef int64_t s64;
 
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;
 
typedef float f32;
typedef double f64;

template <typename T>
class owning_span {
public:
    owning_span() : m_data(nullptr), m_size(0) {}

    owning_span(size_t count) : m_data(EGG::egg_new_array<T>(count)), m_size(count) {}

    owning_span(const std::span<const T> &span)
        : m_data(EGG::egg_new_array<T>(span.size())), m_size(span.size()) {
        std::copy(span.begin(), span.end(), m_data);
    }

    owning_span(const owning_span &rhs) : m_size(rhs.m_size) {
        m_data = EGG::egg_new_array<T>(m_size);
        std::copy(rhs.begin(), rhs.end(), m_data);
    }

    owning_span(owning_span &&rhs) {
        m_data = rhs.m_data;
        rhs.m_data = nullptr;
 
        m_size = rhs.m_size;
        rhs.m_size = 0;
    }

    owning_span &operator=(const owning_span &rhs) {
        if (this != &rhs) {
            EGG::egg_delete_array(m_data, m_size);
            m_size = rhs.m_size;
            m_data = EGG::egg_new_array<T>(m_size);
            std::copy(rhs.begin(), rhs.end(), m_data);
        }
 
        return *this;
    }

    owning_span &operator=(owning_span &&rhs) {
        if (this != &rhs) {
            EGG::egg_delete_array(m_data, m_size);
            m_data = rhs.m_data;
            rhs.m_data = nullptr;
            m_size = rhs.m_size;
            rhs.m_size = 0;
        }
 
        return *this;
    }

    ~owning_span() {
        EGG::egg_delete_array(m_data, m_size);
    }

    [[nodiscard]] T &operator[](size_t idx) {
        ASSERT(idx < m_size);
        return m_data[idx];
    }

    [[nodiscard]] const T &operator[](size_t idx) const {
        ASSERT(idx < m_size);
        return m_data[idx];
    }

    [[nodiscard]] T &front() {
        ASSERT(m_size > 0);
        return m_data[0];
    }

    [[nodiscard]] const T &front() const {
        ASSERT(m_size > 0);
        return m_data[0];
    }

    [[nodiscard]] T &back() {
        ASSERT(m_size > 0);
        return m_data[m_size - 1];
    }

    [[nodiscard]] const T &back() const {
        ASSERT(m_size > 0);
        return m_data[m_size - 1];
    }
 
    [[nodiscard]] T *begin() {
        return m_data;
    }
 
    [[nodiscard]] T *end() {
        return m_data + m_size;
    }
 
    [[nodiscard]] const T *begin() const {
        return m_data;
    }
 
    [[nodiscard]] const T *end() const {
        return m_data + m_size;
    }

    [[nodiscard]] bool empty() const {
        return m_size == 0;
    }

    [[nodiscard]] size_t size() const {
        return m_size;
    }

    [[nodiscard]] std::span<const T> view() const {
        return {m_data, m_size};
    }
 
private:
    T *m_data;     
    size_t m_size; 
};

template <typename T>
class fixed_vector {
public:
    fixed_vector() : m_data(nullptr), m_size(0), m_capacity(0) {}

    fixed_vector(size_t capacity) : fixed_vector() {
        allocate(capacity);
    }

    fixed_vector(const fixed_vector &rhs) : fixed_vector() {
        if (rhs.initialized()) {
            allocate(rhs.m_capacity);
            for (size_t i = 0; i < rhs.m_size; ++i) {
                push_back(rhs[i]);
            }
        }
    }

    fixed_vector(fixed_vector &&rhs)
        : m_data(rhs.m_data), m_size(rhs.m_size), m_capacity(rhs.m_capacity) {
        rhs.m_data = nullptr;
        rhs.m_size = 0;
        rhs.m_capacity = 0;
    }

    fixed_vector &operator=(const fixed_vector &rhs) {
        if (this != &rhs) {
            destroy();
            if (rhs.initialized()) {
                allocate(rhs.m_capacity);
                for (size_t i = 0; i < rhs.m_size; ++i) {
                    push_back(rhs[i]);
                }
            }
        }
 
        return *this;
    }

    fixed_vector &operator=(fixed_vector &&rhs) {
        if (this != &rhs) {
            destroy();
 
            m_data = rhs.m_data;
            m_size = rhs.m_size;
            m_capacity = rhs.m_capacity;
 
            rhs.m_data = nullptr;
            rhs.m_size = 0;
            rhs.m_capacity = 0;
        }
 
        return *this;
    }

    ~fixed_vector() {
        destroy();
    }

    T &push_back(const T &obj) {
        ASSERT(initialized() && !full());
        new (m_data + m_size++) T(obj);
        return back();
    }

    T &push_back(T &&obj) {
        ASSERT(initialized() && !full());
        new (m_data + m_size++) T(std::move(obj));
        return back();
    }

    template <typename... Args>
    T &emplace_back(Args &&...args) {
        ASSERT(initialized() && !full());
        new (m_data + m_size++) T(std::forward<Args>(args)...);
        return back();
    }

    void pop_back() {
        ASSERT(initialized() && !empty());
        m_data[--m_size].~T();
    }

    void reserve(size_t capacity) {
        ASSERT(!initialized());
        allocate(capacity);
    }

    [[nodiscard]] bool empty() const {
        return m_size == 0;
    }

    [[nodiscard]] bool full() const {
        return m_size == m_capacity;
    }

    [[nodiscard]] bool initialized() const {
        return m_data && m_capacity != 0;
    }

    [[nodiscard]] size_t size() const {
        return m_size;
    }

    [[nodiscard]] size_t capacity() const {
        return m_capacity;
    }

    T &front() {
        ASSERT(m_size > 0);
        return *m_data;
    }

    const T &front() const {
        ASSERT(m_size > 0);
        return *m_data;
    }

    T &back() {
        ASSERT(m_size > 0);
        return m_data[m_size - 1];
    }

    const T &back() const {
        ASSERT(m_size > 0);
        return m_data[m_size - 1];
    }

    T &operator[](size_t idx) {
        ASSERT(idx < m_size);
        return m_data[idx];
    }

    const T &operator[](size_t idx) const {
        ASSERT(idx < m_size);
        return m_data[idx];
    }

    T *begin() noexcept {
        ASSERT(initialized());
        return m_data;
    }

    const T *begin() const noexcept {
        ASSERT(initialized());
        return m_data;
    }

    T *end() noexcept {
        ASSERT(initialized());
        return m_data + m_size;
    }

    const T *end() const noexcept {
        ASSERT(initialized());
        return m_data + m_size;
    }
 
private:
    void destroy() {
        while (m_size > 0) {
            pop_back();
        }
 
        EGG::egg_free(m_data);
        m_data = nullptr;
        m_capacity = 0;
    }

    void allocate(size_t capacity) {
        ASSERT(!initialized());
        m_data = static_cast<T *>(
                EGG::egg_alloc(sizeof(T) * capacity, static_cast<s32>(alignof(T))));
        m_capacity = capacity;
    }
 
    T *m_data;         // The underlying array pointer.
    size_t m_size;     // The number of existing elements in the array.
    size_t m_capacity; // The maximum number of elements that can exist in the array.
};
 
} // namespace Kinoko