Dictionary.h

#pragma once
 
#include "IComparable.h"
#include "IToString.h"
#include "Utils.h"
#include <map>
#include <memory>
#include <string>
 
namespace sw
{
    template <typename TKey, typename TVal>
    class Dictionary; // 向前声明
 
    template <typename TVal>
    using StrDictionary = Dictionary<std::wstring, TVal>;
 
    template <typename TKey, typename TVal>
    class Dictionary : public IToString<Dictionary<TKey, TVal>>,
                       public IEqualityComparable<Dictionary<TKey, TVal>>
    {
    private:
        std::shared_ptr<std::map<TKey, TVal>> _pMap;
 
    public:
        Dictionary()
            : _pMap(std::make_shared<std::map<TKey, TVal>>())
        {
        }
 
        Dictionary(std::initializer_list<std::pair<const TKey, TVal>> list)
            : _pMap(std::make_shared<std::map<TKey, TVal>>(list))
        {
        }
 
        auto begin() const
        {
            return this->_pMap->begin();
        }
 
        auto end() const
        {
            return this->_pMap->end();
        }
 
        auto rbegin() const
        {
            return this->_pMap->rbegin();
        }
 
        auto rend() const
        {
            return this->_pMap->rend();
        }
 
        auto &operator[](const TKey &key) const
        {
            return this->_pMap->at(key);
        }
 
        bool Equals(const Dictionary &other) const
        {
            return this->_pMap == other._pMap;
        }
 
        int Count() const
        {
            return (int)this->_pMap->size();
        }
 
        bool IsEmpty() const
        {
            return this->_pMap->empty();
        }
 
        auto Add(const TKey &key, const TVal &value) const
        {
            this->_pMap->insert(std::make_pair(key, value));
            return *this;
        }
 
        bool ContainsKey(const TKey &key) const
        {
            return this->_pMap->count(key);
        }
 
        bool ContainsValue(const TVal &value) const
        {
            for (const auto &pair : *this->_pMap) {
                if (pair.second == value) {
                    return true;
                }
            }
            return false;
        }
 
        void Remove(const TKey &key) const
        {
            this->_pMap->erase(key);
        }
 
        void Clear() const
        {
            this->_pMap->clear();
        }
 
        Dictionary Copy() const
        {
            Dictionary dic;
            dic._pMap->insert(this->_pMap->begin(), this->_pMap->end());
            return dic;
        }
 
        std::map<TKey, TVal> &GetStdMap() const
        {
            return *this->_pMap;
        }
 
        std::wstring ToString() const
        {
            return Utils::BuildStr(*this->_pMap);
        }
    };
}