GFStableList Adapter

STL中，list的优点是插入、删除性能极佳（时间复杂度只需O(1)即可），而且非常重要的在删除节点后，其迭代器不失效，但list查找却不擅长。map由于其实现的数据结构为rb-tree，因此，其插入、删除以及查找的性能也都是非常不错的。如：插入、删除操作在多数情况下，可能只需要几个简单的数据交换、节点旋转即可达到目的，在这样情况下，时间复杂度也只有O(1)即可（当然，在最糟糕情况下，如插入、删除的时候产生上溯时，则时间复杂度最坏情况有可能达到2logN = O(logN)，但由于rb-tree的性质原因，会产生最坏情况的机会也会比较少，而且大量试验证明，rb-tree的平均性能都是非常好的）。但是map容器在删除节点时，其迭代器是失效的。

但在项目开发(尤其是在游戏项目开发)中，像设计角色管理器、技能管理器、buff管理器等等时候，经常会遇到这样一个问题(说明：此处以角色管理器为例说明)如下：

问题

游戏中(或战场中吧)，每一个角色对象都有一个唯一Id，那么，这些游戏中的对象该如何维护？

解决

见过有的项目中是将这些角色对象用map来维护的。看上去好像是比较理想，因为它查找非常方便，而且在实际当中，也的的确确是需要频繁根据唯一Id查找对应的角色对象。但用map有个问题，在这些对象更新时，有可能会遇到角色死亡的情况，此时该如何处理这个对象？是立即移除？是先打标记然后再在全部更新之后，再一次性全部移除？又或者是都不移除只是不再更新它而已？事实上，这些处理方案都不理想。事实上，用这个方案的项目，最终的结果是：因为没办法在更新时移时移除掉这些“垃圾”角色对象，性能好坏且不说，整个代码最后都显得比较乱。因为用户在到处查找使用时，都是小心查看取出来的该对象是否是有效的。

另一种维护方案是使用list。该方案不必多说，数据组织与更新、移除都没啥大问题，就是查找效率不高。

鉴于前面综述情况，特地设计一个容器适配器GFStableList，其功能类似list，但却具有map的查找性能，并且支持erase时，reverse_iterator参数。编码如下：

 #pragma once

 #include "src/Common/IncludeHeaders.h"

 /******************************************************************************
  * create   : (jacc.kim) [3-1-2016]
  * summary  : class GFStableList.
  * !!!note  : 01.该列表中的元素的"Id"是不可以重复的.
  *            02.该列表稳定、支持快速查找、类似std::list删除时迭代器有效.
  *            03.使用时必需要设置 IdGetter 与 ValueDeleter 两个参数!!!
  *               使用时必需要设置 IdGetter 与 ValueDeleter 两个参数!!!
  *               使用时必需要设置 IdGetter 与 ValueDeleter 两个参数!!!
 ******************************************************************************/
 template<typename TValue, typename TId>
 class GFStableList
 {
 public:
     typedef typename std::list<TValue>                          value_list;
     typedef typename value_list::value_type                     value_type;
     typedef typename value_list::pointer                        pointer;
     typedef typename value_list::const_pointer                  const_pointer;
     typedef typename value_list::reference                      reference;
     typedef typename value_list::const_reference                const_reference;
     typedef typename value_list::difference_type                difference_type;
     typedef typename value_list::size_type                      size_type;
     typedef typename value_list::iterator                       iterator;
     typedef typename value_list::const_iterator                 const_iterator;
     typedef typename value_list::reverse_iterator               reverse_iterator;
     typedef typename value_list::const_reverse_iterator         const_reverse_iterator;

     typedef typename TId                                        id_type;
     typedef typename std::function<id_type(const_reference)>    TGFvalueIdGetter;
     typedef typename std::function<void(const_reference)>       TGFvalueDeleter;

 public:
     GFStableList();
     explicit GFStableList(const TGFvalueIdGetter& getter);
     GFStableList(const TGFvalueIdGetter& getter, const TGFvalueDeleter& deleter);
     ~GFStableList();

     void                                setValueIdGetter(const TGFvalueIdGetter& getter);
     void                                setValueDeleter(const TGFvalueDeleter& deleter);

     // !!!note: only no exist items & valid items will be insert or push.
     const bool                          push_front(const_reference value);
     const bool                          push_back(const_reference value);
     iterator                            insert(const_iterator _where, const_reference value);
     iterator                            insert(const_iterator _where, const_iterator _first, const_iterator _last);

     iterator                            erase(const_reference value);
     iterator                            erase(const id_type& id);
     iterator                            erase(const_iterator _first, const_iterator _last);
     iterator                            erase(const_iterator _where);
     reverse_iterator                    erase(reverse_iterator _first, reverse_iterator _last);
     reverse_iterator                    erase(reverse_iterator _where);
     const_reverse_iterator              erase(const_reverse_iterator _first, const_reverse_iterator _last);
     const_reverse_iterator              erase(const_reverse_iterator _where);
     void                                clear();
     iterator                            find(const id_type& id);
     const_iterator                      find(const id_type& id) const;

     iterator                            begin();
     const_iterator                      begin() const;
     iterator                            end();
     const_iterator                      end() const;

     reverse_iterator                    rbegin();
     const_reverse_iterator              rbegin() const;
     reverse_iterator                    rend();
     const_reverse_iterator              rend() const;

     const_iterator                      cbegin() const;
     const_iterator                      cend() const;
     const_reverse_iterator              crbegin() const;
     const_reverse_iterator              crend() const;

     reference                           front();
     reference                           back();
     const_reference                     front() const;
     const_reference                     back() const;

     void                                pop_front();
     void                                pop_back();

     bool                                empty();
     size_type                           size();

 private:
     GFStableList(const GFStableList<TValue, TId>& listValues) = delete;

 private:
     typedef typename std::map<id_type, iterator>        id_value_map;

     void                                _clearValueList();
     void                                _clearMapping();
     iterator                            _locate(const_reference value);
     const_iterator                      _locate(const_reference value) const;
     iterator                            _locate(const id_type& id);
     const_iterator                      _locate(const id_type& id) const;
     const bool                          _isExisted(const id_type& id);
     const bool                          _isExisted(const_reference value);
     const id_type                       _getValueId(const_reference value);

 private:
     TGFvalueIdGetter                    m_IdGetter;
     TGFvalueDeleter                     m_ValueDeleter;
     value_list                          m_listValues;
     id_value_map                        m_mapMapping;

 };//template<typename TValue, typename TId> class GFStableList

 #include "src/Common/GFStableList.inl"

GFStableList.h文件

 #include "src/Common/IncludeHeaders.h"

 ///////////////////////////////////////////////////////////////////////////////
 // template<typename TValue, typename TId> class GFStableList
 template<typename TValue, typename TId>
 GFStableList<TValue, TId>::GFStableList() : m_IdGetter    (nullptr)
                                           , m_ValueDeleter(nullptr)
                                           , m_listValues  ()
                                           , m_mapMapping  ()
 {

 }

 template<typename TValue, typename TId>
 GFStableList<TValue, TId>::GFStableList(const TGFvalueIdGetter& getter) : m_IdGetter    (getter)
                                                                         , m_ValueDeleter(nullptr)
                                                                         , m_listValues  ()
                                                                         , m_mapMapping  ()
 {

 }

 template<typename TValue, typename TId>
 GFStableList<TValue, TId>::GFStableList(const TGFvalueIdGetter& getter, const TGFvalueDeleter& deleter) : m_IdGetter    (getter)
                                                                                                         , m_ValueDeleter(deleter)
                                                                                                         , m_listValues  ()
                                                                                                         , m_mapMapping  ()
 {

 }

 template<typename TValue, typename TId>
 GFStableList<TValue, TId>::~GFStableList() {
     this->clear();
 }

 template<typename TValue, typename TId>
 void GFStableList<TValue, TId>::setValueIdGetter(const TGFvalueIdGetter& getter) {
     m_IdGetter = getter;
     //GFAssert(nullptr != m_IdGetter, "the id getter is nullptr.");
 }

 template<typename TValue, typename TId>
 void GFStableList<TValue, TId>::setValueDeleter(const TGFvalueDeleter& deleter) {
     m_ValueDeleter = deleter;
 }

 template<typename TValue, typename TId>
 const bool GFStableList<TValue, TId>::push_front(const_reference value) {
     return insert(begin(), value) != end();
 }

 template<typename TValue, typename TId>
 const bool GFStableList<TValue, TId>::push_back(const_reference value) {
     return insert(end(), value) != end();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::iterator GFStableList<TValue, TId>::insert(const_iterator _where, const_reference value) {
     if (nullptr == value) {
         return end();
     }

     const auto id = _getValueId(value);
     if (_isExisted(id)) {
         return end();// 已经存在了.
     }

     auto iter = m_listValues.insert(_where, value);
     m_mapMapping[id] = iter;
     return iter;
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::iterator GFStableList<TValue, TId>::insert(const_iterator _where, const_iterator _first, const_iterator _last) {
     if (_first == end() || _first == _last) {
         return;
     }
     auto insert_pos = end();
     iterator tmpResult;
     id_type id;
     for (auto iter = _first; iter != _last; ++iter) {
         id = _getValueId(*iter);
         if (_isExisted(id)) {
             continue;// id is existed.
         }
         tmpResult = m_listValues.insert(_where, *iter);
         m_mapMapping[id] = tmpResult;

         if (insert_pos == end()) {
             insert_pos = tmpResult;
         }
     }
     return insert_pos;
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::iterator GFStableList<TValue, TId>::erase(const_reference value) {
     auto iter = _locate(value);
     return erase(iter);
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::iterator GFStableList<TValue, TId>::erase(const id_type& id) {
     auto iter = _locate(id);
     return erase(iter);
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::iterator GFStableList<TValue, TId>::erase(const_iterator _first, const_iterator _last) {
     if (_first == end()) {
         return end();
     }
     if (_first == begin() && _last == end()) {
         this->clear();
         return end();
     }
     iterator retIter = end();
     auto iter = _first;
     while (iter != _last && iter != end()) {
         retIter = this->erase(iter);
         iter = retIter;
     }
     return retIter;
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::iterator GFStableList<TValue, TId>::erase(const_iterator _where) {
     if (_where == end()) {
         return end();
     }
     const auto id = _getValueId(*_where);
     m_mapMapping.erase(id);
     return m_listValues.erase(_where);
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::reverse_iterator GFStableList<TValue, TId>::erase(reverse_iterator _first, reverse_iterator _last) {
     if (_first == rend()) {
         return rend();
     }
     if (_first == rbegin() && _last == rend()) {
         this->clear();
         return rend();
     }
     reverse_iterator retIter = rend();
     auto iter = _first;
     while (iter != _last && iter != rend()) {
         retIter = this->erase(iter);
         iter = retIter;
     }
     return retIter;
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::reverse_iterator GFStableList<TValue, TId>::erase(reverse_iterator _where) {
     if (_where == rend()) {
         return rend();
     }

     auto ret_iter = _where; // 返回值.
     ++ret_iter;

     const auto id = _getValueId(*_where.base());
     this->erase(id);

     return ret_iter;
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::const_reverse_iterator GFStableList<TValue, TId>::erase(const_reverse_iterator _first, const_reverse_iterator _last) {
     if (_first == rend()) {
         return rend();
     }
     if (_first == rbegin() && _last == rend()) {
         this->clear();
         return rend();
     }
     const_reverse_iterator retIter = rend();
     auto iter = _first;
     while (iter != _last && iter != rend()) {
         retIter = this->erase(iter);
         iter = retIter;
     }
     return retIter;
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::const_reverse_iterator GFStableList<TValue, TId>::erase(const_reverse_iterator _where) {
     if (_where == rend()) {
         return rend();
     }

     auto ret_iter = _where; // 返回值.
     ++ret_iter;

     const auto id = _getValueId(*_where.base());
     this->erase(id);

     return ret_iter;
 }

 template<typename TValue, typename TId>
 void GFStableList<TValue, TId>::clear() {
     _clearValueList();
     _clearMapping();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::iterator GFStableList<TValue, TId>::find(const id_type& id) {
     return _locate(id);
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::const_iterator GFStableList<TValue, TId>::find(const id_type& id) const {
     return _locate(id);
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::iterator GFStableList<TValue, TId>::begin() {
     return m_listValues.begin();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::const_iterator GFStableList<TValue, TId>::begin() const {
     return m_listValues.begin();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::iterator GFStableList<TValue, TId>::end() {
     return m_listValues.end();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::const_iterator GFStableList<TValue, TId>::end() const {
     return m_listValues.end();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::reverse_iterator GFStableList<TValue, TId>::rbegin() {
     return m_listValues.rbegin();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::const_reverse_iterator GFStableList<TValue, TId>::rbegin() const {
     return m_listValues.rbegin();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::reverse_iterator GFStableList<TValue, TId>::rend() {
     return m_listValues.rend();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::const_reverse_iterator GFStableList<TValue, TId>::rend() const {
     return m_listValues.rend();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::const_iterator GFStableList<TValue, TId>::cbegin() const {
     return m_listValues.cbegin();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::const_iterator GFStableList<TValue, TId>::cend() const {
     return m_listValues.cend();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::const_reverse_iterator GFStableList<TValue, TId>::crbegin() const {
     return m_listValues.crbegin();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::const_reverse_iterator GFStableList<TValue, TId>::crend() const {
     return m_listValues.crend();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::reference GFStableList<TValue, TId>::front() {
     return m_listValues.front();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::reference GFStableList<TValue, TId>::back() {
     return m_listValues.back();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::const_reference GFStableList<TValue, TId>::front() const {
     return m_listValues.front();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::const_reference GFStableList<TValue, TId>::back() const {
     return m_listValues.end();
 }

 template<typename TValue, typename TId>
 void GFStableList<TValue, TId>::pop_front() {
     if (this->empty()) {
         return;
     }
     auto iter = this->begin();
     const auto id = _getValueId(*iter);
     this->erase(id);
 }

 template<typename TValue, typename TId>
 void GFStableList<TValue, TId>::pop_back() {
     if (this->empty()) {
         return;
     }
     auto riter = this->rbegin();
     const auto id = _getValueId(*riter);
     this->erase(id);
 }

 template<typename TValue, typename TId>
 bool GFStableList<TValue, TId>::empty() {
     return m_listValues.empty();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::size_type GFStableList<TValue, TId>::size() {
     return m_listValues.size();
 }

 template<typename TValue, typename TId>
 void GFStableList<TValue, TId>::_clearValueList() {
     if (nullptr != m_ValueDeleter) {
         auto iter = m_listValues.begin();
         auto iterend = m_listValues.end();
         for (; iter != iterend; ++iter) {
             m_ValueDeleter(*iter);
         }
     }
     m_listValues.clear();
 }

 template<typename TValue, typename TId>
 void GFStableList<TValue, TId>::_clearMapping() {
     m_mapMapping.clear();
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::iterator GFStableList<TValue, TId>::_locate(const_reference value) {
     const auto id = m_IdGetter(value);
     return _locate(id);
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::const_iterator GFStableList<TValue, TId>::_locate(const_reference value) const {
     const auto id = m_IdGetter(value);
     return _locate(id);
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::iterator GFStableList<TValue, TId>::_locate(const id_type& id) {
     auto iter = m_mapMapping.find(id);
     if (iter == m_mapMapping.end()) {
         return end();
     }
     return iter->second;
 }

 template<typename TValue, typename TId>
 typename GFStableList<TValue, TId>::const_iterator GFStableList<TValue, TId>::_locate(const id_type& id) const {
     auto iter = m_mapMapping.find(id);
     if (iter == m_mapMapping.end()) {
         return end();
     }
     return iter->second;
 }

 template<typename TValue, typename TId>
 const bool GFStableList<TValue, TId>::_isExisted(const id_type& id) {
     auto iter = m_mapMapping.find(id);
     return iter != m_mapMapping.end();
 }

 template<typename TValue, typename TId>
 const bool GFStableList<TValue, TId>::_isExisted(const_reference value) {
     auto id = _getValueId(value);
     return _isExisted(id);
 }

 template<typename TValue, typename TId>
 typename const GFStableList<TValue, TId>::id_type GFStableList<TValue, TId>::_getValueId(const_reference value) {
     return m_IdGetter(value);
 }

GFStableList.inl文件