BLT/include/blt/std/memory.h

/*
 * Created by Brett on 08/02/23.
 * Licensed under GNU General Public License V3.0
 * See LICENSE file for license detail
 */

#ifndef BLT_TESTS_MEMORY_H
#define BLT_TESTS_MEMORY_H

#include <blt/std/memory_util.h>
#include <initializer_list>
#include <iterator>
#include <cstring>
#include "queue.h"
#include "utility.h"
#include <blt/std/assert.h>
#include <cstdint>
#include <type_traits>
#include <utility>
#include <cstring>

namespace blt
{
    
    template<typename V>
    struct ptr_iterator
    {
        public:
            using iterator_category = std::random_access_iterator_tag;
            using difference_type = std::ptrdiff_t;
            using value_type = V;
            using pointer = value_type*;
            using reference = value_type&;
            
            explicit ptr_iterator(V* v): _v(v)
            {}
            
            reference operator*() const
            { return *_v; }
            
            pointer operator->()
            { return _v; }
            
            ptr_iterator& operator++()
            {
                _v++;
                return *this;
            }
            
            ptr_iterator& operator--()
            {
                _v--;
                return *this;
            }
            
            ptr_iterator operator++(int)
            {
                auto tmp = *this;
                ++(*this);
                return tmp;
            }
            
            ptr_iterator operator--(int)
            {
                auto tmp = *this;
                --(*this);
                return tmp;
            }
            
            friend bool operator==(const ptr_iterator& a, const ptr_iterator& b)
            {
                return a._v == b._v;
            }
            
            friend bool operator!=(const ptr_iterator& a, const ptr_iterator& b)
            {
                return a._v != b._v;
            }
        
        private:
            V* _v;
    };

/**
     * Creates an encapsulation of a T array which will be automatically deleted when this object goes out of scope.
     * This is a simple buffer meant to be used only inside of a function and not copied around.
     * The internal buffer is allocated on the heap.
     * The operator * has been overloaded to return the internal buffer.
     * @tparam T type that is stored in buffer eg char
     */
    template<typename T, bool = std::is_copy_constructible_v<T> || std::is_copy_assignable_v<T>>
    class scoped_buffer
    {
        public:
            using element_type = T;
            using value_type = std::remove_cv_t<T>;
            using pointer = T*;
            using const_pointer = const T*;
            using reference = T&;
            using const_reference = const T&;
            using iterator = ptr_iterator<T>;
            using const_iterator = ptr_iterator<const T>;
            using reverse_iterator = std::reverse_iterator<iterator>;
            using const_reverse_iterator = std::reverse_iterator<const_iterator>;
        private:
            T* buffer_ = nullptr;
            size_t size_;
        public:
            constexpr scoped_buffer(): buffer_(nullptr), size_(0)
            {}
            
            constexpr explicit scoped_buffer(size_t size): size_(size)
            {
                if (size > 0)
                    buffer_ = new T[size];
                else
                    buffer_ = nullptr;
            }
            
            constexpr scoped_buffer(const scoped_buffer& copy)
            {
                if (copy.size() == 0)
                {
                    buffer_ = nullptr;
                    size_ = 0;
                    return;
                }
                buffer_ = new T[copy.size()];
                size_ = copy.size_;
                
                if constexpr (std::is_trivially_copyable_v<T>)
                {
                    std::memcpy(buffer_, copy.buffer_, copy.size() * sizeof(T));
                } else
                {
                    if constexpr (std::is_copy_constructible_v<T> && !std::is_copy_assignable_v<T>)
                    {
                        for (size_t i = 0; i < this->size_; i++)
                            buffer_[i] = T(copy[i]);
                    } else
                        for (size_t i = 0; i < this->size_; i++)
                            buffer_[i] = copy[i];
                }
            }
            
            constexpr scoped_buffer& operator=(const scoped_buffer& copy)
            {
                if (&copy == this)
                    return *this;
                
                if (copy.size() == 0)
                {
                    buffer_ = nullptr;
                    size_ = 0;
                    return *this;
                }
                
                delete[] this->buffer_;
                buffer_ = new T[copy.size()];
                size_ = copy.size_;
                
                if constexpr (std::is_trivially_copyable_v<T>)
                {
                    std::memcpy(buffer_, copy.buffer_, copy.size() * sizeof(T));
                } else
                {
                    if constexpr (std::is_copy_constructible_v<T> && !std::is_copy_assignable_v<T>)
                    {
                        for (size_t i = 0; i < this->size_; i++)
                            buffer_[i] = T(copy[i]);
                    } else
                        for (size_t i = 0; i < this->size_; i++)
                            buffer_[i] = copy[i];
                }
                return *this;
            }
            
            constexpr scoped_buffer(scoped_buffer&& move) noexcept
            {
                delete[] buffer_;
                buffer_ = move.buffer_;
                size_ = move.size();
                move.buffer_ = nullptr;
            }
            
            constexpr scoped_buffer& operator=(scoped_buffer&& moveAssignment) noexcept
            {
                delete[] buffer_;
                buffer_ = moveAssignment.buffer_;
                size_ = moveAssignment.size();
                moveAssignment.buffer_ = nullptr;
                
                return *this;
            }
            
            constexpr inline T& operator[](size_t index)
            {
                return buffer_[index];
            }
            
            constexpr inline const T& operator[](size_t index) const
            {
                return buffer_[index];
            }
            
            constexpr inline T* operator*()
            {
                return buffer_;
            }
            
            [[nodiscard]] constexpr inline size_t size() const
            {
                return size_;
            }
            
            constexpr inline T*& ptr()
            {
                return buffer_;
            }
            
            constexpr inline const T* const& ptr() const
            {
                return buffer_;
            }
            
            constexpr inline const T* const& data() const
            {
                return buffer_;
            }
            
            constexpr inline T*& data()
            {
                return buffer_;
            }
            
//            inline auto begin()
//            {
//                return ptr_iterator{buffer_};
//            }
//
//            inline ptr_iterator<T> end()
//            {
//                return ptr_iterator{&buffer_[size_]};
//            }
            
            constexpr iterator begin() noexcept
            {
                return iterator{data()};
            }
            
            constexpr iterator end() noexcept
            {
                return iterator{data() + size()};
            }
            
            constexpr const_iterator cbegin() const noexcept
            {
                return const_iterator{data()};
            }
            
            constexpr const_iterator cend() const noexcept
            {
                return const_iterator{data() + size()};
            }
            
            constexpr reverse_iterator rbegin() noexcept
            {
                return reverse_iterator{end()};
            }
            
            constexpr reverse_iterator rend() noexcept
            {
                return reverse_iterator{begin()};
            }
            
            constexpr const_reverse_iterator crbegin() const noexcept
            {
                return reverse_iterator{cend()};
            }
            
            constexpr const_reverse_iterator crend() const noexcept
            {
                return reverse_iterator{cbegin()};
            }

            ~scoped_buffer()
            {
                delete[] buffer_;
            }
    };
    
    template<typename T, size_t MAX_SIZE>
    class static_vector
    {
        private:
            T buffer_[MAX_SIZE];
            size_t size_ = 0;
        public:
            static_vector() = default;
            
            inline bool push_back(const T& copy)
            {
                if (size_ >= MAX_SIZE)
                    return false;
                buffer_[size_++] = copy;
                return true;
            }
            
            inline bool push_back(T&& move)
            {
                if (size_ >= MAX_SIZE)
                    return false;
                buffer_[size_++] = std::move(move);
                return true;
            }
            
            inline T& at(size_t index)
            {
                if (index >= MAX_SIZE)
                    throw std::runtime_error("Array index " + std::to_string(index) + " out of bounds! (Max size: " + std::to_string(MAX_SIZE) + ')');
            }
            
            inline T& operator[](size_t index)
            {
                return buffer_[index];
            }
            
            inline const T& operator[](size_t index) const
            {
                return buffer_[index];
            }
            
            inline void reserve(size_t size)
            {
                if (size > MAX_SIZE)
                    size = MAX_SIZE;
                size_ = size;
            }
            
            [[nodiscard]] inline size_t size() const
            {
                return size_;
            }
            
            [[nodiscard]] inline size_t capacity() const
            {
                return MAX_SIZE;
            }
            
            inline T* data()
            {
                return buffer_;
            }
            
            inline T* operator*()
            {
                return buffer_;
            }
            
            inline T* data() const
            {
                return buffer_;
            }
            
            inline T* begin()
            {
                return buffer_;
            }
            
            inline T* end()
            {
                return &buffer_[size_];
            }
    };
    
    template<typename T>
    class scoped_buffer<T, false> : scoped_buffer<T, true>
    {
            using scoped_buffer<T, true>::scoped_buffer;
        public:
            scoped_buffer(const scoped_buffer& copy) = delete;
            
            scoped_buffer operator=(scoped_buffer& copyAssignment) = delete;
    };
    
    template<typename T>
    struct nullptr_initializer
    {
        private:
            T* m_ptr = nullptr;
        public:
            nullptr_initializer() = default;
            
            explicit nullptr_initializer(T* ptr): m_ptr(ptr)
            {}
            
            nullptr_initializer(const nullptr_initializer<T>& ptr): m_ptr(ptr.m_ptr)
            {}
            
            nullptr_initializer(nullptr_initializer<T>&& ptr) noexcept: m_ptr(ptr.m_ptr)
            {}
            
            nullptr_initializer<T>& operator=(const nullptr_initializer<T>& ptr)
            {
                if (&ptr == this)
                    return *this;
                this->m_ptr = ptr.m_ptr;
                return *this;
            }
            
            nullptr_initializer<T>& operator=(nullptr_initializer<T>&& ptr) noexcept
            {
                if (&ptr == this)
                    return *this;
                this->m_ptr = ptr.m_ptr;
                return *this;
            }
            
            inline T* operator->()
            {
                return m_ptr;
            }
            
            ~nullptr_initializer() = default;
    };
    
    /**
     * Creates a hash-map like association between an enum key and any arbitrary value.
     * The storage is backed by a contiguous array for faster access.
     * @tparam K enum value
     * @tparam V associated value
     */
    template<typename K, typename V>
    class enum_storage
    {
        private:
            V* m_values;
            size_t m_size = 0;
        public:
            enum_storage(std::initializer_list<std::pair<K, V>> init)
            {
                for (auto& i : init)
                    m_size = std::max((size_t) i.first, m_size);
                m_values = new V[m_size];
                for (auto& v : init)
                    m_values[(size_t) v.first] = v.second;
            }
            
            inline V& operator[](size_t index)
            {
                return m_values[index];
            }
            
            inline const V& operator[](size_t index) const
            {
                return m_values[index];
            }
            
            [[nodiscard]] inline size_t size() const
            {
                return m_size;
            }
            
            ptr_iterator<V> begin()
            {
                return ptr_iterator{m_values};
            }
            
            ptr_iterator<V> end()
            {
                return ptr_iterator{&m_values[m_size]};
            }
            
            ~enum_storage()
            {
                delete[] m_values;
            }
    };
    
}

#endif //BLT_TESTS_MEMORY_H