Vector.h

 
#pragma once
 
#include <cassert>
#include <memory>       //std::allocator_traits
 
#include "Refureku/Containers/Allocator.h"
 
namespace rfk
{
    template <typename T, typename Allocator = rfk::Allocator<T>>
    class Vector
    {
        //Friendship for move constructor from Vector holding another type of data
        template <typename U, typename UAllocator>
        friend class Vector;
 
        private:
            using AllocTraits = std::allocator_traits<Allocator>;
 
            static constexpr float const _growthFactor = 2.0f;
 
            T*          _data;
 
            std::size_t _size;
 
            std::size_t _capacity;
 
            Allocator   _allocator;
 
            void        constructElements(T*            from,
                                          std::size_t   count);
 
            void        copyElements(T const*    from,
                                     T*          to,
                                     std::size_t count);
 
            void        copyElementsReverse(T const*    from,
                                            T*          to,
                                            std::size_t count);
            
            void        moveElements(T*          from,
                                     T*          to,
                                     std::size_t count);
 
            void        moveElementsReverse(T*          from,
                                            T*          to,
                                            std::size_t count);
 
            void        destroyElements(T*          from,
                                        std::size_t count);
 
            void        checkedDelete();
 
            void        reallocateIfNecessary(std::size_t minCapacity);
 
            void        makeFreeSpaceForXElements(std::size_t index,
                                                  std::size_t count);
 
            std::size_t computeNewCapacity(std::size_t minCapacity) const noexcept;
 
        public:
            using value_type = T;
            using allocator_type = Allocator;
            using reference = value_type&;
            using const_reference = value_type const&;
            
            Vector(std::size_t initialCapacity = 0u)    noexcept;
 
            template <typename U, typename UAlloc>
            Vector(Vector<U, UAlloc>&&)                 noexcept;
 
            Vector(Vector const&);
            Vector(Vector&&)                            noexcept;
            ~Vector();
 
            T&          front()         noexcept;
            T const&    front() const   noexcept;
 
            T&          back()          noexcept;
            T const&    back()  const   noexcept;
 
            T*          data()          noexcept;
            T const*    data()  const   noexcept;
 
            void        reserve(std::size_t capacity);
 
            void        resize(std::size_t size);
 
            std::size_t size()          const   noexcept;
 
            std::size_t capacity()      const   noexcept;
 
            bool        empty()         const   noexcept;
 
            void        clear();
 
            void        push_back(T const& value);
 
            void        push_back(T&& value);
 
            void        push_back(Vector const& other);
            void        push_back(Vector&& other);
 
            void        insert(std::size_t  index,
                               T const&     element);
 
            void        insert(std::size_t  index,
                               T&&          element);
 
            template <typename... Args>
            T&          emplace_back(Args&&... args);
 
            T*          begin()             noexcept;
            T const*    begin()     const   noexcept;
            T const*    cbegin()    const   noexcept;
 
            T*          end()               noexcept;
            T const*    end()       const   noexcept;
            T const*    cend()      const   noexcept;
 
            T&              operator[](std::size_t index)       noexcept;
            T const&        operator[](std::size_t index) const noexcept;
 
            Vector&         operator=(Vector const&);
            Vector&         operator=(Vector&&)                 noexcept;
    };
 
    #include "Refureku/Containers/Vector.inl"
}