core/include/core/data/List.hpp

#ifndef CORE_LIST_HPP
#define CORE_LIST_HPP

#include "core/math/Math.hpp"
#include "core/utils/AlignedData.hpp"
#include "core/utils/ArrayString.hpp"
#include "core/utils/Error.hpp"
#include "core/utils/New.hpp"

namespace Core {
    template<typename T>
    class List final {
        size_t length;
        size_t capacity;
        T* data;

    public:
        List() : length(0), capacity(0), data(nullptr) {
        }

        List(const List& other) = delete;

        List(List&& other) : List() {
            swap(other);
        }

        ~List() {
            clear();
            delete[] reinterpret_cast<AlignedType<T>*>(data);
        }

        List& operator=(const List& other) = delete;

        List& operator=(List&& other) {
            swap(other);
            return *this;
        }

        check_return Error copyFrom(const List& other) {
            List copy;
            CORE_RETURN_ERROR(allocate(copy.data, other.capacity));
            copy.capacity = other.capacity;
            for(size_t i = 0; i < other.length; i++) {
                copy.unsafeAdd(other[i]);
            }
            swap(copy);
            return ErrorCode::NONE;
        }

        T* begin() {
            return data;
        }

        T* end() {
            return data + length;
        }

        const T* begin() const {
            return data;
        }

        const T* end() const {
            return data + length;
        }

        check_return Error reserve(size_t n) {
            if(n <= capacity) {
                return ErrorCode::NONE;
            }
            return setSize(n);
        }

        check_return Error shrink() {
            if(length == capacity) {
                return ErrorCode::NONE;
            }
            return setSize(length);
        }

        check_return Error resize(size_t n, const T& t) {
            if(length < n) {
                CORE_RETURN_ERROR(reserve(n));
                for(size_t i = n - length; i != 0; i--) {
                    unsafeAdd(t);
                }
            } else if(length > n) {
                for(size_t i = n; i < length; i++) {
                    data[i].~T();
                }
                length = n;
            }
            return ErrorCode::NONE;
        }

        check_return Error resize(size_t n) {
            if(length < n) {
                CORE_RETURN_ERROR(reserve(n));
                for(size_t i = n - length; i != 0; i--) {
                    unsafeAdd(T());
                }
            } else if(length > n) {
                for(size_t i = n; i < length; i++) {
                    data[i].~T();
                }
                length = n;
            }
            return ErrorCode::NONE;
        }

        template<typename... Args>
        check_return Error put(T*& t, Args&&... args) {
            CORE_RETURN_ERROR(ensureCapacity());
            t = unsafeAdd(Core::forward<Args>(args)...);
            return ErrorCode::NONE;
        }

        template<typename... Args>
        check_return Error add(Args&&... args) {
            T* t = nullptr;
            return put(t, Core::forward<Args>(args)...);
        }

        T& operator[](size_t index) {
            return data[index];
        }

        const T& operator[](size_t index) const {
            return data[index];
        }

        size_t getLength() const {
            return length;
        }

        size_t getCapacity() const {
            return capacity;
        }

        void clear() {
            for(size_t i = 0; i < length; i++) {
                data[i].~T();
            }
            length = 0;
        }

        check_return Error removeBySwap(size_t index) {
            if(index >= length) {
                return ErrorCode::INVALID_INDEX;
            }
            length--;
            if(index != length) {
                data[index] = Core::move(data[length]);
            }
            data[length].~T();
            return ErrorCode::NONE;
        }

        check_return Error remove(size_t index) {
            if(index >= length) {
                return ErrorCode::INVALID_INDEX;
            }
            length--;
            T* currentT = begin() + index;
            T* endT = end();
            while(currentT != endT) {
                T* nextT = currentT + 1;
                *currentT = Core::move(*nextT);
                currentT = nextT;
            }
            endT->~T();
            return ErrorCode::NONE;
        }

        check_return Error removeLast() {
            return removeBySwap(length - 1);
        }

        template<typename String>
        check_return Error toString(String& s) const {
            return Core::toString(s, *this);
        }

        void swap(List& other) {
            Core::swap(length, other.length);
            Core::swap(capacity, other.capacity);
            Core::swap(data, other.data);
        }

    private:
        static Error allocate(T*& t, size_t n) {
            if(n > (1lu << 48)) {
                return ErrorCode::CAPACITY_REACHED;
            } else if(n <= 0) {
                return ErrorCode::NONE;
            }
            t = reinterpret_cast<T*>(new(noThrow) AlignedType<T>[n]);
            return t == nullptr ? ErrorCode::OUT_OF_MEMORY : ErrorCode::NONE;
        }

        check_return Error ensureCapacity() {
            return length < capacity
                       ? ErrorCode::NONE
                       : reserve(capacity + Math::max(4lu, capacity / 4));
        }

        // does not check for capacity
        template<typename... Args>
        T* unsafeAdd(Args&&... args) {
            return new(data + length++) T(Core::forward<Args>(args)...);
        }

        check_return Error setSize(size_t n) {
            List copy;
            CORE_RETURN_ERROR(allocate(copy.data, n));
            copy.capacity = n;
            for(size_t i = 0; i < length; i++) {
                copy.unsafeAdd(Core::move(data[i]));
            }
            swap(copy);
            return ErrorCode::NONE;
        }
    };
}

#endif