Vector.h

 
#ifndef ACTIVE_CONTAINER_VECTOR
#define ACTIVE_CONTAINER_VECTOR
 
#include "Active/Utility/Cloner.h"
#include "Active/Utility/Mover.h"
 
#include <vector>
 
namespace active::container {
    
    template<class T> requires utility::Clonable<T>
    class Vector : public std::vector<std::unique_ptr<T>> {
    public:
        
        // MARK: Types
        
        using base = std::vector<std::unique_ptr<T>>;
        using value_type = typename base::value_type;
        using size_type = typename base::size_type;
        using iterator = typename base::iterator;
        using const_iterator = typename base::const_iterator;
        
        // MARK: Constructors
        
        Vector(size_type toReserve = 0) : base() { if (toReserve != 0) base::reserve(toReserve); }
        template<class Derived>
        explicit Vector(const std::initializer_list<Derived>& items) : base() {
            for (const auto& item : items)
                emplace_back(item);
        }
        Vector(const Vector& source) : base() { cloneFrom(source); }
        Vector(Vector&& source) : base(std::move(source)) {}
        virtual ~Vector() = default;
        
        // MARK: Operators
        
        auto operator= (const Vector& source) {
            if (this != &source) {
                base::clear();
                cloneFrom(source);
            }
            return *this;
        }
        auto operator= (Vector&& source) {
            if (this != &source)
                base::operator=(std::move(source));
            return *this;
        }
        
        // MARK: Functions (mutating)
        
        void push_back(T* item) { base::push_back(value_type{item}); }
        void emplace_back(T&& item) {
            if constexpr(utility::Movable<T>)
                base::emplace_back(cloneMove(std::move(item)));
            else
                base::emplace_back(clone(item));
        }
        void emplace_back(const T& item) { base::emplace_back(clone(item)); }
        void emplace_back(value_type&& item) { base::emplace_back(std::move(item)); }
        void emplace_back(value_type& item) { base::emplace_back(std::move(item)); }
        auto insert(const_iterator pos, T* item) { return base::insert(pos, value_type{item}); }
        auto emplace(const_iterator pos, T&& item) {
            if constexpr(utility::Movable<decltype(item)>)
                return base::emplace(pos, cloneMove(item));
            else
                return base::emplace(pos, clone(item));
        }
        auto emplace(const_iterator pos, value_type& item) { return base::emplace(pos, std::move(item)); }
        auto release(iterator& pos) { return release(const_iterator(pos)); }
        auto release(const_iterator pos) {
            auto item = std::move(const_cast<value_type&>(*pos));
            base::erase(pos);
            return item;
        }
        
    private:
        void cloneFrom(const Vector& source) {
            base::reserve(source.size());
            for (const auto& item : source)
                base::push_back(item ? clone(*item) : value_type());
        }
    };
    
}
 
#endif  //ACTIVE_CONTAINER_VECTOR