ConcurrentPtrSet.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.
 */
 
 
#include "CxxUtils/ConcurrentHashmapImpl.h"
#include "CxxUtils/IsUpdater.h"
#include "CxxUtils/iterator_range.h"
#include "boost/iterator/iterator_facade.hpp"
#include <type_traits>
#include <ranges>
 
 
#ifndef CXXUTILS_CONCURRENTPTRSET_H
#define CXXUTILS_CONCURRENTPTRSET_H
 
 
namespace CxxUtils {
 

template <class VALUE, template <class> class UPDATER>
requires (detail::IsUpdater<UPDATER>)
class ConcurrentPtrSet
{
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 = VALUE*;
  using const_key_type = const 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;
 

  ConcurrentPtrSet (Updater_t&& updater,
                    size_type capacity = 64,
                    const Context_t& ctx = Updater_t::defaultContext());
 

  ConcurrentPtrSet (const ConcurrentPtrSet& other,
                    Updater_t&& updater,
                    size_t capacity = 64,
                    const Context_t& ctx = Updater_t::defaultContext());
 

  template <class InputIterator>
  ConcurrentPtrSet (InputIterator f,
                    InputIterator l,
                    Updater_t&& updater,
                    size_type capacity = 64,
                    const Context_t& ctx = Updater_t::defaultContext());
 

  ConcurrentPtrSet (const ConcurrentPtrSet& other) = delete;
  ConcurrentPtrSet (ConcurrentPtrSet&& other) = delete;
  ConcurrentPtrSet& operator= (const ConcurrentPtrSet& other) = delete;
  ConcurrentPtrSet& operator= (ConcurrentPtrSet&& other) = delete;
 

  ~ConcurrentPtrSet();
 

  size_type size() const;
 

  bool empty() const;
 

  size_t capacity() const;
 

  using const_iterator_value = const key_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;
 

    key_type 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 const_key_type key) const;
 

  size_type count (const const_key_type key) const;
 

  const_iterator find (const const_key_type key) const;
 

  std::pair<const_iterator, const_iterator>
  equal_range (const const_key_type key) const;
 

  Lock_t lock();
 

  std::pair<const_iterator, bool>
  emplace (const key_type key,
           const Context_t& ctx = Updater_t::defaultContext());
 

  std::pair<const_iterator, bool>
  emplace (const Lock_t& lock,
           const key_type key,
           const Context_t& ctx = Updater_t::defaultContext());
 

  std::pair<const_iterator, bool> insert (const key_type p);
 

  template <class InputIterator>
  void insert (InputIterator first, InputIterator last);
 

  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 quiescent (const Context_t& ctx);
 

  void swap (ConcurrentPtrSet& other);
 

  Updater_t& updater();
 
 
private:
  static key_type keyAsPtr (val_t val);
 

  static val_t keyAsVal (const const_key_type p);
 

  typename Impl_t::const_iterator get (const const_key_type key) const;
 

  std::pair<const_iterator, bool>
  put (const key_type key,
       const Context_t& ctx = Updater_t::defaultContext());
 

  std::pair<const_iterator, bool>
  put (const Lock_t& lock,
       const key_type key,
       const Context_t& ctx = Updater_t::defaultContext());
 

  struct Hasher
  {
    size_t operator() (const val_t p) const;
    size_t operator() (const const_key_type p) const;
    std::hash<const_key_type> m_hash;
  };
 

  struct Matcher
  {
    bool operator() (const val_t a, const val_t b) const;
  };
 

  Impl_t m_impl;
};
 
 
} // namespace CxxUtils
 
 
#include "CxxUtils/ConcurrentPtrSet.icc"
 
 
#endif // not CXXUTILS_CONCURRENTPTRSET_H