dynarray.h

Go to the documentation of this file.

// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
 
 
#ifndef FENNEC_CONTAINERS_DYNARRAY_H
#define FENNEC_CONTAINERS_DYNARRAY_H
 
#include <fennec/containers/initializer_list.h>
#include <fennec/lang/utility.h>
#include <fennec/memory/allocator.h>
#include <fennec/memory/new.h>
 
namespace fennec
{
 
template<class TypeT, class Alloc = allocator<TypeT>>
struct dynarray {
public:
 
// Definitions =========================================================================================================
 
    using value_t = TypeT; 
    using alloc_t = Alloc; 
 
 
// Constructors ========================================================================================================
 
 
    constexpr dynarray()
        : _alloc(8)
        , _size(0) {
    }
 
    explicit constexpr dynarray(const alloc_t& alloc)
        : _alloc(8, alloc)
        , _size(0) {
    }
 
    explicit constexpr dynarray(alloc_t&& alloc) noexcept
        : _alloc(8, alloc)
        , _size(0) {
    }
 
    explicit constexpr dynarray(size_t n)
        : _alloc(n)
        , _size(n)
    {
        value_t* addr = _alloc.data();
        for(; n > 0; --n, ++addr) {
            fennec::construct(addr);
        }
    }
 
    constexpr dynarray(size_t n, const alloc_t& alloc)
        : _alloc(n, alloc)
        , _size(n) {
        value_t* addr = _alloc.data();
        for(; n > 0; --n, ++addr) {
            fennec::construct(addr);
        }
    }
 
    constexpr dynarray(size_t n, alloc_t&& alloc)
        : _alloc(n, alloc)
        , _size(n) {
        value_t* addr = _alloc.data();
        for(; n > 0; --n, ++addr) {
            fennec::construct(addr);
        }
    }
 
    constexpr dynarray(size_t n, const TypeT& val)
        : _alloc(n)
        , _size(n) {
        value_t* addr = _alloc.data();
        for(; n > 0; --n, ++addr) {
            fennec::construct(addr, val);
        }
    }
 
    // This constructor should not be invokable since moving is a single object operation and will cause undefined
    // behaviour when moving to multiple elements
    constexpr dynarray(size_t n, TypeT&& val) = delete;
 
    template<typename...ArgsT>
    constexpr explicit dynarray(size_t n, ArgsT&&...args)
        : _alloc(n)
        , _size(n) {
        for(; n > 0; --n) {
            fennec::construct(&_alloc[n], fennec::forward<ArgsT>(args)...);
        }
    }
 
    template<size_t N>
    constexpr dynarray(const TypeT (&arr)[N])
        : _alloc(N)
        , _size(N) {
        for (size_t i = 0; i < N; ++i) {
            _alloc[i] = arr[i];
        }
    }
 
    template<size_t N>
    constexpr dynarray(TypeT (&&arr)[N])
        : _alloc(N)
        , _size(N) {
        for (size_t i = 0; i < N; ++i) {
            _alloc[i] = fennec::move(arr[i]);
        }
    }
 
    template<typename OTypeT, class OAlloc>
    constexpr dynarray(const dynarray<OTypeT, OAlloc>& conv)
        : _alloc(conv.size())
        , _size(conv.size()) {
        size_t i = 0;
        for (const auto& it : conv) {
            fennec::construct(&_alloc[i++], it);
        }
    }
 
    constexpr dynarray(initializer_list<value_t> l, const alloc_t& alloc = alloc_t())
        : _alloc(l.size(), alloc)
        , _size(l.size()) {
        size_t i = 0;
        for (auto& it : l) {
            fennec::construct(&_alloc[i++], fennec::move(it));
        }
    }
 
    constexpr dynarray(const dynarray& arr)
        : _alloc(arr._size)
        , _size(arr._size) {
        for (size_t i = 0; i < _size; ++i) {
            fennec::construct(&_alloc[i], arr[i]);
        }
    }
 
    constexpr dynarray(dynarray&& arr) noexcept
        : _alloc(fennec::move(arr._alloc))
        , _size(arr._size) {
        arr._size = 0;
    }
 
    constexpr ~dynarray() {
        value_t* addr = _alloc.data();
        if (addr == nullptr) return;
        for(int n = _size; n > 0; --n, ++addr) {
            fennec::destruct(addr);
        }
    }
 
 
// Assignment ==========================================================================================================
 
 
    constexpr dynarray& operator=(const dynarray& arr) {
        this->clear();
        _alloc.creallocate(_size = arr._size);
        for (size_t i = 0; i < _size; ++i) {
            fennec::construct(&_alloc[i], fennec::copy(arr[i]));
        }
        return *this;
    }
 
    constexpr dynarray& operator=(dynarray&& arr) noexcept {
        this->clear();
        _alloc = fennec::move(arr._alloc);
        _size  = arr._size;
        arr._size = 0;
        return *this;
    }
 
    template<size_t N>
    constexpr dynarray& operator=(const TypeT (&arr)[N]) {
        this->clear();
        _alloc.creallocate(_size = N);
        for (size_t i = 0; i < _size; ++i) {
            fennec::construct(&_alloc[i], fennec::copy(arr[i]));
        }
        return *this;
    }
 
    template<size_t N>
    constexpr dynarray& operator=(TypeT (&&arr)[N]) {
        this->clear();
        _alloc.creallocate(_size = N);
        for (size_t i = 0; i < _size; ++i) {
            fennec::construct(&_alloc[i], fennec::move(arr[i]));
        }
        return *this;
    }
 
 
// Properties ==========================================================================================================
 
 
    constexpr size_t size() const {
        return _size;
    }
 
    constexpr size_t capacity() const {
        return _alloc.capacity();
    }
 
    constexpr bool empty() const {
        return _size == 0;
    }
 
 
 
// Element Access ======================================================================================================
 
 
    constexpr TypeT& operator[](size_t i) {
        assertd(i < _size, "Array Out of Bounds");
        return _alloc.data()[i];
    }
 
    constexpr const TypeT& operator[](size_t i) const {
        assertd(i < _size, "Array Out of Bounds");
        return _alloc.data()[i];
    }
 
    constexpr TypeT& front() {
        return this->operator[](0);
    }
 
    constexpr const TypeT& front() const {
        return this->operator[](0);
    }
 
    constexpr TypeT& back() {
        return this->operator[](size() - 1);
    }
 
    constexpr const TypeT& back() const {
        return this->operator[](size() - 1);
    }
 
 
 
// Modifiers ===========================================================================================================
 
 
    constexpr void insert(size_t i, TypeT&& val) {
 
        // Grow if the size has reached the capacity of the allocation
        if(_size == capacity()) {
            _grow();
        }
 
        // Move the data if we are not inserting at the end of the array
        if((i = min(i, _size)) < _size) {
            fennec::memmove(
                (void*)(_alloc.data() + i + 1)
            ,   (void*)(_alloc.data() + i)
            ,   (_size - i) * sizeof(TypeT));
        }
 
        // Insert the element
        fennec::construct(_alloc.data() + i, fennec::forward<TypeT>(val));
        ++_size;
    }
 
    constexpr void insert(size_t i, const TypeT& val) {
 
        // Grow if the size has reached the capacity of the allocation
        if(_size == capacity()) {
            _grow();
        }
 
        // Move the data if we are not inserting at the end of the array
        if((i = min(i, _size)) < _size) {
            fennec::memmove(
                (void*)(_alloc.data() + i),
                (void*)(_alloc.data() + i + 1),
                (_size - i) * sizeof(TypeT)
            );
        }
 
        // Insert the element
        fennec::construct(_alloc.data() + i, val);
        ++_size;
    }
 
    template<typename...ArgsT>
    constexpr void emplace(size_t i, ArgsT&&...args) {
 
        // Grow if the size has reached the capacity of the allocation
        if(_size == capacity()) {
            _grow();
        }
 
        // Move the data if we are not inserting at the end of the array
        if((i = min(i, _size)) < _size) {
            fennec::memmove(
                (void*)(_alloc.data() + i)
            ,   (void*)(_alloc.data() + i + 1)
            ,   (_size - i) * sizeof(TypeT));
        }
 
        // Insert the element
        fennec::construct(_alloc.data() + i, fennec::forward<ArgsT>(args)...);
        ++_size;
    }
 
    constexpr void push_back(const TypeT& val) {
        dynarray::insert(_size, val);
    }
 
    constexpr void push_back(TypeT&& val) {
        dynarray::insert(_size, fennec::forward<TypeT>(val));
    }
 
    template<typename...ArgsT>
    constexpr void emplace_back(ArgsT...args) {
        dynarray::emplace(_size, fennec::forward<ArgsT>(args)...);
    }
 
    constexpr void pop_back() {
        fennec::destruct(&_alloc[--_size]);
    }
 
    constexpr void resize(size_t n) {
        _alloc.creallocate(n);
 
        while (_size < n) {
            emplace_back();
        }
    }
 
    constexpr void resize(size_t n, const TypeT& val) {
        _alloc.creallocate(n);
 
        while (_size < n) {
            emplace_back(val);
        }
    }
 
    constexpr void clear() {
        while (_size > 0) {
            fennec::destruct(&_alloc[--_size]);
        }
        _alloc.deallocate();
    }
 
 
 
// Iteration ===========================================================================================================
 
 
    constexpr TypeT* begin() { return _alloc.data(); }
 
    constexpr TypeT* end()   { return begin() + _size; }
 
    constexpr const TypeT* begin() const { return _alloc; }
 
    constexpr const TypeT* end()   const { return begin() + _size; }
 
 
private:
    constexpr void _grow() {
        _alloc.creallocate(_alloc.capacity() * 2);
    }
 
    allocation<value_t, alloc_t> _alloc;
    size_t _size;
};
 
}
 
#endif // FENNEC_CONTAINERS_DYNARRAY_H