Array.h

#pragma once
#include "ToolchefsSTL/Allocators/Allocator.h"
#include <utility>
#include <cassert>
 
namespace ToolchefsSTL
{
    template<typename T>
    class Array
    {
    public:
 
        template <class Iter>
        struct ReverseIterator
        {
            ReverseIterator(Iter* ptr) : m_ptr(ptr) {}
            ~ReverseIterator() = default;
            Iter* operator +(size_t value) const { return m_ptr - value; }
            Iter* operator -(size_t value) const { return m_ptr + value; }
            Iter* operator ++() { return --m_ptr; }
            Iter* operator --() { return ++m_ptr; }
            bool operator ==(const ReverseIterator& rhs) const { return m_ptr == rhs.m_ptr; }
            bool operator !=(const ReverseIterator& rhs) const { return m_ptr != rhs.m_ptr; }
            Iter operator *() const { return *m_ptr; }
            Iter* operator->() const { return m_ptr; }
            Iter* m_ptr;
        };
 
        typedef T value_type;
        typedef T& reference_type;
        typedef T* ptr_type;
 
        typedef T* iterator;
        typedef const T* const_iterator;
        typedef ReverseIterator<T> reverse_iterator;
        typedef ReverseIterator<const T> const_reverse_iterator;
 
        explicit Array(Allocator* allocator = defaultAllocator()) noexcept;
 
        explicit Array(size_t num_elements, Allocator* allocator = defaultAllocator()) noexcept;
 
        explicit  Array(size_t num_elements, const T& init_value, Allocator* allocator = defaultAllocator()) noexcept;
 
        ~Array() noexcept;
 
        Array(const Array& rhs) noexcept;
 
        Array& operator=(const Array& rhs) noexcept;
 
        Array(Array&& rhs) noexcept;
 
        Array& operator=(Array&& rhs) noexcept;
 
        bool operator==(const Array& rhs) const noexcept;
 
        void push_back(const T& element) noexcept;
 
        template <typename... Args>
        T& emplace_back(Args&&... args) {
            if (m_length == m_capacity) grow();
            return *new (m_data + m_length++) T(std::forward<Args>(args)...);
        }
 
        void pop_back() noexcept;
 
        void insert(size_t index, const T& value) noexcept;
        void insert(iterator it, const T& value) noexcept;
 
        void erase(size_t index) noexcept;
        iterator erase(iterator it) noexcept;
 
        iterator begin() noexcept;
        iterator end() noexcept;
        const_iterator cbegin() const noexcept;
        const_iterator cend() const noexcept;
 
        reverse_iterator rbegin() noexcept;
        reverse_iterator rend() noexcept;
        const_reverse_iterator crbegin() const noexcept;
        const_reverse_iterator crend() const noexcept;
 
        T& back() noexcept;
        const T& back() const noexcept;
 
        T& front() noexcept;
        const T& front() const noexcept;
 
#if __cplusplus >= 201703L
        constexpr T& operator[](const size_t index) noexcept;
        constexpr const T& operator[](const size_t index) const noexcept;
#else
        inline T& operator[](const size_t index) noexcept { return m_data[index];}
        inline const T& operator[](const size_t index) const noexcept { return m_data[index];}
#endif
        const T* data() const noexcept;
 
        void resize(size_t new_length) noexcept;
 
        void reserve(size_t new_capacity) noexcept;
 
        void clear() noexcept;
 
        size_t size() const noexcept;
 
        size_t length() const noexcept;
 
        size_t capacity() const noexcept;
 
        void shrink_to_fit() noexcept;
 
        iterator find(const T& element) noexcept;
 
        const_iterator find(const T& element) const noexcept;
 
        bool empty() const noexcept;
 
    private:
 
        void grow() noexcept;
 
    private:
 
        T* m_data;
        Allocator* m_allocator;
        size_t m_length;
        size_t m_capacity;
    };
}
 
#include "Array.impl.h"