Set.h

#pragma once
#include <ToolchefsSTL/Allocators/Allocator.h>
 
namespace ToolchefsSTL
{
    template<typename T>
    class Set
    {
    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 Set(Allocator* allocator = defaultAllocator()) noexcept;
 
        ~Set() noexcept;
 
        Set(const Set& rhs) noexcept;
 
        Set& operator=(const Set& rhs) noexcept;
 
        Set(Set&& rhs) noexcept;
 
        Set& operator=(Set&& rhs) noexcept;
 
        bool operator==(const Set& rhs) const noexcept;
 
        void insert(const T& element) noexcept;
 
        void erase(const T& element) noexcept;
        void 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;
 
        const T* data() const 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 resize(size_t new_length) noexcept;
 
        T& back() noexcept;
        const T& back() const noexcept;
 
        T& front() noexcept;
        const T& front() const noexcept;
 
        void grow() noexcept;
 
    private:
 
        T* m_data;
        Allocator* m_allocator;
        size_t m_length;
        size_t m_capacity;
    };
}
 
#include "Set.impl.h"