List.h

#pragma once
 
#include "IList.h"
#include "IToString.h"
#include "Utils.h"
#include <algorithm>
#include <initializer_list>
#include <stdexcept>
#include <utility>
 
namespace sw
{
    template <typename T>
    class List final : public IListT<T>,
                       public IToString<List<T>>
    {
    private:
        std::vector<T> _data;
 
    public:
        List() = default;
 
        List(std::initializer_list<T> list)
            : _data(list)
        {
        }
 
        explicit List(int capacity)
            : _data()
        {
            _data.reserve(static_cast<size_t>(capacity));
        }
 
        List(const List<T> &other)
            : _data(other._data)
        {
        }
 
        List(List<T> &&other) noexcept
            : _data(std::move(other._data))
        {
        }
 
        List<T> &operator=(const List<T> &other)
        {
            if (this != &other) {
                _data = other._data;
            }
            return *this;
        }
 
        List<T> &operator=(List<T> &&other) noexcept
        {
            if (this != &other) {
                _data = std::move(other._data);
            }
            return *this;
        }
 
        T &operator[](int index)
        {
            return GetAt(index);
        }
 
        const T &operator[](int index) const
        {
            return GetAt(index);
        }
 
        int Capacity() const noexcept
        {
            return static_cast<int>(_data.capacity());
        }
 
        void Reserve(int newCapacity)
        {
            if (newCapacity > Capacity()) {
                _data.reserve(static_cast<size_t>(newCapacity));
            }
        }
 
        void Clear()
        {
            _data.clear();
        }
 
        void Add(const T &value)
        {
            _data.push_back(value);
        }
 
        void Add(T &&value)
        {
            _data.push_back(std::move(value));
        }
 
        void RemoveAt(int index)
        {
            if (index < 0 || index >= Count()) {
                throw std::out_of_range("Index out of range in List::RemoveAt.");
            }
            _data.erase(_data.begin() + static_cast<size_t>(index));
        }
 
        void Insert(int index, const T &value)
        {
            if (index < 0 || index > Count()) {
                throw std::out_of_range("Index out of range in List::Insert.");
            }
            _data.insert(_data.begin() + static_cast<size_t>(index), value);
        }
 
        void Insert(int index, T &&value)
        {
            if (index < 0 || index > Count()) {
                throw std::out_of_range("Index out of range in List::Insert.");
            }
            _data.insert(_data.begin() + static_cast<size_t>(index), std::move(value));
        }
 
        int IndexOf(const T &value) const
        {
            auto it = std::find(_data.begin(), _data.end(), value);
            return it != _data.end() ? static_cast<int>(std::distance(_data.begin(), it)) : -1;
        }
 
        int LastIndexOf(const T &value) const
        {
            auto it = std::find(_data.rbegin(), _data.rend(), value);
            return it != _data.rend() ? static_cast<int>(std::distance(it, _data.rend()) - 1) : -1;
        }
 
        bool Contains(const T &value) const
        {
            return std::find(_data.begin(), _data.end(), value) != _data.end();
        }
 
        bool Remove(const T &value)
        {
            int index = IndexOf(value);
            if (index == -1) {
                return false;
            } else {
                RemoveAt(index);
                return true;
            }
        }
 
        std::wstring ToString() const
        {
            return Utils::BuildStr(_data);
        }
 
        std::vector<T> &GetInternalVector() noexcept
        {
            return _data;
        }
 
        const std::vector<T> &GetInternalVector() const noexcept
        {
            return _data;
        }
 
    private:
        template <typename U = T>
        auto SetAtImpl(int index, const T &value)
            -> typename std::enable_if<std::is_copy_assignable<U>::value>::type
        {
            if (index < 0 || index >= Count()) {
                throw std::out_of_range("Index out of range in List::SetAt.");
            }
            _data[static_cast<size_t>(index)] = value;
        }
 
        template <typename U = T>
        auto SetAtImpl(int index, const T &value)
            -> typename std::enable_if<!std::is_copy_assignable<U>::value>::type
        {
            throw std::logic_error("Type T must be copy assignable to use SetAt in List.");
        }
 
        template <typename U = T>
        auto SetAtImpl(int index, T &&value)
            -> typename std::enable_if<std::is_move_assignable<U>::value>::type
        {
            if (index < 0 || index >= Count()) {
                throw std::out_of_range("Index out of range in List::SetAt.");
            }
            _data[static_cast<size_t>(index)] = std::move(value);
        }
 
        template <typename U = T>
        auto SetAtImpl(int index, T &&value)
            -> typename std::enable_if<!std::is_move_assignable<U>::value>::type
        {
            throw std::logic_error("Type T must be move assignable to use move SetAt in List.");
        }
 
    public:
        virtual int Count() const noexcept override
        {
            return static_cast<int>(_data.size());
        }
 
        virtual T &GetAt(int index) override
        {
            if (index < 0 || index >= Count()) {
                throw std::out_of_range("Index out of range in List::GetAt.");
            }
            return _data[static_cast<size_t>(index)];
        }
 
        virtual const T &GetAt(int index) const override
        {
            if (index < 0 || index >= Count()) {
                throw std::out_of_range("Index out of range in List::GetAt.");
            }
            return _data[static_cast<size_t>(index)];
        }
 
        virtual void SetAt(int index, const T &value) override
        {
            SetAtImpl(index, value);
        }
 
        virtual void SetAt(int index, T &&value) override
        {
            SetAtImpl(index, std::move(value));
        }
    };
}