List.h

 
#ifndef ACTIVE_CONTAINER_LIST
#define ACTIVE_CONTAINER_LIST
 
#include "Active/Utility/Cloner.h"
#include "Active/Utility/Mover.h"
 
#include <list>
#include <memory>
 
namespace active::container {
    
    template<class T> requires utility::Clonable<T>
    class List : public std::list<std::unique_ptr<T>> {
    public:
        
        // MARK: Types
        
        using value_t = std::unique_ptr<T>;
        using base = std::list<value_t>;
        using size_type = typename base::size_type;
        using iterator = typename base::iterator;
        using const_iterator = typename base::const_iterator;
        
        // MARK: Constructors
        
        List() : base() {}
        template<class Derived>
        explicit List(const std::initializer_list<Derived>& items) : base() {
            for (const auto& item : items)
                emplace_back(item);
        }
        List(const List& source) : base () { cloneFrom(source); }
        List(List&& source) : base(std::move(source)) {}
        virtual ~List() = default;
        
        // MARK: Operators
        
        auto operator= (const List& source) {
            if (this != &source) {
                base::clear();
                cloneFrom(source);
            }
            return *this;
        }
        auto operator= (List&& source) {
            if (this != &source)
                base::operator=(std::move(source));
            return *this;
        }
        
        // MARK: Functions (mutating)
        
        void push_back(T* item) { base::push_back(value_t(item)); }
        void push_back(T& item) { base::push_back(clone(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_t&& item) { base::emplace_back(std::move(item)); }
        void emplace_back(value_t& item) { base::emplace_back(std::move(item)); }
        void push_front(T* item) { base::push_front(value_t(item)); }
        void emplace_front(T&& item) {
            if constexpr(utility::Movable<T>)
                base::emplace_front(cloneMove(std::move(item)));
            else
                base::emplace_front(clone(item));
        }
        void emplace_front(value_t&& item) { base::emplace_front(std::move(item)); }
        auto release(iterator& pos) {
            auto item = std::move(*pos);
            pos = this->erase(pos);
            return item;
        }
        
    private:
        void cloneFrom(const List& source) {
            for (const auto& item : source)
                base::push_back(item ? clone(*item) : value_t());
        }
    };
    
}
 
#endif  //ACTIVE_CONTAINER_LIST