ConcurrentStrMap.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-2025 CERN for the benefit of the ATLAS collaboration.
 */
#ifndef CXXUTILS_CONCURRENTSTRMAP_H
#define CXXUTILS_CONCURRENTSTRMAP_H
 
 
#include "CxxUtils/ConcurrentHashmapImpl.h"
#include "CxxUtils/UIntConv.h"
#include "CxxUtils/IsUpdater.h"
#include "CxxUtils/iterator_range.h"
#include "boost/iterator/iterator_facade.hpp"
#include <type_traits>
#include <stdexcept>
 
 
namespace CxxUtils {
 
 
template <class VALUE, template <class> class UPDATER>
requires (detail::IsConcurrentHashmapPayload<VALUE> &&
          detail::IsUpdater<UPDATER>)
class ConcurrentStrMap
{
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;
  using Lock_t = typename Impl_t::Lock_t;
 
  static_assert( sizeof(typename Impl_t::val_t) >= sizeof(mapped_type) );
 
 
  ConcurrentStrMap (Updater_t&& updater,
                    size_type capacity = 64,
                    const Context_t& ctx = Updater_t::defaultContext());
 
  ConcurrentStrMap (const ConcurrentStrMap& other,
                    Updater_t&& updater,
                    size_t capacity = 64,
                    const Context_t& ctx = Updater_t::defaultContext());
 
 
  template <class InputIterator>
  ConcurrentStrMap (InputIterator f,
                    InputIterator l,
                    Updater_t&& updater,
                    size_type capacity = 64,
                    const Context_t& ctx = Updater_t::defaultContext());
 
 
  ConcurrentStrMap (const ConcurrentStrMap& other) = delete;
  ConcurrentStrMap (ConcurrentStrMap&& other) = delete;
  ConcurrentStrMap& operator= (const ConcurrentStrMap& other) = delete;
  ConcurrentStrMap& operator= (ConcurrentStrMap&& other) = delete;
 
 
  ~ConcurrentStrMap();
 
 
  size_type size() const;
 
 
  bool empty() const;
 
 
  size_t capacity() 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;
  };
 
 
  using const_iterator_range = CxxUtils::iterator_range<const_iterator>;
 
 
  const_iterator_range range() const;
 
 
  const_iterator begin() const;
 
 
  const_iterator end() const;
 
 
  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;
 
 
  mapped_type at (const std::string& key) const;
 
 
  std::pair<const_iterator, const_iterator>
  equal_range (const key_type& key) const;
 
 
  Lock_t lock();
 
 
  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 (const Lock_t& lock,
           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 Lock_t& lock,
           key_type&& key, mapped_type val,
           const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  insert_or_assign (const 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,
                    const 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,
                                          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 (ConcurrentStrMap& 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,
       mapped_type val,
       bool overwrite = true,
       const Context_t& ctx = Updater_t::defaultContext());
 
 
  std::pair<const_iterator, bool>
  put (const Lock_t& lock,
       std::unique_ptr<key_type> key,
       mapped_type val,
       bool overwrite = true,
       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/ConcurrentStrMap.icc"
 
 
#endif // not CXXUTILS_CONCURRENTSTRMAP_H