ConcurrentStrToValMap.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_CONCURRENTSTRTOVALMAP_H
#define CXXUTILS_CONCURRENTSTRTOVALMAP_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 VALUE, template <class> class UPDATER>
ATH_REQUIRES (detail::IsUpdater<UPDATER>)
class ConcurrentStrToValMap
{
private:
  struct Hasher;
  struct Matcher;
  using Impl_t = typename detail::ConcurrentHashmapImpl<UPDATER, Hasher, Matcher>;
  using val_t = CxxUtils::detail::ConcurrentHashmapVal_t;
 
 
public:
  using key_type = std::string;
  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;
 
 
  ConcurrentStrToValMap (Updater_t&& updater,
                         size_type capacity = 64,
                         const Context_t& ctx = Updater_t::defaultContext());
 
 
  ConcurrentStrToValMap (const ConcurrentStrToValMap& other,
                         Updater_t&& updater,
                         size_t capacity = 64,
                         const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class InputIterator>
  ConcurrentStrToValMap (InputIterator f,
                         InputIterator l,
                         Updater_t&& updater,
                         size_type capacity = 64,
                         const Context_t& ctx = Updater_t::defaultContext());
 
 
  ConcurrentStrToValMap (const ConcurrentStrToValMap& other) = delete;
  ConcurrentStrToValMap (ConcurrentStrToValMap&& other) = delete;
  ConcurrentStrToValMap& operator= (const ConcurrentStrToValMap& other) = delete;
  ConcurrentStrToValMap& operator= (ConcurrentStrToValMap&& other) = delete;
 
 
  ~ConcurrentStrToValMap();
 
 
  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 (const key_type& key, const mapped_type& val,
           const Context_t& ctx = Updater_t::defaultContext());
 
 
  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 (const key_type& key, 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 (const key_type& key, std::unique_ptr<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 (ConcurrentStrToValMap& other);
 
 
  Updater_t& updater();
 
 
private:
  static const std::string* keyAsString (val_t val);
 
 
  static val_t keyAsVal (const std::string* s);
 
 
  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 (std::unique_ptr<key_type> key,
       std::unique_ptr<mapped_type> val,
       const Context_t& ctx = Updater_t::defaultContext());
 
 
  struct Hasher
  {
    size_t operator() (const val_t p) const;
    size_t operator() (const std::string& s) const;
    std::hash<std::string> m_hash;
  };
 
 
  struct Matcher
  {
    bool operator() (const val_t a, const val_t b) const;
  };
 
 
  Impl_t m_impl;
};
 
 
} // namespace CxxUtils
 
 
#include "CxxUtils/ConcurrentStrToValMap.icc"
 
 
#endif // not CXXUTILS_CONCURRENTSTRTOVALMAP_H