List.h

#pragma once
#include <ToolchefsSTL/Allocators/Allocator.h>
 
namespace ToolchefsSTL
{
    template<typename T>
    class List
    {
    public:
 
        class Node
        {
        public:
            Node(): data(), _prev(nullptr), _next(nullptr) {}
 
            Node(const T& value) : data(value), _prev(nullptr), _next(nullptr) {}
 
            template <typename... Args>
            Node(Args&&... args): data(std::forward<Args>(args)...), _prev(nullptr), _next(nullptr) {}
 
            ~Node() = default;
 
        public:
            T data;
            Node* _prev;
            Node* _next;
        };
 
        template <class Item, class ItemType, bool Reverse>
        struct ListIterator
        {
            ListIterator(Item* ptr) : m_ptr(ptr) {}
            ~ListIterator() = default;
            ListIterator operator +(size_t value) const
            {
                Item* node = m_ptr;
                for (size_t i=0; i < value; ++i)
                {
                    if (Reverse)
                    {
                        if (node && node->_prev)
                            node = node->_prev;
                    }
                    else
                    {
                        if (node && node->_next)
                            node = node->_next;
                    }
                }
                return ListIterator(node);
            }
 
            ListIterator operator -(size_t value) const
            {
                Item* node = m_ptr;
                for (size_t i = 0; i < value; ++i)
                {
                    if (Reverse)
                    {
                        if (node && node->_next)
                            node = node->_next;
                    }
                    else
                    {
                        if (node && node->_prev)
                            node = node->_prev;
                    }
                }
                return ListIterator(node);
            }
 
            ListIterator& operator ++()
            {
                if (Reverse)
                    m_ptr = m_ptr ? m_ptr->_prev : nullptr;
                else
                    m_ptr = m_ptr ? m_ptr->_next : nullptr;
                return *this;
            }
 
            ListIterator& operator --()
            {
                if (Reverse)
                    m_ptr = m_ptr ? m_ptr->_next : nullptr;
                else
                    m_ptr = m_ptr ? m_ptr->_prev : nullptr;
                return *this;
            }
 
            bool operator ==(const ListIterator& rhs) const { return m_ptr == rhs.m_ptr; }
            bool operator !=(const ListIterator& rhs) const { return m_ptr != rhs.m_ptr; }
            ItemType& operator *() const { return m_ptr->data; }
            ItemType* operator->() const { return &m_ptr->data; }
            Item* m_ptr;
        };
 
        typedef T value_type;
        typedef T& reference_type;
        typedef T* ptr_type;
 
        typedef ListIterator<Node, T, false> iterator;
        typedef ListIterator<const Node, const T, false> const_iterator;
        typedef ListIterator<Node, T, true> reverse_iterator;
        typedef ListIterator<const Node, const T, true> const_reverse_iterator;
 
        explicit List(Allocator* allocator = defaultAllocator()) noexcept;
 
        ~List() noexcept;
 
        List(const List& rhs) noexcept;
 
        List& operator=(const List& rhs) noexcept;
 
        List(List&& rhs) noexcept;
 
        List& operator=(List&& rhs) noexcept;
 
        void clear() noexcept;
 
        size_t size() const noexcept;
 
        size_t length() const 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;
 
        void push_back(const T& element) noexcept;
 
        void pop_back() noexcept;
 
        template <typename... Args>
        T& emplace_back(Args&&... args)
        {
            Node* value = static_cast<Node*>(m_allocator->malloc(sizeof(Node)));
            new (value) Node(std::forward<Args>(args)...);
            if (!m_head)
            {
                m_head = value;
                m_tail = m_head;
                return value->data;
            }
            m_tail->_next = value;
            value->_prev = m_tail;
            m_tail = value;
            return value->data;
        }
 
        template <typename... Args>
        T& emplace_front(Args&&... args)
        {
            Node* value = static_cast<Node*>(m_allocator->malloc(sizeof(Node)));
            new (value) Node(std::forward<Args>(args)...);
            if (!m_head)
            {
                m_head = value;
                m_tail = m_head;
                return value->data;
            }
 
            value->_next = m_head;
            m_head = value;
            return value->data;
        }
 
        void push_front(const T& element) noexcept;
 
        void pop_front() noexcept;
 
        inline bool empty() noexcept { return m_head == nullptr; }
 
        iterator insert(const_iterator pos, const T& value) noexcept;
 
        iterator insert(iterator pos, const T& value) noexcept;
 
        template <typename... Args>
        iterator emplace(const_iterator pos, Args&&... args) noexcept
        {
 
            if (pos == cend() || !pos.m_ptr) return end();
            Node* node = const_cast<Node*>(pos.m_ptr);
 
            Node* new_node = static_cast<Node*>(m_allocator->malloc(sizeof(Node)));
            new (new_node) Node(std::forward<Args>(args)...);
            Node* prevNode = node->_prev;
            node->_prev = new_node;
            new_node->_next = node;
            if (prevNode)
            {
                prevNode->_next = new_node;
                new_node->_prev = prevNode;
            }
            return iterator(new_node);
        }
 
        template <typename... Args>
        iterator emplace(iterator pos, Args&&... args) noexcept
        {
 
            if (pos == end() || !pos.m_ptr) return end();
            Node* node = pos.m_ptr;
 
            Node* new_node = static_cast<Node*>(m_allocator->malloc(sizeof(Node)));
            new (new_node) Node(std::forward<Args>(args)...);
            Node* prevNode = node->_prev;
            node->_prev = new_node;
            new_node->_next = node;
            if (prevNode)
            {
                prevNode->_next = new_node;
                new_node->_prev = prevNode;
            }
            return iterator(new_node);
        }
 
        iterator erase(const_iterator pos) noexcept;
 
        iterator erase(iterator pos) noexcept;
 
        iterator find(const T& element) noexcept;
 
        const_iterator find(const T& element) const noexcept;
 
    private:
        Node* m_head;
        Node* m_tail;
        Allocator* m_allocator;
    };
}
 
#include "List.impl.h"