Types.hh

#pragma once
 
#include <Logger.hh>
 
#include <egg/core/Heap.hh>
 
#include <cstdint>
#include <span>
#include <type_traits>
 
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; 
};
 
} // namespace Kinoko