AtomicList.h

浏览该文件的文档.

// Copyright (c) 2017 Computer Vision Center (CVC) at the Universitat Autonoma
// de Barcelona (UAB).
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#pragma once
 
#include "carla/AtomicSharedPtr.h"
#include "carla/NonCopyable.h"
 
#include <algorithm>
#include <mutex>
#include <vector>
 
namespace carla {
namespace client {
namespace detail {
 
  /// Holds an atomic pointer to a list.
  ///
  /// @warning Only Load method is atomic, modifications to the list are locked
  /// with a mutex.
  template <typename T>
  class AtomicList : private NonCopyable {
    using ListT = std::vector<T>;
  public:
 
    AtomicList() : _list(std::make_shared<ListT>()) {}
 
    template <typename ValueT>
    void Push(ValueT &&value) {
      std::lock_guard<std::mutex> lock(_mutex);
      auto new_list = std::make_shared<ListT>(*Load());
      new_list->emplace_back(std::forward<ValueT>(value));
      _list = new_list;
    }
 
    void DeleteByIndex(size_t index) {
      std::lock_guard<std::mutex> lock(_mutex);
      auto new_list = std::make_shared<ListT>(*Load());
      auto begin = new_list->begin();
      std::advance(begin, index);
      new_list->erase(begin);
      _list = new_list;
    }
 
    template <typename ValueT>
    void DeleteByValue(const ValueT &value) {
      std::lock_guard<std::mutex> lock(_mutex);
      auto new_list = std::make_shared<ListT>(*Load());
      new_list->erase(std::remove(new_list->begin(), new_list->end(), value), new_list->end());
      _list = new_list;
    }
 
    void Clear() {
      std::lock_guard<std::mutex> lock(_mutex);
      _list = std::make_shared<ListT>();
    }
 
    /// Returns a pointer to the list.
    std::shared_ptr<const ListT> Load() const {
      return _list.load();
    }
 
  private:
 
    std::mutex _mutex;
 
    AtomicSharedPtr<const ListT> _list;
  };
 
} // namespace detail
} // namespace client
} // namespace carla