Associative container where each element is also indexed by time. More...

#include <aged_unordered_container.h>

Collaboration diagram for beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >:

[legend]

Classes
class	Buckets

class	chronological_t

class	config_t

struct	element

class	KeyValueEqual

class	ValueHash

Public Types
using	clock_type = abstract_clock< Clock >

using	time_point = typename clock_type::time_point

using	duration = typename clock_type::duration

using	key_type = Key

using	mapped_type = T

using	value_type = typename std::conditional< IsMap, std::pair< Key const, T >, Key >::type

using	size_type = std::size_t

using	difference_type = std::ptrdiff_t

using	is_unordered = std::true_type

using	is_multi = std::integral_constant< bool, IsMulti >

using	is_map = std::integral_constant< bool, IsMap >

using	hasher = Hash

using	key_equal = KeyEqual

using	allocator_type = Allocator

using	reference = value_type &

using	const_reference = value_type const &

using	pointer = typename std::allocator_traits< Allocator >::pointer

using	const_pointer = typename std::allocator_traits< Allocator >::const_pointer

using	iterator = beast::detail::aged_container_iterator<!IsMap, typename cont_type::iterator >

using	const_iterator = beast::detail::aged_container_iterator< true, typename cont_type::iterator >

using	local_iterator = beast::detail::aged_container_iterator<!IsMap, typename cont_type::local_iterator >

using	const_local_iterator = beast::detail::aged_container_iterator< true, typename cont_type::local_iterator >

Public Member Functions
	aged_unordered_container ()=delete

	aged_unordered_container (clock_type &clock)

	aged_unordered_container (clock_type &clock, Hash const &hash)

	aged_unordered_container (clock_type &clock, KeyEqual const &key_eq)

	aged_unordered_container (clock_type &clock, Allocator const &alloc)

	aged_unordered_container (clock_type &clock, Hash const &hash, KeyEqual const &key_eq)

	aged_unordered_container (clock_type &clock, Hash const &hash, Allocator const &alloc)

	aged_unordered_container (clock_type &clock, KeyEqual const &key_eq, Allocator const &alloc)

	aged_unordered_container (clock_type &clock, Hash const &hash, KeyEqual const &key_eq, Allocator const &alloc)

template<class InputIt >
	aged_unordered_container (InputIt first, InputIt last, clock_type &clock)

template<class InputIt >
	aged_unordered_container (InputIt first, InputIt last, clock_type &clock, Hash const &hash)

template<class InputIt >
	aged_unordered_container (InputIt first, InputIt last, clock_type &clock, KeyEqual const &key_eq)

template<class InputIt >
	aged_unordered_container (InputIt first, InputIt last, clock_type &clock, Allocator const &alloc)

template<class InputIt >
	aged_unordered_container (InputIt first, InputIt last, clock_type &clock, Hash const &hash, KeyEqual const &key_eq)

template<class InputIt >
	aged_unordered_container (InputIt first, InputIt last, clock_type &clock, Hash const &hash, Allocator const &alloc)

template<class InputIt >
	aged_unordered_container (InputIt first, InputIt last, clock_type &clock, KeyEqual const &key_eq, Allocator const &alloc)

template<class InputIt >
	aged_unordered_container (InputIt first, InputIt last, clock_type &clock, Hash const &hash, KeyEqual const &key_eq, Allocator const &alloc)

	aged_unordered_container (aged_unordered_container const &other)

	aged_unordered_container (aged_unordered_container const &other, Allocator const &alloc)

	aged_unordered_container (aged_unordered_container &&other)

	aged_unordered_container (aged_unordered_container &&other, Allocator const &alloc)

	aged_unordered_container (std::initializer_list< value_type > init, clock_type &clock)

	aged_unordered_container (std::initializer_list< value_type > init, clock_type &clock, Hash const &hash)

	aged_unordered_container (std::initializer_list< value_type > init, clock_type &clock, KeyEqual const &key_eq)

	aged_unordered_container (std::initializer_list< value_type > init, clock_type &clock, Allocator const &alloc)

	aged_unordered_container (std::initializer_list< value_type > init, clock_type &clock, Hash const &hash, KeyEqual const &key_eq)

	aged_unordered_container (std::initializer_list< value_type > init, clock_type &clock, Hash const &hash, Allocator const &alloc)

	aged_unordered_container (std::initializer_list< value_type > init, clock_type &clock, KeyEqual const &key_eq, Allocator const &alloc)

	aged_unordered_container (std::initializer_list< value_type > init, clock_type &clock, Hash const &hash, KeyEqual const &key_eq, Allocator const &alloc)

	~aged_unordered_container ()

aged_unordered_container &	operator= (aged_unordered_container const &other)

aged_unordered_container &	operator= (aged_unordered_container &&other)

aged_unordered_container &	operator= (std::initializer_list< value_type > init)

allocator_type	get_allocator () const

clock_type &	clock ()

clock_type const &	clock () const

template<class K , bool maybe_multi = IsMulti, bool maybe_map = IsMap, class = typename std::enable_if<maybe_map && !maybe_multi>::type>
std::conditional< IsMap, T, void * >::type &	at (K const &k)

template<class K , bool maybe_multi = IsMulti, bool maybe_map = IsMap, class = typename std::enable_if<maybe_map && !maybe_multi>::type>
std::conditional< IsMap, T, void * >::type const &	at (K const &k) const

template<bool maybe_multi = IsMulti, bool maybe_map = IsMap, class = typename std::enable_if<maybe_map && !maybe_multi>::type>
std::conditional< IsMap, T, void * >::type &	operator[] (Key const &key)

template<bool maybe_multi = IsMulti, bool maybe_map = IsMap, class = typename std::enable_if<maybe_map && !maybe_multi>::type>
std::conditional< IsMap, T, void * >::type &	operator[] (Key &&key)

iterator	begin ()

const_iterator	begin () const

const_iterator	cbegin () const

iterator	end ()

const_iterator	end () const

const_iterator	cend () const

iterator	iterator_to (value_type &value)

const_iterator	iterator_to (value_type const &value) const

bool	empty () const noexcept

size_type	size () const noexcept

size_type	max_size () const noexcept

void	clear ()

template<bool maybe_multi = IsMulti>
auto	insert (value_type const &value) -> typename std::enable_if<!maybe_multi, std::pair< iterator, bool > >::type

template<bool maybe_multi = IsMulti>
auto	insert (value_type const &value) -> typename std::enable_if< maybe_multi, iterator >::type

template<bool maybe_multi = IsMulti, bool maybe_map = IsMap>
auto	insert (value_type &&value) -> typename std::enable_if< !maybe_multi &&!maybe_map, std::pair< iterator, bool > >::type

template<bool maybe_multi = IsMulti, bool maybe_map = IsMap>
auto	insert (value_type &&value) -> typename std::enable_if< maybe_multi &&!maybe_map, iterator >::type

template<bool maybe_multi = IsMulti>
std::enable_if<!maybe_multi, iterator >::type	insert (const_iterator, value_type const &value)

template<bool maybe_multi = IsMulti>
std::enable_if< maybe_multi, iterator >::type	insert (const_iterator, value_type const &value)

template<bool maybe_multi = IsMulti>
std::enable_if<!maybe_multi, iterator >::type	insert (const_iterator, value_type &&value)

template<bool maybe_multi = IsMulti>
std::enable_if< maybe_multi, iterator >::type	insert (const_iterator, value_type &&value)

template<class P , bool maybe_map = IsMap>
std::enable_if< maybe_map &&std::is_constructible< value_type, P && >::value, typenamestd::conditional< IsMulti, iterator, std::pair< iterator, bool > >::type >::type	insert (P &&value)

template<class P , bool maybe_map = IsMap>
std::enable_if< maybe_map &&std::is_constructible< value_type, P && >::value, typenamestd::conditional< IsMulti, iterator, std::pair< iterator, bool > >::type >::type	insert (const_iterator hint, P &&value)

template<class InputIt >
void	insert (InputIt first, InputIt last)

void	insert (std::initializer_list< value_type > init)

template<bool maybe_multi = IsMulti, class... Args>
auto	emplace (Args &&... args) -> typename std::enable_if<!maybe_multi, std::pair< iterator, bool > >::type

template<bool maybe_multi = IsMulti, class... Args>
auto	emplace (Args &&... args) -> typename std::enable_if< maybe_multi, iterator >::type

template<bool maybe_multi = IsMulti, class... Args>
auto	emplace_hint (const_iterator, Args &&... args) -> typename std::enable_if<!maybe_multi, std::pair< iterator, bool > >::type

template<bool maybe_multi = IsMulti, class... Args>
std::enable_if< maybe_multi, iterator >::type	emplace_hint (const_iterator, Args &&... args)

template<bool is_const, class Iterator >
beast::detail::aged_container_iterator< false, Iterator >	erase (beast::detail::aged_container_iterator< is_const, Iterator > pos)

template<bool is_const, class Iterator >
beast::detail::aged_container_iterator< false, Iterator >	erase (beast::detail::aged_container_iterator< is_const, Iterator > first, beast::detail::aged_container_iterator< is_const, Iterator > last)

template<class K >
auto	erase (K const &k) -> size_type

void	swap (aged_unordered_container &other) noexcept

template<bool is_const, class Iterator >
void	touch (beast::detail::aged_container_iterator< is_const, Iterator > pos)

template<class K >
auto	touch (K const &k) -> size_type

template<class K >
size_type	count (K const &k) const

template<class K >
iterator	find (K const &k)

template<class K >
const_iterator	find (K const &k) const

template<class K >
std::pair< iterator, iterator >	equal_range (K const &k)

template<class K >
std::pair< const_iterator, const_iterator >	equal_range (K const &k) const

local_iterator	begin (size_type n)

const_local_iterator	begin (size_type n) const

const_local_iterator	cbegin (size_type n) const

local_iterator	end (size_type n)

const_local_iterator	end (size_type n) const

const_local_iterator	cend (size_type n) const

size_type	bucket_count () const

size_type	max_bucket_count () const

size_type	bucket_size (size_type n) const

size_type	bucket (Key const &k) const

float	load_factor () const

float	max_load_factor () const

void	max_load_factor (float ml)

void	rehash (size_type count)

void	reserve (size_type count)

hasher const &	hash_function () const

key_equal const &	key_eq () const

template<bool OtherIsMap, class OtherKey , class OtherT , class OtherDuration , class OtherHash , class OtherAllocator , bool maybe_multi = IsMulti>
std::enable_if<!maybe_multi, bool >::type	operator== (aged_unordered_container< false, OtherIsMap, OtherKey, OtherT, OtherDuration, OtherHash, KeyEqual, OtherAllocator > const &other) const

template<bool OtherIsMap, class OtherKey , class OtherT , class OtherDuration , class OtherHash , class OtherAllocator , bool maybe_multi = IsMulti>
std::enable_if< maybe_multi, bool >::type	operator== (aged_unordered_container< true, OtherIsMap, OtherKey, OtherT, OtherDuration, OtherHash, KeyEqual, OtherAllocator > const &other) const

template<bool OtherIsMulti, bool OtherIsMap, class OtherKey , class OtherT , class OtherDuration , class OtherHash , class OtherAllocator >
bool	operator!= (aged_unordered_container< OtherIsMulti, OtherIsMap, OtherKey, OtherT, OtherDuration, OtherHash, KeyEqual, OtherAllocator > const &other) const

template<class K , bool maybe_multi, bool maybe_map, class >
std::conditional< IsMap, T, void * >::type const &	at (K const &k) const

Public Attributes
class beast::detail::aged_unordered_container::chronological_t	chronological

Private Types
using	list_type = typename boost::intrusive::make_list< element, boost::intrusive::constant_time_size< false > >::type

using	cont_type = typename std::conditional< IsMulti, typename boost::intrusive::make_unordered_multiset< element, boost::intrusive::constant_time_size< true >, boost::intrusive::hash< ValueHash >, boost::intrusive::equal< KeyValueEqual >, boost::intrusive::cache_begin< true > >::type, typename boost::intrusive::make_unordered_set< element, boost::intrusive::constant_time_size< true >, boost::intrusive::hash< ValueHash >, boost::intrusive::equal< KeyValueEqual >, boost::intrusive::cache_begin< true > >::type >::type

using	bucket_type = typename cont_type::bucket_type

using	bucket_traits = typename cont_type::bucket_traits

using	ElementAllocator = typename std::allocator_traits< Allocator >::template rebind_alloc< element >

using	ElementAllocatorTraits = std::allocator_traits< ElementAllocator >

using	BucketAllocator = typename std::allocator_traits< Allocator >::template rebind_alloc< element >

using	BucketAllocatorTraits = std::allocator_traits< BucketAllocator >

Private Member Functions
template<class... Args>
element *	new_element (Args &&... args)

void	delete_element (element const *p)

void	unlink_and_delete_element (element const *p)

bool	would_exceed (size_type additional) const

void	maybe_rehash (size_type additional)

template<bool maybe_multi = IsMulti>
auto	insert_unchecked (value_type const &value) -> typename std::enable_if<!maybe_multi, std::pair< iterator, bool > >::type

template<bool maybe_multi = IsMulti>
auto	insert_unchecked (value_type const &value) -> typename std::enable_if< maybe_multi, iterator >::type

template<class InputIt >
void	insert_unchecked (InputIt first, InputIt last)

template<class InputIt >
void	insert (InputIt first, InputIt last, std::input_iterator_tag)

template<class InputIt >
void	insert (InputIt first, InputIt last, std::random_access_iterator_tag)

template<bool is_const, class Iterator >
void	touch (beast::detail::aged_container_iterator< is_const, Iterator > pos, typename clock_type::time_point const &now)

template<bool maybe_propagate = std::allocator_traits< Allocator>::propagate_on_container_swap::value>
std::enable_if< maybe_propagate >::type	swap_data (aged_unordered_container &other) noexcept

template<bool maybe_propagate = std::allocator_traits< Allocator>::propagate_on_container_swap::value>
std::enable_if<!maybe_propagate >::type	swap_data (aged_unordered_container &other) noexcept

Static Private Member Functions
static Key const &	extract (value_type const &value)

Private Attributes
config_t	m_config

Buckets	m_buck

cont_type	m_cont

Detailed Description

template<bool IsMulti, bool IsMap, class Key, class T, class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>
class beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >

Associative container where each element is also indexed by time.

This container mirrors the interface of the standard library unordered associative containers, with the addition that each element is associated with a when time_point which is obtained from the value of the clock's now. The function touch updates the time for an element to the current time as reported by the clock.

An extra set of iterator types and member functions are provided in the chronological memberspace that allow traversal in temporal or reverse temporal order. This container is useful as a building block for caches whose items expire after a certain amount of time. The chronological iterators allow for fully customizable expiration strategies.

See also: aged_unordered_set, aged_unordered_multiset; aged_unordered_map, aged_unordered_multimap

Definition at line 87 of file aged_unordered_container.h.

Member Typedef Documentation

◆ clock_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::clock_type = abstract_clock<Clock>

Definition at line 90 of file aged_unordered_container.h.

◆ time_point

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::time_point = typename clock_type::time_point

Definition at line 91 of file aged_unordered_container.h.

◆ duration

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::duration = typename clock_type::duration

Definition at line 92 of file aged_unordered_container.h.

◆ key_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::key_type = Key

Definition at line 93 of file aged_unordered_container.h.

◆ mapped_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::mapped_type = T

Definition at line 94 of file aged_unordered_container.h.

◆ value_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::value_type = typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type

Definition at line 95 of file aged_unordered_container.h.

◆ size_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::size_type = std::size_t

Definition at line 97 of file aged_unordered_container.h.

◆ difference_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::difference_type = std::ptrdiff_t

Definition at line 98 of file aged_unordered_container.h.

◆ is_unordered

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::is_unordered = std::true_type

Definition at line 101 of file aged_unordered_container.h.

◆ is_multi

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::is_multi = std::integral_constant<bool, IsMulti>

Definition at line 102 of file aged_unordered_container.h.

◆ is_map

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::is_map = std::integral_constant<bool, IsMap>

Definition at line 103 of file aged_unordered_container.h.

◆ list_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::list_type = typename boost::intrusive:: make_list<element, boost::intrusive::constant_time_size<false> >::type

private

Definition at line 234 of file aged_unordered_container.h.

◆ cont_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::cont_type = typename std::conditional< IsMulti, typename boost::intrusive::make_unordered_multiset< element, boost::intrusive::constant_time_size<true>, boost::intrusive::hash<ValueHash>, boost::intrusive::equal<KeyValueEqual>, boost::intrusive::cache_begin<true> >::type, typename boost::intrusive::make_unordered_set< element, boost::intrusive::constant_time_size<true>, boost::intrusive::hash<ValueHash>, boost::intrusive::equal<KeyValueEqual>, boost::intrusive::cache_begin<true> >::type>::type

private

Definition at line 237 of file aged_unordered_container.h.

◆ bucket_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::bucket_type = typename cont_type::bucket_type

private

Definition at line 252 of file aged_unordered_container.h.

◆ bucket_traits

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::bucket_traits = typename cont_type::bucket_traits

private

Definition at line 253 of file aged_unordered_container.h.

◆ ElementAllocator

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::ElementAllocator = typename std::allocator_traits< Allocator>::template rebind_alloc<element>

private

Definition at line 255 of file aged_unordered_container.h.

◆ ElementAllocatorTraits

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::ElementAllocatorTraits = std::allocator_traits<ElementAllocator>

private

Definition at line 258 of file aged_unordered_container.h.

◆ BucketAllocator

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::BucketAllocator = typename std::allocator_traits< Allocator>::template rebind_alloc<element>

private

Definition at line 260 of file aged_unordered_container.h.

◆ BucketAllocatorTraits

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::BucketAllocatorTraits = std::allocator_traits<BucketAllocator>

private

Definition at line 263 of file aged_unordered_container.h.

◆ hasher

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::hasher = Hash

Definition at line 586 of file aged_unordered_container.h.

◆ key_equal

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::key_equal = KeyEqual

Definition at line 587 of file aged_unordered_container.h.

◆ allocator_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::allocator_type = Allocator

Definition at line 588 of file aged_unordered_container.h.

◆ reference

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::reference = value_type&

Definition at line 589 of file aged_unordered_container.h.

◆ const_reference

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::const_reference = value_type const&

Definition at line 590 of file aged_unordered_container.h.

◆ pointer

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::pointer = typename std::allocator_traits<Allocator>::pointer

Definition at line 591 of file aged_unordered_container.h.

◆ const_pointer

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::const_pointer = typename std::allocator_traits<Allocator>::const_pointer

Definition at line 592 of file aged_unordered_container.h.

◆ iterator

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::iterator = beast::detail:: aged_container_iterator<!IsMap, typename cont_type::iterator>

Definition at line 597 of file aged_unordered_container.h.

◆ const_iterator

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::const_iterator = beast::detail:: aged_container_iterator<true, typename cont_type::iterator>

Definition at line 599 of file aged_unordered_container.h.

◆ local_iterator

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::local_iterator = beast::detail:: aged_container_iterator<!IsMap, typename cont_type::local_iterator>

Definition at line 602 of file aged_unordered_container.h.

◆ const_local_iterator

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::const_local_iterator = beast::detail:: aged_container_iterator<true, typename cont_type::local_iterator>

Definition at line 604 of file aged_unordered_container.h.

Constructor & Destructor Documentation

◆ aged_unordered_container() [1/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container ( )

delete

◆ aged_unordered_container() [2/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container ( clock_type & clock )

explicit

Definition at line 1580 of file aged_unordered_container.h.

◆ aged_unordered_container() [3/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	clock_type &	clock,
		Hash const &	hash
	)

Definition at line 1606 of file aged_unordered_container.h.

◆ aged_unordered_container() [4/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	clock_type &	clock,
		KeyEqual const &	key_eq
	)

Definition at line 1632 of file aged_unordered_container.h.

◆ aged_unordered_container() [5/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	clock_type &	clock,
		Allocator const &	alloc
	)

Definition at line 1659 of file aged_unordered_container.h.

◆ aged_unordered_container() [6/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	clock_type &	clock,
		Hash const &	hash,
		KeyEqual const &	key_eq
	)

Definition at line 1687 of file aged_unordered_container.h.

◆ aged_unordered_container() [7/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	clock_type &	clock,
		Hash const &	hash,
		Allocator const &	alloc
	)

Definition at line 1717 of file aged_unordered_container.h.

◆ aged_unordered_container() [8/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	clock_type &	clock,
		KeyEqual const &	key_eq,
		Allocator const &	alloc
	)

Definition at line 1748 of file aged_unordered_container.h.

◆ aged_unordered_container() [9/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	clock_type &	clock,
		Hash const &	hash,
		KeyEqual const &	key_eq,
		Allocator const &	alloc
	)

Definition at line 1779 of file aged_unordered_container.h.

◆ aged_unordered_container() [10/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<class InputIt >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	InputIt	first,
		InputIt	last,
		clock_type &	clock
	)

Definition at line 1812 of file aged_unordered_container.h.

◆ aged_unordered_container() [11/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<class InputIt >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	InputIt	first,
		InputIt	last,
		clock_type &	clock,
		Hash const &	hash
	)

Definition at line 1841 of file aged_unordered_container.h.

◆ aged_unordered_container() [12/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<class InputIt >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	InputIt	first,
		InputIt	last,
		clock_type &	clock,
		KeyEqual const &	key_eq
	)

Definition at line 1874 of file aged_unordered_container.h.

◆ aged_unordered_container() [13/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<class InputIt >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	InputIt	first,
		InputIt	last,
		clock_type &	clock,
		Allocator const &	alloc
	)

Definition at line 1907 of file aged_unordered_container.h.

◆ aged_unordered_container() [14/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<class InputIt >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	InputIt	first,
		InputIt	last,
		clock_type &	clock,
		Hash const &	hash,
		KeyEqual const &	key_eq
	)

Definition at line 1941 of file aged_unordered_container.h.

◆ aged_unordered_container() [15/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<class InputIt >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	InputIt	first,
		InputIt	last,
		clock_type &	clock,
		Hash const &	hash,
		Allocator const &	alloc
	)

Definition at line 1975 of file aged_unordered_container.h.

◆ aged_unordered_container() [16/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<class InputIt >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	InputIt	first,
		InputIt	last,
		clock_type &	clock,
		KeyEqual const &	key_eq,
		Allocator const &	alloc
	)

Definition at line 2010 of file aged_unordered_container.h.

◆ aged_unordered_container() [17/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<class InputIt >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	InputIt	first,
		InputIt	last,
		clock_type &	clock,
		Hash const &	hash,
		KeyEqual const &	key_eq,
		Allocator const &	alloc
	)

Definition at line 2045 of file aged_unordered_container.h.

◆ aged_unordered_container() [18/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container ( aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > const & other )

Definition at line 2080 of file aged_unordered_container.h.

◆ aged_unordered_container() [19/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > const &	other,
		Allocator const &	alloc
	)

Definition at line 2108 of file aged_unordered_container.h.

◆ aged_unordered_container() [20/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container ( aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > && other )

Definition at line 2139 of file aged_unordered_container.h.

◆ aged_unordered_container() [21/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > &&	other,
		Allocator const &	alloc
	)

Definition at line 2164 of file aged_unordered_container.h.

◆ aged_unordered_container() [22/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	std::initializer_list< value_type >	init,
		clock_type &	clock
	)

Definition at line 2196 of file aged_unordered_container.h.

◆ aged_unordered_container() [23/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	std::initializer_list< value_type >	init,
		clock_type &	clock,
		Hash const &	hash
	)

Definition at line 2226 of file aged_unordered_container.h.

◆ aged_unordered_container() [24/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	std::initializer_list< value_type >	init,
		clock_type &	clock,
		KeyEqual const &	key_eq
	)

Definition at line 2257 of file aged_unordered_container.h.

◆ aged_unordered_container() [25/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	std::initializer_list< value_type >	init,
		clock_type &	clock,
		Allocator const &	alloc
	)

Definition at line 2288 of file aged_unordered_container.h.

◆ aged_unordered_container() [26/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	std::initializer_list< value_type >	init,
		clock_type &	clock,
		Hash const &	hash,
		KeyEqual const &	key_eq
	)

Definition at line 2320 of file aged_unordered_container.h.

◆ aged_unordered_container() [27/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	std::initializer_list< value_type >	init,
		clock_type &	clock,
		Hash const &	hash,
		Allocator const &	alloc
	)

Definition at line 2352 of file aged_unordered_container.h.

◆ aged_unordered_container() [28/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	std::initializer_list< value_type >	init,
		clock_type &	clock,
		KeyEqual const &	key_eq,
		Allocator const &	alloc
	)

Definition at line 2385 of file aged_unordered_container.h.

◆ aged_unordered_container() [29/29]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::aged_unordered_container	(	std::initializer_list< value_type >	init,
		clock_type &	clock,
		Hash const &	hash,
		KeyEqual const &	key_eq,
		Allocator const &	alloc
	)

Definition at line 2418 of file aged_unordered_container.h.

◆ ~aged_unordered_container()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::~aged_unordered_container ( )

Definition at line 2452 of file aged_unordered_container.h.

Member Function Documentation

◆ extract()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

static Key const & beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::extract ( value_type const & value )

staticprivate

Definition at line 107 of file aged_unordered_container.h.

◆ new_element()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class... Args>

element * beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::new_element ( Args &&... args )

private

Definition at line 542 of file aged_unordered_container.h.

◆ delete_element()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

void beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::delete_element ( element const * p )

private

Definition at line 570 of file aged_unordered_container.h.

◆ unlink_and_delete_element()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

void beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::unlink_and_delete_element ( element const * p )

private

Definition at line 578 of file aged_unordered_container.h.

◆ operator=() [1/3]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

auto beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::operator= ( aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > const & other )

Definition at line 2475 of file aged_unordered_container.h.

◆ operator=() [2/3]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

auto beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::operator= ( aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > && other )

Definition at line 2508 of file aged_unordered_container.h.

◆ operator=() [3/3]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

auto beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::operator= ( std::initializer_list< value_type > init )

Definition at line 2539 of file aged_unordered_container.h.

◆ get_allocator()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

allocator_type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::get_allocator ( ) const

Definition at line 899 of file aged_unordered_container.h.

◆ clock() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

clock_type & beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::clock ( )

Definition at line 905 of file aged_unordered_container.h.

◆ clock() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

clock_type const & beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::clock ( ) const

Definition at line 911 of file aged_unordered_container.h.

◆ at() [1/3]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<class K , bool maybe_multi, bool maybe_map, class >

std::conditional< IsMap, T, void * >::type & beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::at ( K const & k )

Definition at line 2568 of file aged_unordered_container.h.

◆ at() [2/3]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class K , bool maybe_multi = IsMulti, bool maybe_map = IsMap, class = typename std::enable_if<maybe_map && !maybe_multi>::type>

std::conditional< IsMap, T, void * >::type const & beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::at ( K const & k ) const

◆ operator[]() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<bool maybe_multi, bool maybe_map, class >

std::conditional< IsMap, T, void * >::type & beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::operator[] ( Key const & key )

Definition at line 2628 of file aged_unordered_container.h.

◆ operator[]() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<bool maybe_multi, bool maybe_map, class >

std::conditional< IsMap, T, void * >::type & beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::operator[] ( Key && key )

Definition at line 2669 of file aged_unordered_container.h.

◆ begin() [1/4]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

iterator beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::begin ( )

Definition at line 959 of file aged_unordered_container.h.

◆ begin() [2/4]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_iterator beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::begin ( ) const

Definition at line 965 of file aged_unordered_container.h.

◆ cbegin() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_iterator beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::cbegin ( ) const

Definition at line 971 of file aged_unordered_container.h.

◆ end() [1/4]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

iterator beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::end ( )

Definition at line 977 of file aged_unordered_container.h.

◆ end() [2/4]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_iterator beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::end ( ) const

Definition at line 983 of file aged_unordered_container.h.

◆ cend() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_iterator beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::cend ( ) const

Definition at line 989 of file aged_unordered_container.h.

◆ iterator_to() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

iterator beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::iterator_to ( value_type & value )

Definition at line 995 of file aged_unordered_container.h.

◆ iterator_to() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_iterator beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::iterator_to ( value_type const & value ) const

Definition at line 1005 of file aged_unordered_container.h.

◆ empty()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

bool beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::empty ( ) const

noexcept

Definition at line 1021 of file aged_unordered_container.h.

◆ size()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

size_type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::size ( ) const

noexcept

Definition at line 1027 of file aged_unordered_container.h.

◆ max_size()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

size_type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::max_size ( ) const

noexcept

Definition at line 1033 of file aged_unordered_container.h.

◆ clear()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

void beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::clear ( )

Definition at line 2711 of file aged_unordered_container.h.

◆ insert() [1/14]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<bool maybe_multi>

auto beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert ( value_type const & value ) -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type

Definition at line 2741 of file aged_unordered_container.h.

◆ insert() [2/14]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<bool maybe_multi = IsMulti>

auto beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert ( value_type const & value ) -> typename std::enable_if< maybe_multi, iterator >::type

◆ insert() [3/14]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<bool maybe_multi, bool maybe_map>

auto beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert ( value_type && value ) -> typename std::enable_if< !maybe_multi && !maybe_map, std::pair<iterator, bool>>::type

Definition at line 2811 of file aged_unordered_container.h.

◆ insert() [4/14]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<bool maybe_multi = IsMulti, bool maybe_map = IsMap>

auto beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert ( value_type && value ) -> typename std::enable_if< maybe_multi &&!maybe_map, iterator >::type

◆ insert() [5/14]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<bool maybe_multi = IsMulti>

std::enable_if<!maybe_multi, iterator >::type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert	(	const_iterator	,
		value_type const &	value
	)

Definition at line 1075 of file aged_unordered_container.h.

◆ insert() [6/14]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<bool maybe_multi = IsMulti>

std::enable_if< maybe_multi, iterator >::type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert	(	const_iterator	,
		value_type const &	value
	)

Definition at line 1085 of file aged_unordered_container.h.

◆ insert() [7/14]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<bool maybe_multi = IsMulti>

std::enable_if<!maybe_multi, iterator >::type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert	(	const_iterator	,
		value_type &&	value
	)

Definition at line 1095 of file aged_unordered_container.h.

◆ insert() [8/14]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<bool maybe_multi = IsMulti>

std::enable_if< maybe_multi, iterator >::type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert	(	const_iterator	,
		value_type &&	value
	)

Definition at line 1105 of file aged_unordered_container.h.

◆ insert() [9/14]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class P , bool maybe_map = IsMap>

std::enable_if< maybe_map &&std::is_constructible< value_type, P && >::value, typenamestd::conditional< IsMulti, iterator, std::pair< iterator, bool > >::type >::type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert ( P && value )

Definition at line 1119 of file aged_unordered_container.h.

◆ insert() [10/14]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class P , bool maybe_map = IsMap>

std::enable_if< maybe_map &&std::is_constructible< value_type, P && >::value, typenamestd::conditional< IsMulti, iterator, std::pair< iterator, bool > >::type >::type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert	(	const_iterator	hint,
		P &&	value
	)

Definition at line 1131 of file aged_unordered_container.h.

◆ insert() [11/14]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class InputIt >

void beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert	(	InputIt	first,
		InputIt	last
	)

Definition at line 1138 of file aged_unordered_container.h.

◆ insert() [12/14]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

void beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert ( std::initializer_list< value_type > init )

Definition at line 1147 of file aged_unordered_container.h.

◆ emplace() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<bool maybe_multi, class... Args>

auto beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::emplace ( Args &&... args ) -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type

Definition at line 2883 of file aged_unordered_container.h.

◆ emplace() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<bool maybe_multi = IsMulti, class... Args>

auto beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::emplace ( Args &&... args ) -> typename std::enable_if< maybe_multi, iterator >::type

◆ emplace_hint() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<bool maybe_multi, class... Args>

auto beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::emplace_hint	(	const_iterator	,
		Args &&...	args
	)		-> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type

Definition at line 2994 of file aged_unordered_container.h.

◆ emplace_hint() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<bool maybe_multi = IsMulti, class... Args>

std::enable_if< maybe_multi, iterator >::type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::emplace_hint	(	const_iterator	,
		Args &&...	args
	)

Definition at line 1173 of file aged_unordered_container.h.

◆ erase() [1/3]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<bool is_const, class Iterator >

beast::detail::aged_container_iterator< false, Iterator > beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::erase ( beast::detail::aged_container_iterator< is_const, Iterator > pos )

Definition at line 3036 of file aged_unordered_container.h.

◆ erase() [2/3]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<bool is_const, class Iterator >

beast::detail::aged_container_iterator< false, Iterator > beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::erase	(	beast::detail::aged_container_iterator< is_const, Iterator >	first,
		beast::detail::aged_container_iterator< is_const, Iterator >	last
	)

Definition at line 3063 of file aged_unordered_container.h.

◆ erase() [3/3]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<class K >

auto beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::erase ( K const & k ) -> size_type

Definition at line 3094 of file aged_unordered_container.h.

◆ swap()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

void beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::swap ( aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > & other )

noexcept

Definition at line 3133 of file aged_unordered_container.h.

◆ touch() [1/3]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<bool is_const, class Iterator >

void beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::touch ( beast::detail::aged_container_iterator< is_const, Iterator > pos )

Definition at line 1199 of file aged_unordered_container.h.

◆ touch() [2/3]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<class K >

auto beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::touch ( K const & k ) -> size_type

Definition at line 3159 of file aged_unordered_container.h.

◆ count()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class K >

size_type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::count ( K const & k ) const

Definition at line 1217 of file aged_unordered_container.h.

◆ find() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class K >

iterator beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::find ( K const & k )

Definition at line 1228 of file aged_unordered_container.h.

◆ find() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class K >

const_iterator beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::find ( K const & k ) const

Definition at line 1239 of file aged_unordered_container.h.

◆ equal_range() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class K >

std::pair< iterator, iterator > beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::equal_range ( K const & k )

Definition at line 1250 of file aged_unordered_container.h.

◆ equal_range() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class K >

std::pair< const_iterator, const_iterator > beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::equal_range ( K const & k ) const

Definition at line 1262 of file aged_unordered_container.h.

◆ begin() [3/4]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

local_iterator beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::begin ( size_type n )

Definition at line 1279 of file aged_unordered_container.h.

◆ begin() [4/4]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_local_iterator beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::begin ( size_type n ) const

Definition at line 1285 of file aged_unordered_container.h.

◆ cbegin() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_local_iterator beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::cbegin ( size_type n ) const

Definition at line 1291 of file aged_unordered_container.h.

◆ end() [3/4]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

local_iterator beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::end ( size_type n )

Definition at line 1297 of file aged_unordered_container.h.

◆ end() [4/4]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_local_iterator beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::end ( size_type n ) const

Definition at line 1303 of file aged_unordered_container.h.

◆ cend() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_local_iterator beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::cend ( size_type n ) const

Definition at line 1309 of file aged_unordered_container.h.

◆ bucket_count()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

size_type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::bucket_count ( ) const

Definition at line 1315 of file aged_unordered_container.h.

◆ max_bucket_count()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

size_type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::max_bucket_count ( ) const

Definition at line 1321 of file aged_unordered_container.h.

◆ bucket_size()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

size_type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::bucket_size ( size_type n ) const

Definition at line 1327 of file aged_unordered_container.h.

◆ bucket()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

size_type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::bucket ( Key const & k ) const

Definition at line 1333 of file aged_unordered_container.h.

◆ load_factor()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

float beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::load_factor ( ) const

Definition at line 1349 of file aged_unordered_container.h.

◆ max_load_factor() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

float beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::max_load_factor ( ) const

Definition at line 1355 of file aged_unordered_container.h.

◆ max_load_factor() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

void beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::max_load_factor ( float ml )

Definition at line 1361 of file aged_unordered_container.h.

◆ rehash()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

void beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::rehash ( size_type count )

Definition at line 1367 of file aged_unordered_container.h.

◆ reserve()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

void beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::reserve ( size_type count )

Definition at line 1374 of file aged_unordered_container.h.

◆ hash_function()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

hasher const & beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::hash_function ( ) const

Definition at line 1386 of file aged_unordered_container.h.

◆ key_eq()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

key_equal const & beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::key_eq ( ) const

Definition at line 1392 of file aged_unordered_container.h.

◆ operator==() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<bool OtherIsMap, class OtherKey , class OtherT , class OtherDuration , class OtherHash , class OtherAllocator , bool maybe_multi>

std::enable_if<!maybe_multi, bool >::type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::operator== ( aged_unordered_container< false, OtherIsMap, OtherKey, OtherT, OtherDuration, OtherHash, KeyEqual, OtherAllocator > const & other ) const

Definition at line 3198 of file aged_unordered_container.h.

◆ operator==() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<bool OtherIsMap, class OtherKey , class OtherT , class OtherDuration , class OtherHash , class OtherAllocator , bool maybe_multi>

std::enable_if< maybe_multi, bool >::type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::operator== ( aged_unordered_container< true, OtherIsMap, OtherKey, OtherT, OtherDuration, OtherHash, KeyEqual, OtherAllocator > const & other ) const

Definition at line 3247 of file aged_unordered_container.h.

◆ operator!=()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<bool OtherIsMulti, bool OtherIsMap, class OtherKey , class OtherT , class OtherDuration , class OtherHash , class OtherAllocator >

bool beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::operator!= ( aged_unordered_container< OtherIsMulti, OtherIsMap, OtherKey, OtherT, OtherDuration, OtherHash, KeyEqual, OtherAllocator > const & other ) const

Definition at line 1454 of file aged_unordered_container.h.

◆ would_exceed()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

bool beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::would_exceed ( size_type additional ) const

private

Definition at line 1469 of file aged_unordered_container.h.

◆ maybe_rehash()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

void beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::maybe_rehash ( size_type additional )

private

Definition at line 1475 of file aged_unordered_container.h.

◆ insert_unchecked() [1/3]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock , class Hash , class KeyEqual , class Allocator >

template<bool maybe_multi>

auto beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert_unchecked ( value_type const & value ) -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type

private

Definition at line 3301 of file aged_unordered_container.h.

◆ insert_unchecked() [2/3]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<bool maybe_multi = IsMulti>

auto beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert_unchecked ( value_type const & value ) -> typename std::enable_if< maybe_multi, iterator >::type

private

◆ insert_unchecked() [3/3]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class InputIt >

void beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert_unchecked	(	InputIt	first,
		InputIt	last
	)

private

Definition at line 1499 of file aged_unordered_container.h.

◆ insert() [13/14]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class InputIt >

void beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert	(	InputIt	first,
		InputIt	last,
		std::input_iterator_tag
	)

private

Definition at line 1507 of file aged_unordered_container.h.

◆ insert() [14/14]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class InputIt >

void beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert	(	InputIt	first,
		InputIt	last,
		std::random_access_iterator_tag
	)

private

Definition at line 1515 of file aged_unordered_container.h.

◆ touch() [3/3]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<bool is_const, class Iterator >

void beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::touch	(	beast::detail::aged_container_iterator< is_const, Iterator >	pos,
		typename clock_type::time_point const &	now
	)

private

Definition at line 1524 of file aged_unordered_container.h.

◆ swap_data() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<bool maybe_propagate = std::allocator_traits< Allocator>::propagate_on_container_swap::value>

std::enable_if< maybe_propagate >::type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::swap_data ( aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > & other )

privatenoexcept

Definition at line 1538 of file aged_unordered_container.h.

◆ swap_data() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<bool maybe_propagate = std::allocator_traits< Allocator>::propagate_on_container_swap::value>

std::enable_if<!maybe_propagate >::type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::swap_data ( aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > & other )

privatenoexcept

Definition at line 1549 of file aged_unordered_container.h.

◆ at() [3/3]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class K , bool maybe_multi, bool maybe_map, class >

std::conditional< IsMap, T, void * >::type const & beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::at ( K const & k ) const

Definition at line 2598 of file aged_unordered_container.h.

Member Data Documentation

◆ chronological

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

class beast::detail::aged_unordered_container::chronological_t beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::chronological

◆ m_config

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

config_t beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::m_config

private

Definition at line 1556 of file aged_unordered_container.h.

◆ m_buck

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

Buckets beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::m_buck

private

Definition at line 1557 of file aged_unordered_container.h.

◆ m_cont

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

cont_type beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::m_cont

mutableprivate

Definition at line 1558 of file aged_unordered_container.h.

Classes

Public Types

Public Member Functions

Public Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ clock_type

◆ time_point

◆ duration

◆ key_type

◆ mapped_type

◆ value_type

◆ size_type

◆ difference_type

◆ is_unordered

◆ is_multi

◆ is_map

◆ list_type

◆ cont_type

◆ bucket_type

◆ bucket_traits

◆ ElementAllocator

◆ ElementAllocatorTraits

◆ BucketAllocator

◆ BucketAllocatorTraits

◆ hasher

◆ key_equal

◆ allocator_type

◆ reference

◆ const_reference

◆ pointer

◆ const_pointer

◆ iterator

◆ const_iterator

◆ local_iterator

◆ const_local_iterator

Constructor & Destructor Documentation

◆ aged_unordered_container() [1/29]

◆ aged_unordered_container() [2/29]

◆ aged_unordered_container() [3/29]

◆ aged_unordered_container() [4/29]

◆ aged_unordered_container() [5/29]

◆ aged_unordered_container() [6/29]

◆ aged_unordered_container() [7/29]

◆ aged_unordered_container() [8/29]

◆ aged_unordered_container() [9/29]

◆ aged_unordered_container() [10/29]

◆ aged_unordered_container() [11/29]

◆ aged_unordered_container() [12/29]

◆ aged_unordered_container() [13/29]

◆ aged_unordered_container() [14/29]

◆ aged_unordered_container() [15/29]

◆ aged_unordered_container() [16/29]

◆ aged_unordered_container() [17/29]

◆ aged_unordered_container() [18/29]

◆ aged_unordered_container() [19/29]

◆ aged_unordered_container() [20/29]

◆ aged_unordered_container() [21/29]

◆ aged_unordered_container() [22/29]

◆ aged_unordered_container() [23/29]

◆ aged_unordered_container() [24/29]

◆ aged_unordered_container() [25/29]

◆ aged_unordered_container() [26/29]

◆ aged_unordered_container() [27/29]

◆ aged_unordered_container() [28/29]

◆ aged_unordered_container() [29/29]

◆ ~aged_unordered_container()

Member Function Documentation

◆ extract()

◆ new_element()

◆ delete_element()

◆ unlink_and_delete_element()

◆ operator=() [1/3]

◆ operator=() [2/3]

◆ operator=() [3/3]

◆ get_allocator()