File concurrent_map.h

namespace faabric

namespace util

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)

Private Types

using UnderlyingMap = typename absl::flat_hash_map<Key, Value>

template<class T> using KeyArg = typename UnderlyingMap::template key_arg<T>

Private Members

mutable std::shared_mutex mutex

UnderlyingMap map

namespace detail

template<typename> struct is_shared_ptr : public false_type

template<typename Pointee> struct is_shared_ptr<std::shared_ptr<Pointee>> : public true_type