ConcurrentMap.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
 * Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration.
 */
#ifndef CXXUTILS_CONCURRENTMAP_H
#define CXXUTILS_CONCURRENTMAP_H
 
 
#include "CxxUtils/ConcurrentHashmapImpl.h"
#include "CxxUtils/UIntConv.h"
#include "CxxUtils/concepts.h"
#include "CxxUtils/IsUpdater.h"
#include "boost/iterator/iterator_facade.hpp"
#include "boost/range/iterator_range.hpp"
#include <type_traits>
#include <stdexcept>
 
 
namespace CxxUtils {
 
 
template <class KEY, class VALUE, template <class> class UPDATER,
          class HASHER = std::hash<KEY>,
          class MATCHER = std::equal_to<KEY>,
          detail::ConcurrentHashmapVal_t NULLVAL = 0,
          detail::ConcurrentHashmapVal_t TOMBSTONE = NULLVAL>
ATH_REQUIRES (detail::IsConcurrentHashmapPayload<KEY> &&
              detail::IsConcurrentHashmapPayload<VALUE> &&
              detail::IsUpdater<UPDATER> &&
              detail::IsHash<HASHER, KEY> &&
              detail::IsBinaryPredicate<MATCHER, KEY>)
class ConcurrentMap
{
private:
  using val_t = CxxUtils::detail::ConcurrentHashmapVal_t;
 
  // Translate between the Hasher/Matcher provided (which take KEY arguments)
  // and what we need to give to the underlying implementation
  // (which takes a uintptr_t).
  struct Hasher
  {
    size_t operator() (val_t k) const {
      return m_h (keyAsKey (k));
    }
    HASHER m_h;
  };
  struct Matcher
  {
    bool operator() (val_t a, val_t b) const {
      return m_m (keyAsKey (a), keyAsKey (b));
    }
    MATCHER m_m;
  };
 
  using Impl_t = typename detail::ConcurrentHashmapImpl<UPDATER,
                                                        Hasher,
                                                        Matcher,
                                                        NULLVAL,
                                                        TOMBSTONE>;
 
 
public:
  using key_type = KEY;
  using mapped_type = VALUE;
  using size_type = size_t;
  using Updater_t = typename Impl_t::Updater_t;
  using Context_t = typename Updater_t::Context_t;
  using Lock_t = typename Impl_t::Lock_t;
 
  static_assert( sizeof(typename Impl_t::val_t) >= sizeof(key_type) );
  static_assert( sizeof(typename Impl_t::val_t) >= sizeof(mapped_type) );
 
 
  ConcurrentMap (Updater_t&& updater,
                 size_type capacity = 64,
                 const Context_t& ctx = Updater_t::defaultContext());
 
  ConcurrentMap (const ConcurrentMap& other,
                 Updater_t&& updater,
                 size_t capacity = 64,
                 const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class InputIterator>
  ConcurrentMap (InputIterator f,
                 InputIterator l,
                 Updater_t&& updater,
                 size_type capacity = 64,
                 const Context_t& ctx = Updater_t::defaultContext());
 
 
  ConcurrentMap (const ConcurrentMap& other) = delete;
  ConcurrentMap (ConcurrentMap&& other) = delete;
  ConcurrentMap& operator= (const ConcurrentMap& other) = delete;
  ConcurrentMap& operator= (ConcurrentMap&& other) = delete;
 
 
  ~ConcurrentMap() = default;
 
 
  size_type size() const;
 
 
  bool empty() const;
 
 
  size_t capacity() const;
 
 
  size_t erased() const;
 
 
  using const_iterator_value = std::pair<const key_type, mapped_type>;
 
 
  class const_iterator
    : public boost::iterator_facade<const_iterator,
                                    const const_iterator_value,
                                    std::bidirectional_iterator_tag,
                                    const const_iterator_value>
  {
  public:
    const_iterator (typename Impl_t::const_iterator it);
 
 
    bool valid() const;
 
 
  private:
    friend class boost::iterator_core_access;
 
 
    void increment();
 
 
    void decrement();
 
 
    bool equal (const const_iterator& other) const;
 
 
    const const_iterator_value dereference() const;
 
 
    typename Impl_t::const_iterator m_impl;
  };
 
 
  typedef boost::iterator_range<const_iterator> const_iterator_range;
 
 
  const_iterator_range range() const;
 
 
  const_iterator begin() const;
 
 
  const_iterator end() const;
 
 
  const_iterator cbegin() const;
 
 
  const_iterator cend() const;
 
 
  bool contains (key_type key) const;
 
 
  size_type count (key_type key) const;
 
 
  const_iterator find (key_type key) const;
 
 
  mapped_type at (key_type key) const;
 
 
  std::pair<const_iterator, const_iterator>
  equal_range (key_type key) const;
 
 
  Lock_t lock();
 
 
  std::pair<const_iterator, bool>
  emplace (key_type key, mapped_type val,
           const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  emplace (const Lock_t& lock,
           key_type key, mapped_type val,
           const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  insert_or_assign (key_type key, mapped_type val,
                    const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  insert_or_assign (const Lock_t& lock,
                    key_type key, mapped_type val,
                    const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class PAIR>
  std::pair<const_iterator, bool> insert (const PAIR& p);
 
 
  template <class InputIterator>
  void insert (InputIterator first, InputIterator last);
 
 
  bool erase (key_type key);
 
 
  bool erase (const Lock_t& lock, key_type key);
 
 
  void reserve (size_type capacity,
                const Context_t& ctx = Updater_t::defaultContext());
 
 
  void rehash (size_type capacity);
 
 
  void clear (size_t capacity,
              const Context_t& ctx = Updater_t::defaultContext());
 
 
  void clear (const Context_t& ctx = Updater_t::defaultContext());
 
 
  void forceClear();
 
 
  void quiescent (const Context_t& ctx);
 
 
  void swap (ConcurrentMap& other);
 
 
  Updater_t& updater();
 
 
private:
  static key_type keyAsKey (val_t val);
 
 
  static val_t keyAsVal (key_type k);
 
 
  static mapped_type mappedAsMapped (val_t val);
 
 
  static val_t mappedAsVal (mapped_type val);
 
 
  typename Impl_t::const_iterator get (key_type key) const;
 
 
  std::pair<const_iterator, bool>
  put (key_type key,
       mapped_type val,
       bool overwrite = true,
       const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  put (const Lock_t& lock,
       key_type key,
       mapped_type val,
       bool overwrite = true,
       const Context_t& ctx = Updater_t::defaultContext());
 
 
  Impl_t m_impl;
};
 
 
} // namespace CxxUtils
 
 
#include "CxxUtils/ConcurrentMap.icc"
 
 
#endif // not CXXUTILS_CONCURRENTMAP_H