ConcurrentToValMap.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_CONCURRENTTOVALMAP_H
#define CXXUTILS_CONCURRENTTOVALMAP_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 <memory>
#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>
ATH_REQUIRES (detail::IsConcurrentHashmapPayload<KEY> &&
              detail::IsUpdater<UPDATER> && 
              detail::IsHash<HASHER, KEY> &&
              detail::IsBinaryPredicate<MATCHER, KEY>)
class ConcurrentToValMap
{
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>;
 
 
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;
 
 
  ConcurrentToValMap (Updater_t&& updater,
                      size_type capacity = 64,
                      const Context_t& ctx = Updater_t::defaultContext());
 
 
  ConcurrentToValMap (const ConcurrentToValMap& other,
                      Updater_t&& updater,
                      size_t capacity = 64,
                      const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class InputIterator>
  ConcurrentToValMap (InputIterator f,
                      InputIterator l,
                      Updater_t&& updater,
                      size_type capacity = 64,
                      const Context_t& ctx = Updater_t::defaultContext());
 
 
  ConcurrentToValMap (const ConcurrentToValMap& other) = delete;
  ConcurrentToValMap (ConcurrentToValMap&& other) = delete;
  ConcurrentToValMap& operator= (const ConcurrentToValMap& other) = delete;
  ConcurrentToValMap& operator= (ConcurrentToValMap&& other) = delete;
 
 
  ~ConcurrentToValMap();
 
 
  size_type size() const;
 
 
  bool empty() const;
 
 
  size_t capacity() const;
 
 
  using const_iterator_value = std::pair<const key_type, const mapped_type&>;
  using iterator_value = std::pair<const key_type, mapped_type&>;
 
  class const_iterator;
  class iterator;
 
 
  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);
 
 
    const_iterator (const iterator& other);
 
 
    bool valid() const;
 
 
  private:
    friend class boost::iterator_core_access;
    friend class iterator;
 
 
    void increment();
 
 
    void decrement();
 
 
    bool equal (const const_iterator& other) const;
 
 
    bool equal (const iterator& other) const;
 
 
    const const_iterator_value dereference() const;
 
 
    typename Impl_t::const_iterator m_impl;
  };
 
 
  class iterator
    : public boost::iterator_facade<iterator,
                                    const iterator_value,
                                    std::bidirectional_iterator_tag,
                                    const iterator_value>
  {
  public:
    iterator (typename Impl_t::const_iterator it);
 
 
    bool valid() const;
 
 
  private:
    friend class boost::iterator_core_access;
    friend class const_iterator;
 
 
    void increment();
 
 
    void decrement();
 
 
    bool equal (const iterator& other) const;
 
 
    bool equal (const const_iterator& other) const;
 
 
    const iterator_value dereference() const;
 
 
    typename Impl_t::const_iterator m_impl;
  };
 
 
  typedef boost::iterator_range<const_iterator> const_iterator_range;
  typedef boost::iterator_range<iterator> iterator_range;
 
 
  const_iterator_range range() const;
 
 
  iterator_range range();
 
 
  const_iterator begin() const;
 
 
  const_iterator end() const;
 
 
  iterator begin();
 
 
  iterator end();
 
 
  const_iterator cbegin() const;
 
 
  const_iterator cend() const;
 
 
  bool contains (const key_type key) const;
 
 
  size_type count (const key_type key) const;
 
 
  const_iterator find (const key_type key) const;
 
 
  iterator find (const key_type key);
 
 
  const mapped_type& at (const key_type key) const;
 
 
  mapped_type& at (const key_type key);
 
 
  std::pair<const_iterator, const_iterator>
  equal_range (const key_type key) const;
 
 
  std::pair<iterator, iterator>
  equal_range (const key_type key);
 
 
  std::pair<const_iterator, bool>
  emplace (key_type key, const mapped_type& val,
           const Context_t& ctx = Updater_t::defaultContext());
 
 
  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 (key_type key, std::unique_ptr<mapped_type> val,
           const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class PAIR>
  std::pair<const_iterator, bool> insert (const PAIR& p,
                                          const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class PAIR>
  std::pair<const_iterator, bool> insert (PAIR&& p,
                                          const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class InputIterator>
  void insert (InputIterator first, InputIterator last,
               const Context_t& ctx = Updater_t::defaultContext());
 
 
  void reserve (size_type capacity,
                const Context_t& ctx = Updater_t::defaultContext());
 
 
  void rehash (size_type capacity);
 
 
  void quiescent (const Context_t& ctx);
 
 
  void swap (ConcurrentToValMap& 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 (const key_type key) const;
 
 
  std::pair<const_iterator, bool>
  put (const key_type key,
       std::unique_ptr<mapped_type> val,
       const Context_t& ctx = Updater_t::defaultContext());
 
 
  Impl_t m_impl;
};
 
 
} // namespace CxxUtils
 
 
#include "CxxUtils/ConcurrentToValMap.icc"
 
 
#endif // not CXXUTILS_CONCURRENTTOVALMAP_H