beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > Class Template Reference

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

#include <aged_ordered_container.h>

Collaboration diagram for beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >:

Classes
class	chronological_t
class	config_t
struct	element
class	KeyValueCompare
class	pair_value_compare

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::false_type
using	is_multi = std::integral_constant< bool, IsMulti >
using	is_map = std::integral_constant< bool, IsMap >
using	key_compare = Compare
using	value_compare = typename std::conditional< IsMap, pair_value_compare, Compare >::type
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	reverse_iterator = beast::detail::aged_container_iterator<!IsMap, typename cont_type::reverse_iterator >
using	const_reverse_iterator = beast::detail::aged_container_iterator< true, typename cont_type::reverse_iterator >

Public Member Functions
	aged_ordered_container ()=delete
	aged_ordered_container (clock_type &clock)
	aged_ordered_container (clock_type &clock, Compare const &comp)
	aged_ordered_container (clock_type &clock, Allocator const &alloc)
	aged_ordered_container (clock_type &clock, Compare const &comp, Allocator const &alloc)
template<class InputIt >
	aged_ordered_container (InputIt first, InputIt last, clock_type &clock)
template<class InputIt >
	aged_ordered_container (InputIt first, InputIt last, clock_type &clock, Compare const &comp)
template<class InputIt >
	aged_ordered_container (InputIt first, InputIt last, clock_type &clock, Allocator const &alloc)
template<class InputIt >
	aged_ordered_container (InputIt first, InputIt last, clock_type &clock, Compare const &comp, Allocator const &alloc)
	aged_ordered_container (aged_ordered_container const &other)
	aged_ordered_container (aged_ordered_container const &other, Allocator const &alloc)
	aged_ordered_container (aged_ordered_container &&other)
	aged_ordered_container (aged_ordered_container &&other, Allocator const &alloc)
	aged_ordered_container (std::initializer_list< value_type > init, clock_type &clock)
	aged_ordered_container (std::initializer_list< value_type > init, clock_type &clock, Compare const &comp)
	aged_ordered_container (std::initializer_list< value_type > init, clock_type &clock, Allocator const &alloc)
	aged_ordered_container (std::initializer_list< value_type > init, clock_type &clock, Compare const &comp, Allocator const &alloc)
	~aged_ordered_container ()
aged_ordered_container &	operator= (aged_ordered_container const &other)
aged_ordered_container &	operator= (aged_ordered_container &&other)
aged_ordered_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
reverse_iterator	rbegin ()
const_reverse_iterator	rbegin () const
const_reverse_iterator	crbegin () const
reverse_iterator	rend ()
const_reverse_iterator	rend () const
const_reverse_iterator	crend () 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>
auto	insert (const_iterator hint, value_type const &value) -> typename std::enable_if<!maybe_multi, 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>
auto	insert (const_iterator hint, value_type &&value) -> typename std::enable_if<!maybe_multi, iterator >::type
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 hint, 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 , class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
beast::detail::aged_container_iterator< false, Iterator >	erase (beast::detail::aged_container_iterator< is_const, Iterator > pos)
template<bool is_const, class Iterator , class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
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_ordered_container &other) noexcept
template<bool is_const, class Iterator , class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
void	touch (beast::detail::aged_container_iterator< is_const, Iterator > pos)
template<class K >
size_type	touch (K const &k)
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
template<class K >
iterator	lower_bound (K const &k)
template<class K >
const_iterator	lower_bound (K const &k) const
template<class K >
iterator	upper_bound (K const &k)
template<class K >
const_iterator	upper_bound (K const &k) const
key_compare	key_comp () const
value_compare	value_comp () const
template<bool OtherIsMulti, bool OtherIsMap, class OtherT , class OtherDuration , class OtherAllocator >
bool	operator== (aged_ordered_container< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const &other) const
template<bool OtherIsMulti, bool OtherIsMap, class OtherT , class OtherDuration , class OtherAllocator >
bool	operator!= (aged_ordered_container< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const &other) const
template<bool OtherIsMulti, bool OtherIsMap, class OtherT , class OtherDuration , class OtherAllocator >
bool	operator< (aged_ordered_container< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const &other) const
template<bool OtherIsMulti, bool OtherIsMap, class OtherT , class OtherDuration , class OtherAllocator >
bool	operator<= (aged_ordered_container< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const &other) const
template<bool OtherIsMulti, bool OtherIsMap, class OtherT , class OtherDuration , class OtherAllocator >
bool	operator> (aged_ordered_container< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const &other) const
template<bool OtherIsMulti, bool OtherIsMap, class OtherT , class OtherDuration , class OtherAllocator >
bool	operator>= (aged_ordered_container< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, 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
template<class K >
auto	touch (K const &k) -> size_type

Public Attributes
class beast::detail::aged_ordered_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_multiset< element, boost::intrusive::constant_time_size< true >, boost::intrusive::compare< KeyValueCompare > >::type, typename boost::intrusive::make_set< element, boost::intrusive::constant_time_size< true >, boost::intrusive::compare< KeyValueCompare > >::type >::type
using	ElementAllocator = typename std::allocator_traits< Allocator >::template rebind_alloc< element >
using	ElementAllocatorTraits = std::allocator_traits< ElementAllocator >

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)
template<bool is_const, class Iterator , class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
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_ordered_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_ordered_container &other) noexcept

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

Private Attributes
config_t	m_config
cont_type	m_cont

Detailed Description

template<bool IsMulti, bool IsMap, class Key, class T, class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>
class beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >

Associative container where each element is also indexed by time.

This container mirrors the interface of the standard library ordered 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_set, aged_multiset, aged_map, aged_multimap

Definition at line 83 of file aged_ordered_container.h.

Member Typedef Documentation

clock_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::clock_type = abstract_clock<Clock>

Definition at line 86 of file aged_ordered_container.h.

time_point

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::time_point = typename clock_type::time_point

Definition at line 87 of file aged_ordered_container.h.

duration

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::duration = typename clock_type::duration

Definition at line 88 of file aged_ordered_container.h.

key_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::key_type = Key

Definition at line 89 of file aged_ordered_container.h.

mapped_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::mapped_type = T

Definition at line 90 of file aged_ordered_container.h.

value_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

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

Definition at line 91 of file aged_ordered_container.h.

size_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::size_type = std::size_t

Definition at line 93 of file aged_ordered_container.h.

difference_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::difference_type = std::ptrdiff_t

Definition at line 94 of file aged_ordered_container.h.

is_unordered

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::is_unordered = std::false_type

Definition at line 97 of file aged_ordered_container.h.

is_multi

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::is_multi = std::integral_constant<bool, IsMulti>

Definition at line 98 of file aged_ordered_container.h.

is_map

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::is_map = std::integral_constant<bool, IsMap>

Definition at line 99 of file aged_ordered_container.h.

list_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

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

private

Definition at line 224 of file aged_ordered_container.h.

cont_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::cont_type = typename std::conditional< IsMulti, typename boost::intrusive::make_multiset< element, boost::intrusive::constant_time_size<true>, boost::intrusive::compare<KeyValueCompare> >::type, typename boost::intrusive::make_set< element, boost::intrusive::constant_time_size<true>, boost::intrusive::compare<KeyValueCompare> >::type>::type

private

Definition at line 227 of file aged_ordered_container.h.

ElementAllocator

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

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

private

Definition at line 238 of file aged_ordered_container.h.

ElementAllocatorTraits

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::ElementAllocatorTraits = std::allocator_traits<ElementAllocator>

private

Definition at line 241 of file aged_ordered_container.h.

key_compare

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::key_compare = Compare

Definition at line 412 of file aged_ordered_container.h.

value_compare

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::value_compare = typename std::conditional<IsMap, pair_value_compare, Compare>::type

Definition at line 413 of file aged_ordered_container.h.

allocator_type

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::allocator_type = Allocator

Definition at line 415 of file aged_ordered_container.h.

reference

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::reference = value_type&

Definition at line 416 of file aged_ordered_container.h.

const_reference

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::const_reference = value_type const&

Definition at line 417 of file aged_ordered_container.h.

pointer

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::pointer = typename std::allocator_traits<Allocator>::pointer

Definition at line 418 of file aged_ordered_container.h.

const_pointer

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::const_pointer = typename std::allocator_traits<Allocator>::const_pointer

Definition at line 419 of file aged_ordered_container.h.

iterator

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::iterator = beast::detail:: aged_container_iterator<!IsMap, typename cont_type::iterator>

Definition at line 424 of file aged_ordered_container.h.

const_iterator

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

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

Definition at line 426 of file aged_ordered_container.h.

reverse_iterator

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::reverse_iterator = beast::detail:: aged_container_iterator<!IsMap, typename cont_type::reverse_iterator>

Definition at line 428 of file aged_ordered_container.h.

const_reverse_iterator

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

using beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::const_reverse_iterator = beast::detail:: aged_container_iterator<true, typename cont_type::reverse_iterator>

Definition at line 430 of file aged_ordered_container.h.

Constructor & Destructor Documentation

aged_ordered_container() [1/17]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::aged_ordered_container ( )

delete

aged_ordered_container() [2/17]

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

beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::aged_ordered_container ( clock_type &  clock )

explicit

Definition at line 1266 of file aged_ordered_container.h.

aged_ordered_container() [3/17]

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

beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::aged_ordered_container	(	clock_type &	clock,
		Compare const &	comp
	)

Definition at line 1280 of file aged_ordered_container.h.

aged_ordered_container() [4/17]

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

beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::aged_ordered_container	(	clock_type &	clock,
		Allocator const &	alloc
	)

Definition at line 1294 of file aged_ordered_container.h.

aged_ordered_container() [5/17]

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

beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::aged_ordered_container	(	clock_type &	clock,
		Compare const &	comp,
		Allocator const &	alloc
	)

Definition at line 1308 of file aged_ordered_container.h.

aged_ordered_container() [6/17]

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

template<class InputIt >

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

Definition at line 1326 of file aged_ordered_container.h.

aged_ordered_container() [7/17]

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

template<class InputIt >

beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::aged_ordered_container	(	InputIt	first,
		InputIt	last,
		clock_type &	clock,
		Compare const &	comp
	)

Definition at line 1342 of file aged_ordered_container.h.

aged_ordered_container() [8/17]

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

template<class InputIt >

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

Definition at line 1362 of file aged_ordered_container.h.

aged_ordered_container() [9/17]

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

template<class InputIt >

beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::aged_ordered_container	(	InputIt	first,
		InputIt	last,
		clock_type &	clock,
		Compare const &	comp,
		Allocator const &	alloc
	)

Definition at line 1382 of file aged_ordered_container.h.

aged_ordered_container() [10/17]

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

beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::aged_ordered_container

(

aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > const &

other

)

Definition at line 1402 of file aged_ordered_container.h.

aged_ordered_container() [11/17]

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

beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::aged_ordered_container	(	aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > const &	other,
		Allocator const &	alloc
	)

Definition at line 1422 of file aged_ordered_container.h.

aged_ordered_container() [12/17]

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

beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::aged_ordered_container

(

aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > &&

other

)

Definition at line 1444 of file aged_ordered_container.h.

aged_ordered_container() [13/17]

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

beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::aged_ordered_container	(	aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > &&	other,
		Allocator const &	alloc
	)

Definition at line 1459 of file aged_ordered_container.h.

aged_ordered_container() [14/17]

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

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

Definition at line 1483 of file aged_ordered_container.h.

aged_ordered_container() [15/17]

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

beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::aged_ordered_container	(	std::initializer_list< value_type >	init,
		clock_type &	clock,
		Compare const &	comp
	)

Definition at line 1500 of file aged_ordered_container.h.

aged_ordered_container() [16/17]

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

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

Definition at line 1518 of file aged_ordered_container.h.

aged_ordered_container() [17/17]

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

beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::aged_ordered_container	(	std::initializer_list< value_type >	init,
		clock_type &	clock,
		Compare const &	comp,
		Allocator const &	alloc
	)

Definition at line 1536 of file aged_ordered_container.h.

~aged_ordered_container()

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

beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::~aged_ordered_container

(

)

Definition at line 1555 of file aged_ordered_container.h.

Member Function Documentation

extract()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

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

staticprivate

Definition at line 103 of file aged_ordered_container.h.

new_element()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class... Args>

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

private

Definition at line 368 of file aged_ordered_container.h.

delete_element()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

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

private

Definition at line 396 of file aged_ordered_container.h.

unlink_and_delete_element()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

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

private

Definition at line 404 of file aged_ordered_container.h.

operator=() [1/3]

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

auto beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator=

(

aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > const &

other

)

Definition at line 1570 of file aged_ordered_container.h.

operator=() [2/3]

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

auto beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator=

(

aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > &&

other

)

Definition at line 1591 of file aged_ordered_container.h.

operator=() [3/3]

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

auto beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator=

(

std::initializer_list< value_type >

init

)

Definition at line 1610 of file aged_ordered_container.h.

get_allocator()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

allocator_type beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::get_allocator

(

)

const

Definition at line 651 of file aged_ordered_container.h.

clock() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

clock_type & beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::clock

(

)

Definition at line 657 of file aged_ordered_container.h.

clock() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

clock_type const & beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::clock

(

)

const

Definition at line 663 of file aged_ordered_container.h.

at() [1/3]

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

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

std::conditional< IsMap, T, void * >::type & beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::at

(

K const &

k

)

Definition at line 1630 of file aged_ordered_container.h.

at() [2/3]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<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_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::at

(

K const &

k

)

const

operator[]() [1/2]

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

template<bool maybe_multi, bool maybe_map, class >

std::conditional< IsMap, T, void * >::type & beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator[]

(

Key const &

key

)

Definition at line 1668 of file aged_ordered_container.h.

operator[]() [2/2]

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

template<bool maybe_multi, bool maybe_map, class >

std::conditional< IsMap, T, void * >::type & beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator[]

(

Key &&

key

)

Definition at line 1697 of file aged_ordered_container.h.

begin() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::begin

(

)

Definition at line 711 of file aged_ordered_container.h.

begin() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::begin

(

)

const

Definition at line 717 of file aged_ordered_container.h.

cbegin()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::cbegin

(

)

const

Definition at line 723 of file aged_ordered_container.h.

end() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::end

(

)

Definition at line 729 of file aged_ordered_container.h.

end() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::end

(

)

const

Definition at line 735 of file aged_ordered_container.h.

cend()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::cend

(

)

const

Definition at line 741 of file aged_ordered_container.h.

rbegin() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

reverse_iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::rbegin

(

)

Definition at line 747 of file aged_ordered_container.h.

rbegin() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_reverse_iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::rbegin

(

)

const

Definition at line 753 of file aged_ordered_container.h.

crbegin()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_reverse_iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::crbegin

(

)

const

Definition at line 759 of file aged_ordered_container.h.

rend() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

reverse_iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::rend

(

)

Definition at line 765 of file aged_ordered_container.h.

rend() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_reverse_iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::rend

(

)

const

Definition at line 771 of file aged_ordered_container.h.

crend()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_reverse_iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::crend

(

)

const

Definition at line 777 of file aged_ordered_container.h.

iterator_to() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::iterator_to

(

value_type &

value

)

Definition at line 783 of file aged_ordered_container.h.

iterator_to() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

const_iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::iterator_to

(

value_type const &

value

)

const

Definition at line 793 of file aged_ordered_container.h.

empty()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

bool beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::empty ( ) const

noexcept

Definition at line 809 of file aged_ordered_container.h.

size()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

size_type beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::size ( ) const

noexcept

Definition at line 815 of file aged_ordered_container.h.

max_size()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

size_type beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::max_size ( ) const

noexcept

Definition at line 821 of file aged_ordered_container.h.

clear()

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

void beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::clear

(

)

Definition at line 1727 of file aged_ordered_container.h.

insert() [1/12]

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

template<bool maybe_multi>

auto beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::insert

(

value_type const &

value

)

-> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type

Definition at line 1748 of file aged_ordered_container.h.

insert() [2/12]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<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_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::insert

(

value_type const &

value

)

-> typename std::enable_if< maybe_multi, iterator >::type

insert() [3/12]

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

template<bool maybe_multi, bool maybe_map>

auto beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::insert

(

value_type &&

value

)

-> typename std::enable_if< !maybe_multi && !maybe_map, std::pair<iterator, bool>>::type

Definition at line 1799 of file aged_ordered_container.h.

insert() [4/12]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<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_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::insert

(

value_type &&

value

)

-> typename std::enable_if< maybe_multi &&!maybe_map, iterator >::type

insert() [5/12]

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

template<bool maybe_multi>

auto beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::insert	(	const_iterator	hint,
		value_type const &	value
	)		-> typename std::enable_if<!maybe_multi, iterator>::type

Definition at line 1853 of file aged_ordered_container.h.

insert() [6/12]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<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_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::insert	(	const_iterator	,
		value_type const &	value
	)

Definition at line 871 of file aged_ordered_container.h.

insert() [7/12]

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

template<bool maybe_multi>

auto beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::insert	(	const_iterator	hint,
		value_type &&	value
	)		-> typename std::enable_if<!maybe_multi, iterator>::type

Definition at line 1881 of file aged_ordered_container.h.

insert() [8/12]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<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_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::insert	(	const_iterator	,
		value_type &&	value
	)

Definition at line 886 of file aged_ordered_container.h.

insert() [9/12]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<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_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::insert

(

P &&

value

)

Definition at line 899 of file aged_ordered_container.h.

insert() [10/12]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<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_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::insert	(	const_iterator	hint,
		P &&	value
	)

Definition at line 911 of file aged_ordered_container.h.

insert() [11/12]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class InputIt >

void beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::insert	(	InputIt	first,
		InputIt	last
	)

Definition at line 918 of file aged_ordered_container.h.

insert() [12/12]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

void beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::insert

(

std::initializer_list< value_type >

init

)

Definition at line 925 of file aged_ordered_container.h.

emplace() [1/2]

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

template<bool maybe_multi, class... Args>

auto beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::emplace

(

Args &&...

args

)

-> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type

Definition at line 1909 of file aged_ordered_container.h.

emplace() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<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_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, 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 Compare , class Allocator >

template<bool maybe_multi, class... Args>

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

Definition at line 1963 of file aged_ordered_container.h.

emplace_hint() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<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_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::emplace_hint	(	const_iterator	,
		Args &&...	args
	)

Definition at line 951 of file aged_ordered_container.h.

erase() [1/3]

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

template<bool is_const, class Iterator , class >

beast::detail::aged_container_iterator< false, Iterator > beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::erase

(

beast::detail::aged_container_iterator< is_const, Iterator >

pos

)

Definition at line 1996 of file aged_ordered_container.h.

erase() [2/3]

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

template<bool is_const, class Iterator , class >

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

Definition at line 2014 of file aged_ordered_container.h.

erase() [3/3]

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

template<class K >

auto beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::erase

(

K const &

k

)

-> size_type

Definition at line 2036 of file aged_ordered_container.h.

swap()

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

void beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::swap ( aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > &  other )

noexcept

Definition at line 2064 of file aged_ordered_container.h.

touch() [1/4]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<bool is_const, class Iterator , class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>

void beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::touch

(

beast::detail::aged_container_iterator< is_const, Iterator >

pos

)

Definition at line 991 of file aged_ordered_container.h.

touch() [2/4]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class K >

size_type beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::touch

(

K const &

k

)

count()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class K >

size_type beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::count

(

K const &

k

)

const

Definition at line 1009 of file aged_ordered_container.h.

find() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class K >

iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::find

(

K const &

k

)

Definition at line 1017 of file aged_ordered_container.h.

find() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class K >

const_iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::find

(

K const &

k

)

const

Definition at line 1025 of file aged_ordered_container.h.

equal_range() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<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_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::equal_range

(

K const &

k

)

Definition at line 1034 of file aged_ordered_container.h.

equal_range() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<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_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::equal_range

(

K const &

k

)

const

Definition at line 1043 of file aged_ordered_container.h.

lower_bound() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class K >

iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::lower_bound

(

K const &

k

)

Definition at line 1053 of file aged_ordered_container.h.

lower_bound() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class K >

const_iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::lower_bound

(

K const &

k

)

const

Definition at line 1062 of file aged_ordered_container.h.

upper_bound() [1/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class K >

iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::upper_bound

(

K const &

k

)

Definition at line 1071 of file aged_ordered_container.h.

upper_bound() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class K >

const_iterator beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::upper_bound

(

K const &

k

)

const

Definition at line 1080 of file aged_ordered_container.h.

key_comp()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

key_compare beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::key_comp

(

)

const

Definition at line 1093 of file aged_ordered_container.h.

value_comp()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

value_compare beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::value_comp

(

)

const

Definition at line 1100 of file aged_ordered_container.h.

operator==()

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

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

bool beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator==

(

aged_ordered_container< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const &

other

)

const

Definition at line 2115 of file aged_ordered_container.h.

operator!=()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

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

bool beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator!=

(

aged_ordered_container< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const &

other

)

const

Definition at line 1138 of file aged_ordered_container.h.

operator<()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

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

bool beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator<

(

aged_ordered_container< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const &

other

)

const

Definition at line 1156 of file aged_ordered_container.h.

operator<=()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

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

bool beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator<=

(

aged_ordered_container< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const &

other

)

const

Definition at line 1177 of file aged_ordered_container.h.

operator>()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

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

bool beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator>

(

aged_ordered_container< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const &

other

)

const

Definition at line 1197 of file aged_ordered_container.h.

operator>=()

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

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

bool beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator>=

(

aged_ordered_container< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const &

other

)

const

Definition at line 1216 of file aged_ordered_container.h.

touch() [3/4]

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

template<bool is_const, class Iterator , class >

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

private

Definition at line 2159 of file aged_ordered_container.h.

swap_data() [1/2]

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

template<bool maybe_propagate>

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

privatenoexcept

Definition at line 2180 of file aged_ordered_container.h.

swap_data() [2/2]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<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_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::swap_data ( aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > &  other )

privatenoexcept

at() [3/3]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<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_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::at

(

K const &

k

)

const

Definition at line 1649 of file aged_ordered_container.h.

touch() [4/4]

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

template<class K >

auto beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::touch

(

K const &

k

)

-> size_type

Definition at line 2084 of file aged_ordered_container.h.

Member Data Documentation

chronological

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

class beast::detail::aged_ordered_container::chronological_t beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::chronological

m_config

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

config_t beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::m_config

private

Definition at line 1252 of file aged_ordered_container.h.

m_cont

template<bool IsMulti, bool IsMap, class Key , class T , class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator< typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>

cont_type beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::m_cont

mutableprivate

Definition at line 1253 of file aged_ordered_container.h.