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

#include <aged_unordered_container.h>

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

[legend]

Classes
struct	Element
class	ValueHash
class	KeyValueEqual
class	ConfigT
class	Buckets
class	ChronologicalT

Public Types
using	clock_type = AbstractClock<Clock>
using	time_point = clock_type::time_point
using	duration = clock_type::duration
using	key_type = Key
using	mapped_type = T
using	value_type = std::conditional_t<IsMap, std::pair<Key const, T>, Key>
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 = std::allocator_traits<Allocator>::pointer
using	const_pointer = std::allocator_traits<Allocator>::const_pointer
using	iterator = beast::detail::AgedContainerIterator<!IsMap, typename cont_type::iterator>
using	const_iterator = beast::detail::AgedContainerIterator<true, typename cont_type::iterator>
using	local_iterator
using	const_local_iterator

Public Member Functions
	AgedUnorderedContainer ()=delete
	AgedUnorderedContainer (clock_type &clock)
	AgedUnorderedContainer (clock_type &clock, Hash const &hash)
	AgedUnorderedContainer (clock_type &clock, KeyEqual const &keyEq)
	AgedUnorderedContainer (clock_type &clock, Allocator const &alloc)
	AgedUnorderedContainer (clock_type &clock, Hash const &hash, KeyEqual const &keyEq)
	AgedUnorderedContainer (clock_type &clock, Hash const &hash, Allocator const &alloc)
	AgedUnorderedContainer (clock_type &clock, KeyEqual const &keyEq, Allocator const &alloc)
	AgedUnorderedContainer (clock_type &clock, Hash const &hash, KeyEqual const &keyEq, Allocator const &alloc)
template<class InputIt>
	AgedUnorderedContainer (InputIt first, InputIt last, clock_type &clock)
template<class InputIt>
	AgedUnorderedContainer (InputIt first, InputIt last, clock_type &clock, Hash const &hash)
template<class InputIt>
	AgedUnorderedContainer (InputIt first, InputIt last, clock_type &clock, KeyEqual const &keyEq)
template<class InputIt>
	AgedUnorderedContainer (InputIt first, InputIt last, clock_type &clock, Allocator const &alloc)
template<class InputIt>
	AgedUnorderedContainer (InputIt first, InputIt last, clock_type &clock, Hash const &hash, KeyEqual const &keyEq)
template<class InputIt>
	AgedUnorderedContainer (InputIt first, InputIt last, clock_type &clock, Hash const &hash, Allocator const &alloc)
template<class InputIt>
	AgedUnorderedContainer (InputIt first, InputIt last, clock_type &clock, KeyEqual const &keyEq, Allocator const &alloc)
template<class InputIt>
	AgedUnorderedContainer (InputIt first, InputIt last, clock_type &clock, Hash const &hash, KeyEqual const &keyEq, Allocator const &alloc)
	AgedUnorderedContainer (AgedUnorderedContainer const &other)
	AgedUnorderedContainer (AgedUnorderedContainer const &other, Allocator const &alloc)
	AgedUnorderedContainer (AgedUnorderedContainer &&other)
	AgedUnorderedContainer (AgedUnorderedContainer &&other, Allocator const &alloc)
	AgedUnorderedContainer (std::initializer_list< value_type > init, clock_type &clock)
	AgedUnorderedContainer (std::initializer_list< value_type > init, clock_type &clock, Hash const &hash)
	AgedUnorderedContainer (std::initializer_list< value_type > init, clock_type &clock, KeyEqual const &keyEq)
	AgedUnorderedContainer (std::initializer_list< value_type > init, clock_type &clock, Allocator const &alloc)
	AgedUnorderedContainer (std::initializer_list< value_type > init, clock_type &clock, Hash const &hash, KeyEqual const &keyEq)
	AgedUnorderedContainer (std::initializer_list< value_type > init, clock_type &clock, Hash const &hash, Allocator const &alloc)
	AgedUnorderedContainer (std::initializer_list< value_type > init, clock_type &clock, KeyEqual const &keyEq, Allocator const &alloc)
	AgedUnorderedContainer (std::initializer_list< value_type > init, clock_type &clock, Hash const &hash, KeyEqual const &keyEq, Allocator const &alloc)
	~AgedUnorderedContainer ()
AgedUnorderedContainer &	operator= (AgedUnorderedContainer const &other)
AgedUnorderedContainer &	operator= (AgedUnorderedContainer &&other)
AgedUnorderedContainer &	operator= (std::initializer_list< value_type > init)
allocator_type	getAllocator () const
clock_type &	clock ()
clock_type const &	clock () const
template<class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap, class = std::enable_if_t<MaybeMap && !MaybeMulti>>
std::conditional_t< IsMap, T, void * > &	at (K const &k)
template<class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap, class = std::enable_if_t<MaybeMap && !MaybeMulti>>
std::conditional< IsMap, T, void * >::type const &	at (K const &k) const
template<bool MaybeMulti = IsMulti, bool MaybeMap = IsMap, class = std::enable_if_t<MaybeMap && !MaybeMulti>>
std::conditional_t< IsMap, T, void * > &	operator[] (Key const &key)
template<bool MaybeMulti = IsMulti, bool MaybeMap = IsMap, class = std::enable_if_t<MaybeMap && !MaybeMulti>>
std::conditional_t< IsMap, T, void * > &	operator[] (Key &&key)
iterator	begin ()
const_iterator	begin () const
const_iterator	cbegin () const
iterator	end ()
const_iterator	end () const
const_iterator	cend () const
iterator	iteratorTo (value_type &value)
const_iterator	iteratorTo (value_type const &value) const
bool	empty () const noexcept
size_type	size () const noexcept
size_type	maxSize () const noexcept
void	clear ()
template<bool MaybeMulti = IsMulti>
auto	insert (value_type const &value) -> std::enable_if_t<!MaybeMulti, std::pair< iterator, bool > >
template<bool MaybeMulti = IsMulti>
auto	insert (value_type const &value) -> std::enable_if_t< MaybeMulti, iterator >
template<bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
auto	insert (value_type &&value) -> std::enable_if_t<!MaybeMulti &&!MaybeMap, std::pair< iterator, bool > >
template<bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
auto	insert (value_type &&value) -> std::enable_if_t< MaybeMulti &&!MaybeMap, iterator >
template<bool MaybeMulti = IsMulti>
std::enable_if_t<!MaybeMulti, iterator >	insert (const_iterator, value_type const &value)
template<bool MaybeMulti = IsMulti>
std::enable_if_t< MaybeMulti, iterator >	insert (const_iterator, value_type const &value)
template<bool MaybeMulti = IsMulti>
std::enable_if_t<!MaybeMulti, iterator >	insert (const_iterator, value_type &&value)
template<bool MaybeMulti = IsMulti>
std::enable_if_t< MaybeMulti, iterator >	insert (const_iterator, value_type &&value)
template<class P, bool MaybeMap = IsMap>
std::enable_if_t< MaybeMap &&std::is_constructible_v< value_type, P && >, std::conditional_t< IsMulti, iterator, std::pair< iterator, bool > > >	insert (P &&value)
template<class P, bool MaybeMap = IsMap>
std::enable_if_t< MaybeMap &&std::is_constructible_v< value_type, P && >, std::conditional_t< IsMulti, iterator, std::pair< iterator, bool > > >	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 MaybeMulti = IsMulti, class... Args>
auto	emplace (Args &&... args) -> std::enable_if_t<!MaybeMulti, std::pair< iterator, bool > >
template<bool MaybeMulti = IsMulti, class... Args>
auto	emplace (Args &&... args) -> std::enable_if_t< MaybeMulti, iterator >
template<bool MaybeMulti = IsMulti, class... Args>
auto	emplaceHint (const_iterator, Args &&... args) -> std::enable_if_t<!MaybeMulti, std::pair< iterator, bool > >
template<bool MaybeMulti = IsMulti, class... Args>
std::enable_if_t< MaybeMulti, iterator >	emplaceHint (const_iterator, Args &&... args)
template<bool IsConst, class Iterator>
beast::detail::AgedContainerIterator< false, Iterator >	erase (beast::detail::AgedContainerIterator< IsConst, Iterator > pos)
template<bool IsConst, class Iterator>
beast::detail::AgedContainerIterator< false, Iterator >	erase (beast::detail::AgedContainerIterator< IsConst, Iterator > first, beast::detail::AgedContainerIterator< IsConst, Iterator > last)
template<class K>
auto	erase (K const &k) -> size_type
void	swap (AgedUnorderedContainer &other) noexcept
template<bool IsConst, class Iterator>
void	touch (beast::detail::AgedContainerIterator< IsConst, 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 >	equalRange (K const &k)
template<class K>
std::pair< const_iterator, const_iterator >	equalRange (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	bucketCount () const
size_type	maxBucketCount () const
size_type	bucketSize (size_type n) const
size_type	bucket (Key const &k) const
float	loadFactor () const
float	maxLoadFactor () const
void	maxLoadFactor (float ml)
void	rehash (size_type count)
void	reserve (size_type count)
hasher const &	hashFunction () const
key_equal const &	keyEq () const
template<bool OtherIsMap, class OtherKey, class OtherT, class OtherDuration, class OtherHash, class OtherAllocator, bool MaybeMulti = IsMulti>
std::enable_if_t<!MaybeMulti, bool >	operator== (AgedUnorderedContainer< 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 MaybeMulti = IsMulti>
std::enable_if_t< MaybeMulti, bool >	operator== (AgedUnorderedContainer< 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!= (AgedUnorderedContainer< OtherIsMulti, OtherIsMap, OtherKey, OtherT, OtherDuration, OtherHash, KeyEqual, OtherAllocator > const &other) const
template<class K, bool MaybeMulti, bool MaybeMap, class>
std::conditional< IsMap, T, void * >::type const &	at (K const &k) const

Public Attributes
class beast::detail::AgedUnorderedContainer::ChronologicalT	chronological

Private Types
using	list_type
using	cont_type
using	bucket_type = cont_type::bucket_type
using	bucket_traits = cont_type::bucket_traits
using	ElementAllocator = std::allocator_traits<Allocator>::template rebind_alloc<Element>
using	ElementAllocatorTraits = std::allocator_traits<ElementAllocator>
using	BucketAllocator = std::allocator_traits<Allocator>::template rebind_alloc<Element>
using	BucketAllocatorTraits = std::allocator_traits<BucketAllocator>

Private Member Functions
template<class... Args>
Element *	newElement (Args &&... args)
void	deleteElement (Element const *p)
void	unlinkAndDeleteElement (Element const *p)
bool	wouldExceed (size_type additional) const
void	maybeRehash (size_type additional)
template<bool MaybeMulti = IsMulti>
auto	insertUnchecked (value_type const &value) -> std::enable_if_t<!MaybeMulti, std::pair< iterator, bool > >
template<bool MaybeMulti = IsMulti>
auto	insertUnchecked (value_type const &value) -> std::enable_if_t< MaybeMulti, iterator >
template<class InputIt>
void	insertUnchecked (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 IsConst, class Iterator>
void	touch (beast::detail::AgedContainerIterator< IsConst, Iterator > pos, clock_type::time_point const &now)
template<bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
std::enable_if_t< MaybePropagate >	swapData (AgedUnorderedContainer &other) noexcept
template<bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
std::enable_if_t<!MaybePropagate >	swapData (AgedUnorderedContainer &other) noexcept

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

Private Attributes
ConfigT	config_
Buckets	buck_
cont_type	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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>
class beast::detail::AgedUnorderedContainer< 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 66 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 69 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 70 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 71 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 72 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 73 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

using beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::value_type = std::conditional_t<IsMap, std::pair<Key const, T>, Key>

Definition at line 74 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 75 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 76 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 79 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 80 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 81 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

using beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::list_type

private

Initial value:

boost::intrusive::make_list<Element, boost::intrusive::constant_time_size<false>>::type

beast::detail::type

Definition at line 204 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

using beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::cont_type

private

Initial value:

std::conditional_t<
       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>

Definition at line 207 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

private

Definition at line 222 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

private

Definition at line 223 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

private

Definition at line 225 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

private

Definition at line 227 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

private

Definition at line 229 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

private

Definition at line 231 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 538 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 539 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 540 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 541 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 542 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 543 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 544 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 548 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 549 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

using beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::local_iterator

Initial value:

beast::detail::AgedContainerIterator<!IsMap, typename cont_type::local_iterator>

beast::detail::AgedContainerIterator

Definition aged_container_iterator.h:17

Definition at line 551 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

using beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::const_local_iterator

Initial value:

beast::detail::AgedContainerIterator<true, typename cont_type::local_iterator>

Definition at line 553 of file aged_unordered_container.h.

Constructor & Destructor Documentation

◆ AgedUnorderedContainer() [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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

delete

◆ AgedUnorderedContainer() [2/29]

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

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

explicit

Definition at line 1461 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [3/29]

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

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

Definition at line 1477 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [4/29]

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

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

Definition at line 1493 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [5/29]

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

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

Definition at line 1509 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [6/29]

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

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

Definition at line 1526 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [7/29]

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

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

Definition at line 1542 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [8/29]

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

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

Definition at line 1559 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [9/29]

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

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

Definition at line 1576 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [10/29]

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

template<class InputIt>

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

Definition at line 1598 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [11/29]

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

template<class InputIt>

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

Definition at line 1616 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [12/29]

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

template<class InputIt>

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

Definition at line 1634 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [13/29]

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

template<class InputIt>

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

Definition at line 1652 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [14/29]

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

template<class InputIt>

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

Definition at line 1671 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [15/29]

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

template<class InputIt>

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

Definition at line 1694 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [16/29]

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

template<class InputIt>

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

Definition at line 1718 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [17/29]

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

template<class InputIt>

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

Definition at line 1742 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [18/29]

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

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

Definition at line 1766 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [19/29]

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

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

Definition at line 1784 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [20/29]

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

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

Definition at line 1802 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [21/29]

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

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

Definition at line 1820 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [22/29]

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

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

Definition at line 1842 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [23/29]

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

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

Definition at line 1859 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [24/29]

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

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

Definition at line 1879 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [25/29]

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

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

Definition at line 1899 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [26/29]

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

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

Definition at line 1920 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [27/29]

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

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

Definition at line 1941 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [28/29]

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

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

Definition at line 1963 of file aged_unordered_container.h.

◆ AgedUnorderedContainer() [29/29]

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

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

Definition at line 1985 of file aged_unordered_container.h.

◆ ~AgedUnorderedContainer()

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

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

Definition at line 2008 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

staticprivate

Definition at line 85 of file aged_unordered_container.h.

◆ newElement()

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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<class... Args>

Element * beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::newElement ( Args &&... args )

private

Definition at line 499 of file aged_unordered_container.h.

◆ deleteElement()

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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

void beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::deleteElement ( Element const * p )

private

Definition at line 523 of file aged_unordered_container.h.

◆ unlinkAndDeleteElement()

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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

void beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::unlinkAndDeleteElement ( Element const * p )

private

Definition at line 530 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::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::operator= ( AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > const & other )

Definition at line 2024 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::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::operator= ( AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > && other )

Definition at line 2049 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::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::operator= ( std::initializer_list< value_type > init )

Definition at line 2072 of file aged_unordered_container.h.

◆ getAllocator()

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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 815 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 821 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 827 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 MaybeMulti, bool MaybeMap, class>

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

Definition at line 2093 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap, class = std::enable_if_t<MaybeMap && !MaybeMulti>>

std::conditional< IsMap, T, void * >::type const & beast::detail::AgedUnorderedContainer< 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 MaybeMulti, bool MaybeMap, class>

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

Definition at line 2134 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 MaybeMulti, bool MaybeMap, class>

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

Definition at line 2163 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 875 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 881 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 887 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 893 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 899 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 905 of file aged_unordered_container.h.

◆ iteratorTo() [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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 911 of file aged_unordered_container.h.

◆ iteratorTo() [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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 920 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

noexcept

Definition at line 935 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

noexcept

Definition at line 941 of file aged_unordered_container.h.

◆ maxSize()

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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

noexcept

Definition at line 947 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::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::clear ( )

Definition at line 2195 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 MaybeMulti>

auto beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert ( value_type const & value ) -> std::enable_if_t<!MaybeMulti, std::pair< iterator, bool > >

Definition at line 2216 of file aged_unordered_container.h.

◆ insert() [2/14]

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

template<bool MaybeMulti>

auto beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert ( value_type const & value ) -> std::enable_if_t< MaybeMulti, iterator >

Definition at line 2245 of file aged_unordered_container.h.

◆ insert() [3/14]

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

template<bool MaybeMulti, bool MaybeMap>

auto beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert ( value_type && value ) -> std::enable_if_t<!MaybeMulti &&!MaybeMap, std::pair< iterator, bool > >

Definition at line 2267 of file aged_unordered_container.h.

◆ insert() [4/14]

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

template<bool MaybeMulti, bool MaybeMap>

auto beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert ( value_type && value ) -> std::enable_if_t< MaybeMulti &&!MaybeMap, iterator >

Definition at line 2296 of file aged_unordered_container.h.

◆ 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<bool MaybeMulti = IsMulti>

std::enable_if_t<!MaybeMulti, iterator > beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert	(	const_iterator	,
		value_type const &	value )

Definition at line 985 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<bool MaybeMulti = IsMulti>

std::enable_if_t< MaybeMulti, iterator > beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert	(	const_iterator	,
		value_type const &	value )

Definition at line 995 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<bool MaybeMulti = IsMulti>

std::enable_if_t<!MaybeMulti, iterator > beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert	(	const_iterator	,
		value_type &&	value )

Definition at line 1005 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<bool MaybeMulti = IsMulti>

std::enable_if_t< MaybeMulti, iterator > beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert	(	const_iterator	,
		value_type &&	value )

Definition at line 1015 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<class P, bool MaybeMap = IsMap>

std::enable_if_t< MaybeMap &&std::is_constructible_v< value_type, P && >, std::conditional_t< IsMulti, iterator, std::pair< iterator, bool > > > beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert ( P && value )

Definition at line 1027 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<class P, bool MaybeMap = IsMap>

std::enable_if_t< MaybeMap &&std::is_constructible_v< value_type, P && >, std::conditional_t< IsMulti, iterator, std::pair< iterator, bool > > > beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insert	(	const_iterator	hint,
		P &&	value )

Definition at line 1037 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<class InputIt>

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

Definition at line 1044 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1050 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 MaybeMulti, class... Args>

auto beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::emplace ( Args &&... args ) -> std::enable_if_t<!MaybeMulti, std::pair< iterator, bool > >

Definition at line 2319 of file aged_unordered_container.h.

◆ emplace() [2/2]

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

template<bool MaybeMulti, class... Args>

auto beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::emplace ( Args &&... args ) -> std::enable_if_t< MaybeMulti, iterator >

Definition at line 2384 of file aged_unordered_container.h.

◆ emplaceHint() [1/2]

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

template<bool MaybeMulti, class... Args>

auto beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::emplaceHint	(	const_iterator	,
		Args &&...	args ) -> std::enable_if_t<!MaybeMulti, std::pair< iterator, bool > >

Definition at line 2406 of file aged_unordered_container.h.

◆ emplaceHint() [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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

std::enable_if_t< MaybeMulti, iterator > beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::emplaceHint	(	const_iterator	,
		Args &&...	args )

Definition at line 1074 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 IsConst, class Iterator>

beast::detail::AgedContainerIterator< false, Iterator > beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::erase ( beast::detail::AgedContainerIterator< IsConst, Iterator > pos )

Definition at line 2441 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 IsConst, class Iterator>

beast::detail::AgedContainerIterator< false, Iterator > beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::erase	(	beast::detail::AgedContainerIterator< IsConst, Iterator >	first,
		beast::detail::AgedContainerIterator< IsConst, Iterator >	last )

Definition at line 2459 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::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::erase ( K const & k ) -> size_type

Definition at line 2480 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::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::swap ( AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > & other )

noexcept

Definition at line 2509 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<bool IsConst, class Iterator>

void beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::touch ( beast::detail::AgedContainerIterator< IsConst, Iterator > pos )

Definition at line 1100 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::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::touch ( K const & k ) -> size_type

Definition at line 2528 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<class K>

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

Definition at line 1118 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<class K>

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

Definition at line 1127 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<class K>

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

Definition at line 1136 of file aged_unordered_container.h.

◆ equalRange() [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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<class K>

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

Definition at line 1145 of file aged_unordered_container.h.

◆ equalRange() [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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<class K>

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

Definition at line 1155 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1169 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1175 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1181 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1187 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1193 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1199 of file aged_unordered_container.h.

◆ bucketCount()

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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1205 of file aged_unordered_container.h.

◆ maxBucketCount()

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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1211 of file aged_unordered_container.h.

◆ bucketSize()

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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1217 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1223 of file aged_unordered_container.h.

◆ loadFactor()

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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1239 of file aged_unordered_container.h.

◆ maxLoadFactor() [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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1245 of file aged_unordered_container.h.

◆ maxLoadFactor() [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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1251 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1257 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1264 of file aged_unordered_container.h.

◆ hashFunction()

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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1276 of file aged_unordered_container.h.

◆ keyEq()

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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

Definition at line 1282 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 MaybeMulti>

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

Definition at line 2560 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 MaybeMulti>

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

Definition at line 2600 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

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

Definition at line 1344 of file aged_unordered_container.h.

◆ wouldExceed()

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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

private

Definition at line 1359 of file aged_unordered_container.h.

◆ maybeRehash()

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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

private

Definition at line 1365 of file aged_unordered_container.h.

◆ insertUnchecked() [1/3]

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

template<bool MaybeMulti>

auto beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insertUnchecked ( value_type const & value ) -> std::enable_if_t<!MaybeMulti, std::pair< iterator, bool > >

private

Definition at line 2645 of file aged_unordered_container.h.

◆ insertUnchecked() [2/3]

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

template<bool MaybeMulti>

auto beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::insertUnchecked ( value_type const & value ) -> std::enable_if_t< MaybeMulti, iterator >

private

Definition at line 2673 of file aged_unordered_container.h.

◆ insertUnchecked() [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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<class InputIt>

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

private

Definition at line 1388 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<class InputIt>

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

private

Definition at line 1396 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<class InputIt>

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

private

Definition at line 1404 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<bool IsConst, class Iterator>

void beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::touch	(	beast::detail::AgedContainerIterator< IsConst, Iterator >	pos,
		clock_type::time_point const &	now )

private

Definition at line 1413 of file aged_unordered_container.h.

◆ swapData() [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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

std::enable_if_t< MaybePropagate > beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::swapData ( AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > & other )

privatenoexcept

Definition at line 1426 of file aged_unordered_container.h.

◆ swapData() [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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

std::enable_if_t<!MaybePropagate > beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::swapData ( AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > & other )

privatenoexcept

Definition at line 1437 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

template<class K, bool MaybeMulti, bool MaybeMap, class>

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

Definition at line 2113 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

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

◆ 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

ConfigT beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::config_

private

Definition at line 1445 of file aged_unordered_container.h.

◆ 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

Buckets beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::buck_

private

Definition at line 1446 of file aged_unordered_container.h.

◆ 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<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>

cont_type beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator >::cont_

mutableprivate

Definition at line 1447 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

◆ AgedUnorderedContainer() [1/29]

◆ AgedUnorderedContainer() [2/29]

◆ AgedUnorderedContainer() [3/29]

◆ AgedUnorderedContainer() [4/29]

◆ AgedUnorderedContainer() [5/29]

◆ AgedUnorderedContainer() [6/29]

◆ AgedUnorderedContainer() [7/29]

◆ AgedUnorderedContainer() [8/29]

◆ AgedUnorderedContainer() [9/29]

◆ AgedUnorderedContainer() [10/29]

◆ AgedUnorderedContainer() [11/29]

◆ AgedUnorderedContainer() [12/29]

◆ AgedUnorderedContainer() [13/29]

◆ AgedUnorderedContainer() [14/29]

◆ AgedUnorderedContainer() [15/29]

◆ AgedUnorderedContainer() [16/29]

◆ AgedUnorderedContainer() [17/29]

◆ AgedUnorderedContainer() [18/29]

◆ AgedUnorderedContainer() [19/29]

◆ AgedUnorderedContainer() [20/29]

◆ AgedUnorderedContainer() [21/29]

◆ AgedUnorderedContainer() [22/29]

◆ AgedUnorderedContainer() [23/29]

◆ AgedUnorderedContainer() [24/29]

◆ AgedUnorderedContainer() [25/29]

◆ AgedUnorderedContainer() [26/29]

◆ AgedUnorderedContainer() [27/29]

◆ AgedUnorderedContainer() [28/29]

◆ AgedUnorderedContainer() [29/29]

◆ ~AgedUnorderedContainer()

Member Function Documentation

◆ extract()

◆ newElement()

◆ deleteElement()

◆ unlinkAndDeleteElement()

◆ operator=() [1/3]

◆ operator=() [2/3]

◆ operator=() [3/3]

◆ getAllocator()