yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator > Class Template Reference

#include <fastmap.h>

Classes
class	const_iterator
class	const_reverse_iterator
class	iterator
class	reverse_iterator

Public Types
typedef Key	key_type
typedef Value	value_type

Public Member Functions
	fastmap (BitExtractor bx=BitExtractor(), Compare cmp=Compare(), ArbitraryAllocator alloc=ArbitraryAllocator())
	fastmap (std::initializer_list< std::pair< Key, Value > > array, BitExtractor bx=BitExtractor(), Compare cmp=Compare(), ArbitraryAllocator alloc=ArbitraryAllocator())
	fastmap (const fastmap &other)=delete
	fastmap (fastmap &&other) noexcept=default
std::size_t	size () const
bool	empty () const
iterator	begin ()
iterator	end ()
const_iterator	begin () const
const_iterator	end () const
const_iterator	cbegin () const
const_iterator	cend () const
reverse_iterator	rbegin ()
reverse_iterator	rend ()
const_reverse_iterator	rbegin () const
const_reverse_iterator	rend () const
const_reverse_iterator	crbegin () const
const_reverse_iterator	crend () const
iterator	find (const Key &key)
const_iterator	find (const Key &key) const
iterator	pred (const Key &key, bool strict=false)
const_iterator	pred (const Key &key, bool strict=false) const
iterator	succ (const Key &key, bool strict=false)
const_iterator	succ (const Key &key, bool strict=false) const
iterator	lower_bound (const Key &key)
const_iterator	lower_bound (const Key &key) const
iterator	upper_bound (const Key &key)
const_iterator	upper_bound (const Key &key) const
iterator::value_type &	operator[] (const Key &key)
const_iterator::value_type &	at (const Key &key) const
template<typename ... Args>
iterator	insert (const Key &key, Args ... args)
template<typename Iterator>
Iterator	erase (const Iterator &i)
bool	erase (const Key &key)
void	clear ()

Static Public Attributes
static constexpr unsigned int	KeyLength = H

Detailed Description

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>
class yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >

sorted associative container

Template Parameters

Key	key type
Value	value type
H	key length in bits
BitExtractor	helper type to provide key shifts and bit extractions
Hash	map from shifted keys to std::uintptr_t
Compare	key comparator
ArbitraryAllocator	allocator

Member Typedef Documentation

key_type

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

typedef Key yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::key_type

key type

value_type

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

typedef Value yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::value_type

value type

Member Function Documentation

at()

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

const_iterator::value_type & yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::at ( const Key & key ) const

inline

get value by key

Parameters

key

key

Returns

const reference to the value indexed by key; if not present, std::out_of_range is thrown

begin() [1/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::begin ( )

inline

Returns

mutable forward iterator pointing at the leftmost entry

begin() [2/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

const_iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::begin ( ) const

inline

Returns

const forward iterator pointing at the leftmost entry

cbegin()

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

const_iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::cbegin ( ) const

inline

Returns

const forward iterator pointing at the leftmost entry

cend()

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

const_iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::cend ( ) const

inline

Returns

const forward iterator right after the rightmost entry

clear()

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

void yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::clear ( )

inline

erase all entries

crbegin()

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

const_reverse_iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::crbegin ( ) const

inline

Returns

const reverse iterator pointing at the rightmost entry

crend()

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

const_reverse_iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::crend ( ) const

inline

Returns

const reverse iterator right after the leftmost entry

empty()

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

bool yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::empty ( ) const

inlinenodiscard

Returns

true if the container is empty otherwise false

end() [1/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::end ( )

inline

Returns

mutable forward iterator right after the rightmost entry

end() [2/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

const_iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::end ( ) const

inline

Returns

const forward iterator right after the rightmost entry

erase() [1/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

template<typename Iterator>

Iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::erase ( const Iterator & i )

inline

erase entry by iterator

Parameters

i	iterator (may be a const iterator and/or a reverse iterator)

Returns

iterator following the removed entry with respect to the iterator direction

erase() [2/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

bool yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::erase ( const Key & key )

inline

find and erase entry by key

Parameters

key	key to find and erase

Returns

true if the entry has been found and erased or false otherwise

find() [1/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::find ( const Key & key )

inline

find an entry by key

Parameters

key	key to find

Returns

iterator pointing to the entry with the key equal to key if any or end() otherwise

find() [2/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

const_iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::find ( const Key & key ) const

inline

find an entry by key

Parameters

key	key to find

Returns

const iterator pointing to the entry with the key equal to key if any or end() otherwise

insert()

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

template<typename ... Args>

iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::insert ( const Key & key, Args ... args )

inline

insert an entry, possibly replacing the existing one

Parameters

key	key to insert
args	const reference or move-reference to the value to insert

Returns

iterator pointing to the inserted entry

lower_bound() [1/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::lower_bound ( const Key & key )

inline

find a successor entry for a key

Parameters

key

key

Returns

iterator pointing to the entry with the key not less than key

lower_bound() [2/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

const_iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::lower_bound ( const Key & key ) const

inline

find a successor entry for a key

Parameters

key

key

Returns

const iterator pointing to the entry with the key not less than key

operator[]()

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

iterator::value_type & yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::operator[] ( const Key & key )

inline

get value by key

Parameters

key

key

Returns

reference to the value indexed by key; if not present, a default-constructed value is inserted

pred() [1/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::pred ( const Key & key, bool strict = false )

inline

find a predecessor entry for a key

Parameters

key	key
strict	whether an entry with the key strictly less than key should be returned

Returns

iterator pointing to the entry with the key either not greater or strictly less than key

pred() [2/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

const_iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::pred ( const Key & key, bool strict = false ) const

inline

find a predecessor entry for a key

Parameters

key	key
strict	whether an entry with the key strictly less than key should be returned

Returns

const iterator pointing to the entry with the key either not greater or strictly less than key

rbegin() [1/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

reverse_iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::rbegin ( )

inline

Returns

mutable reverse iterator pointing at the rightmost entry

rbegin() [2/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

const_reverse_iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::rbegin ( ) const

inline

Returns

const reverse iterator pointing at the rightmost entry

rend() [1/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

reverse_iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::rend ( )

inline

Returns

mutable reverse iterator right after the leftmost entry

rend() [2/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

const_reverse_iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::rend ( ) const

inline

Returns

const reverse iterator right after the leftmost entry

size()

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

std::size_t yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::size ( ) const

inlinenodiscard

Returns

the number of entries in the container

succ() [1/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::succ ( const Key & key, bool strict = false )

inline

find a successor entry for a key

Parameters

key	key
strict	whether an entry with the key strictly greater than key should be returned

Returns

iterator pointing to the entry with the key either not less or strictly greater than key

succ() [2/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

const_iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::succ ( const Key & key, bool strict = false ) const

inline

find a successor entry for a key

Parameters

key	key
strict	whether an entry with the key strictly greater than key should be returned

Returns

const iterator pointing to the entry with the key either not less or strictly greater than key

upper_bound() [1/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::upper_bound ( const Key & key )

inline

find a successor entry for a key

Parameters

key

key

Returns

iterator pointing to the entry with the key strictly greater than key

upper_bound() [2/2]

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

const_iterator yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::upper_bound ( const Key & key ) const

inline

find a successor entry for a key

Parameters

key

key

Returns

const iterator pointing to the entry with the key strictly greater than key

Member Data Documentation

KeyLength

template<typename Key, typename Value, unsigned int H, internal::BitExtractorGeneric< Key > BitExtractor = internal::BitExtractor<Key>, internal::MapGeneric< typename BitExtractor::ShiftResult, std::uintptr_t > Hash = internal::DefaultHash<typename BitExtractor::ShiftResult, std::uintptr_t>, typename Compare = std::less<Key>, typename ArbitraryAllocator = std::allocator<std::pair<Key, Value>>>

unsigned int yfast::fastmap< Key, Value, H, BitExtractor, Hash, Compare, ArbitraryAllocator >::KeyLength = H

staticconstexpr

key length in bits

---

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

• include/yfast/fastmap.h