folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator Class Reference

#include <ConcurrentHashMap.h>

Public Member Functions
const value_type &	operator* () const
const value_type *	operator-> () const
ConstIterator &	operator++ ()
bool	operator== (const ConstIterator &o) const
bool	operator!= (const ConstIterator &o) const
ConstIterator &	operator= (const ConstIterator &o)=delete
ConstIterator &	operator= (ConstIterator &&o) noexcept
	ConstIterator (const ConstIterator &o)=delete
	ConstIterator (ConstIterator &&o) noexcept
	ConstIterator (const ConcurrentHashMap *parent, uint64_t segment)

Private Member Functions
	ConstIterator (const ConcurrentHashMap *parent)
	ConstIterator (uint64_t shards)
void	next ()

Private Attributes
SegmentT::Iterator	it_
uint64_t	segment_
const ConcurrentHashMap *	parent_

Friends
class	ConcurrentHashMap

Detailed Description

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>
class folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator

Definition at line 395 of file ConcurrentHashMap.h.

Constructor & Destructor Documentation

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::ConstIterator ( const ConstIterator &  o )

delete

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator=().

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::ConstIterator ( ConstIterator &&  o )

inlinenoexcept

Definition at line 434 of file ConcurrentHashMap.h.

        : it_(std::move(o.it_)),
          segment_(std::exchange(o.segment_, uint64_t(NumShards))),
          parent_(std::exchange(o.parent_, nullptr)) {}

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::ConstIterator ( const ConcurrentHashMap *  parent, uint64_t  segment  )

inline

Definition at line 439 of file ConcurrentHashMap.h.

        : segment_(segment), parent_(parent) {}

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::ConstIterator ( const ConcurrentHashMap *  parent )

inlineexplicitprivate

Definition at line 444 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::next().

        : it_(parent->ensureSegment(0)->cbegin()),
          segment_(0),
          parent_(parent) {
      // Always iterate to the first element, could be in any shard.
      next();
    }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::ConstIterator ( uint64_t  shards )

inlineexplicitprivate

Definition at line 453 of file ConcurrentHashMap.h.

: it_(nullptr), segment_(shards) {}

Member Function Documentation

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

void folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::next ( )

inlineprivate

Definition at line 455 of file ConcurrentHashMap.h.

References folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::cend(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ensureSegment(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::it_, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::NumShards, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::parent_, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::segment_, and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::segments_.

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::ConstIterator(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::erase(), and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator++().

                {
      while (it_ == parent_->ensureSegment(segment_)->cend() &&
             segment_ < parent_->NumShards) {
        SegmentT* seg{nullptr};
        while (!seg) {
          segment_++;
          seg = parent_->segments_[segment_].load(std::memory_order_acquire);
          if (segment_ < parent_->NumShards) {
            if (!seg) {
              continue;
            }
            it_ = seg->cbegin();
          }
          break;
        }
      }
    }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

bool folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator!= ( const ConstIterator &  o ) const

inline

Definition at line 417 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator=().

                                                  {
      return !(*this == o);
    }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

const value_type& folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator* ( ) const

inline

Definition at line 399 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::it_.

                                        {
      return *it_;
    }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

ConstIterator& folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator++ ( )

inline

Definition at line 407 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::it_, and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::next().

                                {
      ++it_;
      next();
      return *this;
    }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

const value_type* folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator-> ( ) const

inline

Definition at line 403 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::it_.

                                         {
      return &*it_;
    }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

ConstIterator& folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator= ( const ConstIterator &  o )

delete

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator!=().

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

ConstIterator& folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator= ( ConstIterator &&  o )

inlinenoexcept

Definition at line 423 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::ConstIterator(), folly::exchange(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::it_, folly::gen::move, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::parent_, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::segment_, and uint64_t.

                                                         {
      if (this != &o) {
        it_ = std::move(o.it_);
        segment_ = std::exchange(o.segment_, uint64_t(NumShards));
        parent_ = std::exchange(o.parent_, nullptr);
      }
      return *this;
    }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

bool folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator== ( const ConstIterator &  o ) const

inline

Definition at line 413 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::it_, and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::segment_.

                                                  {
      return it_ == o.it_ && segment_ == o.segment_;
    }

Friends And Related Function Documentation

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

friend class ConcurrentHashMap

friend

Definition at line 397 of file ConcurrentHashMap.h.

Member Data Documentation

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

SegmentT::Iterator folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::it_

private

Definition at line 473 of file ConcurrentHashMap.h.

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::assign(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::assign_if_equal(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::erase(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::find(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::next(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator*(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator++(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator->(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator=(), and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator==().

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

const ConcurrentHashMap* folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::parent_

private

Definition at line 475 of file ConcurrentHashMap.h.

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::next(), and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator=().

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

uint64_t folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::segment_

private

Definition at line 474 of file ConcurrentHashMap.h.

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::find(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::next(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator=(), and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator==().

---

The documentation for this class was generated from the following file:

• proxygen/folly/folly/concurrency/ConcurrentHashMap.h