Class faabric::util::ConcurrentMap

template<class Key, class Value> class ConcurrentMap

Public Types

using key_type = typename UnderlyingMap::key_type

using mapped_type = typename UnderlyingMap::value_type

using size_type = typename UnderlyingMap::size_type

using difference_type = typename UnderlyingMap::difference_type

Public Functions

ConcurrentMap() = default

inline ConcurrentMap(size_t initialCapacity)

ConcurrentMap(const ConcurrentMap&) = delete

ConcurrentMap &operator=(const ConcurrentMap&) = delete

ConcurrentMap(ConcurrentMap&&) = default

ConcurrentMap &operator=(ConcurrentMap&&) = default

inline void swap(ConcurrentMap<Key, Value> &other)

inline bool isEmpty() const

inline size_t size() const

inline size_t capacity() const

inline void reserve(size_t count)

inline void rehash(size_t count)

inline void clear()

template<class K = Key> inline bool erase(const KeyArg<K> &key)

template<class P = std::pair<Key, Value>> inline bool insert(P &&pair)

template<class K = Key> inline bool insertOrAssign(K &&key, Value &&value)

template<class K = Key, class ...Args> inline bool tryEmplace(K &&key, Args&&... args)

template<class K = Key, class ...Args> inline std::pair<bool, Value> tryEmplaceShared(K &&key, Args&&... args) requires detail

template<class K = Key, std::invocable<const Value&> F> inline bool inspect(const KeyArg<K> &key, F inspector) const

template<class K = Key> inline std::optional<Value> get(const KeyArg<K> &key) const requires std

template<std::predicate<const Key&, const Value&> F> inline void eraseIf(F predicate)