List.h

#pragma once
 
#include "IComparable.h"
#include "IToString.h"
#include "Utils.h"
#include <algorithm>
#include <memory>
#include <string>
#include <vector>
 
namespace sw
{
    template <typename T>
    class List; // 向前声明
 
    using StrList = List<std::wstring>;
 
    template <typename T>
    class List : public IToString<List<T>>,
                 public IEqualityComparable<List<T>>
    {
    private:
        std::shared_ptr<std::vector<T>> _pVec;
 
    public:
        List()
            : _pVec(std::make_shared<std::vector<T>>())
        {
        }
 
        List(std::initializer_list<T> list)
            : _pVec(std::make_shared<std::vector<T>>(list))
        {
        }
 
        explicit List(int capacity)
            : List()
        {
            this->_pVec->reserve(capacity);
        }
 
        auto begin() const
        {
            return this->_pVec->begin();
        }
 
        auto end() const
        {
            return this->_pVec->end();
        }
 
        auto rbegin() const
        {
            return this->_pVec->rbegin();
        }
 
        auto rend() const
        {
            return this->_pVec->rend();
        }
 
        auto &operator[](int index) const
        {
            return this->_pVec->at(index);
        }
 
        bool Equals(const List &other) const
        {
            return this->_pVec == other._pVec;
        }
 
        int Capacity() const
        {
            return (int)this->_pVec->capacity();
        }
 
        int Count() const
        {
            return (int)this->_pVec->size();
        }
 
        bool IsEmpty() const
        {
            return this->_pVec->empty();
        }
 
        auto Append(const T &value) const
        {
            this->_pVec->push_back(value);
            return *this;
        }
 
        auto Append(T &&value) const
        {
            this->_pVec->push_back(std::forward<T>(value));
            return *this;
        }
 
        auto Insert(int index, const T &value) const
        {
            this->_pVec->insert(this->_pVec->begin() + index, value);
            return *this;
        }
 
        auto Insert(int index, T &&value) const
        {
            this->_pVec->insert(this->_pVec->begin() + index, std::forward<T>(value));
            return *this;
        }
 
        bool Contains(const T &value) const
        {
            return std::find(this->_pVec->begin(), this->_pVec->end(), value) != this->_pVec->end();
        }
 
        int IndexOf(const T &value) const
        {
            auto it = std::find(this->_pVec->begin(), this->_pVec->end(), value);
            return it == this->_pVec->end() ? -1 : int(it - this->_pVec->begin());
        }
 
        bool Remove(const T &value) const
        {
            auto it = std::find(this->_pVec->begin(), this->_pVec->end(), value);
            if (it == this->_pVec->end())
                return false;
            this->_pVec->erase(it);
            return true;
        }
 
        void RemoveAt(int index) const
        {
            this->_pVec->erase(this->_pVec->begin() + index);
        }
 
        void Clear() const
        {
            this->_pVec->clear();
        }
 
        List Copy() const
        {
            List list((int)this->_pVec->capacity());
            list._pVec->assign(this->_pVec->begin(), this->_pVec->end());
            return list;
        }
 
        std::vector<T> &GetStdVector() const
        {
            return *this->_pVec;
        }
 
        std::wstring ToString() const
        {
            return Utils::BuildStr(*this->_pVec);
        }
    };
}