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

#include <aged_ordered_container.h>

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

[legend]

Classes
struct	Element
class	PairValueCompare
class	KeyValueCompare
class	ConfigT
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::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 = std::conditional_t<IsMap, PairValueCompare, Compare>
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	reverse_iterator
using	const_reverse_iterator

Public Member Functions
	AgedOrderedContainer ()=delete
	AgedOrderedContainer (clock_type &clock)
	AgedOrderedContainer (clock_type &clock, Compare const &comp)
	AgedOrderedContainer (clock_type &clock, Allocator const &alloc)
	AgedOrderedContainer (clock_type &clock, Compare const &comp, Allocator const &alloc)
template<class InputIt>
	AgedOrderedContainer (InputIt first, InputIt last, clock_type &clock)
template<class InputIt>
	AgedOrderedContainer (InputIt first, InputIt last, clock_type &clock, Compare const &comp)
template<class InputIt>
	AgedOrderedContainer (InputIt first, InputIt last, clock_type &clock, Allocator const &alloc)
template<class InputIt>
	AgedOrderedContainer (InputIt first, InputIt last, clock_type &clock, Compare const &comp, Allocator const &alloc)
	AgedOrderedContainer (AgedOrderedContainer const &other)
	AgedOrderedContainer (AgedOrderedContainer const &other, Allocator const &alloc)
	AgedOrderedContainer (AgedOrderedContainer &&other)
	AgedOrderedContainer (AgedOrderedContainer &&other, Allocator const &alloc)
	AgedOrderedContainer (std::initializer_list< value_type > init, clock_type &clock)
	AgedOrderedContainer (std::initializer_list< value_type > init, clock_type &clock, Compare const &comp)
	AgedOrderedContainer (std::initializer_list< value_type > init, clock_type &clock, Allocator const &alloc)
	AgedOrderedContainer (std::initializer_list< value_type > init, clock_type &clock, Compare const &comp, Allocator const &alloc)
	~AgedOrderedContainer ()
AgedOrderedContainer &	operator= (AgedOrderedContainer const &other)
AgedOrderedContainer &	operator= (AgedOrderedContainer &&other)
AgedOrderedContainer &	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
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	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>
auto	insert (const_iterator hint, value_type const &value) -> std::enable_if_t<!MaybeMulti, iterator >
template<bool MaybeMulti = IsMulti>
std::enable_if_t< MaybeMulti, iterator >	insert (const_iterator, value_type const &value)
template<bool MaybeMulti = IsMulti>
auto	insert (const_iterator hint, value_type &&value) -> std::enable_if_t<!MaybeMulti, iterator >
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 hint, 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, class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
beast::detail::AgedContainerIterator< false, Iterator >	erase (beast::detail::AgedContainerIterator< IsConst, Iterator > pos)
template<bool IsConst, class Iterator, class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
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 (AgedOrderedContainer &other) noexcept
template<bool IsConst, class Iterator, class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
void	touch (beast::detail::AgedContainerIterator< IsConst, 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 >	equalRange (K const &k)
template<class K>
std::pair< const_iterator, const_iterator >	equalRange (K const &k) const
template<class K>
iterator	lowerBound (K const &k)
template<class K>
const_iterator	lowerBound (K const &k) const
template<class K>
iterator	upperBound (K const &k)
template<class K>
const_iterator	upperBound (K const &k) const
key_compare	keyComp () const
value_compare	valueComp () const
template<bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
bool	operator== (AgedOrderedContainer< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const &other) const
template<bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
bool	operator!= (AgedOrderedContainer< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const &other) const
template<bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
bool	operator< (AgedOrderedContainer< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const &other) const
template<bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
bool	operator<= (AgedOrderedContainer< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const &other) const
template<bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
bool	operator> (AgedOrderedContainer< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const &other) const
template<bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
bool	operator>= (AgedOrderedContainer< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, 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::AgedOrderedContainer::ChronologicalT	chronological

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

Private Member Functions
template<class... Args>
Element *	newElement (Args &&... args)
void	deleteElement (Element const *p)
void	unlinkAndDeleteElement (Element const *p)
template<bool IsConst, class Iterator, class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
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 (AgedOrderedContainer &other) noexcept
template<bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
std::enable_if_t<!MaybePropagate >	swapData (AgedOrderedContainer &other) noexcept

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

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

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

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

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

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

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

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

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

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

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

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

using beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::value_type = std::conditional_t<IsMap, std::pair<Key const, T>, Key>

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

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

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

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

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

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

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

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

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

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

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

using beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::list_type

private

Initial value:

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

beast::detail::type

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

using beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::cont_type

private

Initial value:

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

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

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

private

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

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

private

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

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

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

using beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::value_compare = std::conditional_t<IsMap, PairValueCompare, Compare>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

using beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::reverse_iterator

Initial value:

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

beast::detail::AgedContainerIterator

Definition aged_container_iterator.h:17

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

using beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::const_reverse_iterator

Initial value:

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

Definition at line 384 of file aged_ordered_container.h.

Constructor & Destructor Documentation

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

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

delete

◆ AgedOrderedContainer() [2/17]

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

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

explicit

Definition at line 1168 of file aged_ordered_container.h.

◆ AgedOrderedContainer() [3/17]

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

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

Definition at line 1175 of file aged_ordered_container.h.

◆ AgedOrderedContainer() [4/17]

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

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

Definition at line 1183 of file aged_ordered_container.h.

◆ AgedOrderedContainer() [5/17]

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

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

Definition at line 1191 of file aged_ordered_container.h.

◆ AgedOrderedContainer() [6/17]

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

template<class InputIt>

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

Definition at line 1201 of file aged_ordered_container.h.

◆ AgedOrderedContainer() [7/17]

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

template<class InputIt>

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

Definition at line 1212 of file aged_ordered_container.h.

◆ AgedOrderedContainer() [8/17]

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

template<class InputIt>

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

Definition at line 1224 of file aged_ordered_container.h.

◆ AgedOrderedContainer() [9/17]

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

template<class InputIt>

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

Definition at line 1236 of file aged_ordered_container.h.

◆ AgedOrderedContainer() [10/17]

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

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

Definition at line 1248 of file aged_ordered_container.h.

◆ AgedOrderedContainer() [11/17]

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

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

Definition at line 1261 of file aged_ordered_container.h.

◆ AgedOrderedContainer() [12/17]

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

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

Definition at line 1275 of file aged_ordered_container.h.

◆ AgedOrderedContainer() [13/17]

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

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

Definition at line 1283 of file aged_ordered_container.h.

◆ AgedOrderedContainer() [14/17]

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

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

Definition at line 1299 of file aged_ordered_container.h.

◆ AgedOrderedContainer() [15/17]

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

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

Definition at line 1308 of file aged_ordered_container.h.

◆ AgedOrderedContainer() [16/17]

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

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

Definition at line 1318 of file aged_ordered_container.h.

◆ AgedOrderedContainer() [17/17]

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

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

Definition at line 1328 of file aged_ordered_container.h.

◆ ~AgedOrderedContainer()

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

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

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

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

staticprivate

Definition at line 80 of file aged_ordered_container.h.

◆ newElement()

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

template<class... Args>

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

private

Definition at line 331 of file aged_ordered_container.h.

◆ deleteElement()

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

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

private

Definition at line 355 of file aged_ordered_container.h.

◆ unlinkAndDeleteElement()

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

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

private

Definition at line 362 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::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator= ( AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > const & other )

Definition at line 1346 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::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator= ( AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > && other )

Definition at line 1360 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::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator= ( std::initializer_list< value_type > init )

Definition at line 1372 of file aged_ordered_container.h.

◆ getAllocator()

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

allocator_type beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::getAllocator ( ) const

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

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

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

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

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

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

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

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

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

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

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

iterator beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::begin ( )

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

const_iterator beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::begin ( ) const

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

const_iterator beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::cbegin ( ) const

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

iterator beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::end ( )

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

const_iterator beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::end ( ) const

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

const_iterator beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::cend ( ) const

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

reverse_iterator beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::rbegin ( )

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

const_reverse_iterator beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::rbegin ( ) const

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

const_reverse_iterator beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::crbegin ( ) const

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

reverse_iterator beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::rend ( )

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

const_reverse_iterator beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::rend ( ) const

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

const_reverse_iterator beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::crend ( ) const

Definition at line 709 of file aged_ordered_container.h.

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

iterator beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::iteratorTo ( value_type & value )

Definition at line 715 of file aged_ordered_container.h.

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

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

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

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

noexcept

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

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

noexcept

Definition at line 745 of file aged_ordered_container.h.

◆ maxSize()

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

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

noexcept

Definition at line 751 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::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::clear ( )

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

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

Definition at line 1458 of file aged_ordered_container.h.

◆ insert() [2/12]

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

template<bool MaybeMulti>

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

Definition at line 1477 of file aged_ordered_container.h.

◆ insert() [3/12]

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

template<bool MaybeMulti, bool MaybeMap>

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

Definition at line 1491 of file aged_ordered_container.h.

◆ insert() [4/12]

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

template<bool MaybeMulti, bool MaybeMap>

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

Definition at line 1510 of file aged_ordered_container.h.

◆ insert() [5/12]

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

template<bool MaybeMulti>

auto beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::insert	(	const_iterator	hint,
		value_type const &	value ) -> std::enable_if_t<!MaybeMulti, iterator >

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

template<bool MaybeMulti = IsMulti>

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

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

auto beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::insert	(	const_iterator	hint,
		value_type &&	value ) -> std::enable_if_t<!MaybeMulti, iterator >

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

template<bool MaybeMulti = IsMulti>

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

Definition at line 810 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<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::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::insert ( P && value )

Definition at line 821 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<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::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::insert	(	const_iterator	hint,
		P &&	value )

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

template<class InputIt>

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

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

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

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

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

Definition at line 1568 of file aged_ordered_container.h.

◆ emplace() [2/2]

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

template<bool MaybeMulti, class... Args>

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

Definition at line 1590 of file aged_ordered_container.h.

◆ emplaceHint() [1/2]

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

template<bool MaybeMulti, class... Args>

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

Definition at line 1604 of file aged_ordered_container.h.

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

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

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

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

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

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

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

Definition at line 1637 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::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::erase ( K const & k ) -> size_type

Definition at line 1650 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::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::swap ( AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > & other )

noexcept

Definition at line 1671 of file aged_ordered_container.h.

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

template<bool IsConst, class Iterator, class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>

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

Definition at line 909 of file aged_ordered_container.h.

◆ touch() [2/3]

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

template<class K>

auto beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::touch ( K const & k )

Definition at line 1684 of file aged_ordered_container.h.

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

template<class K>

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

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

template<class K>

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

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

template<class K>

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

Definition at line 943 of file aged_ordered_container.h.

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

template<class K>

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

Definition at line 951 of file aged_ordered_container.h.

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

template<class K>

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

Definition at line 960 of file aged_ordered_container.h.

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

template<class K>

iterator beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::lowerBound ( K const & k )

Definition at line 969 of file aged_ordered_container.h.

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

template<class K>

const_iterator beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::lowerBound ( K const & k ) const

Definition at line 977 of file aged_ordered_container.h.

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

template<class K>

iterator beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::upperBound ( K const & k )

Definition at line 985 of file aged_ordered_container.h.

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

template<class K>

const_iterator beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::upperBound ( K const & k ) const

Definition at line 993 of file aged_ordered_container.h.

◆ keyComp()

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

key_compare beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::keyComp ( ) const

Definition at line 1005 of file aged_ordered_container.h.

◆ valueComp()

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

value_compare beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::valueComp ( ) const

Definition at line 1012 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::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator== ( AgedOrderedContainer< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const & other ) const

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

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

bool beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator!= ( AgedOrderedContainer< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const & other ) const

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

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

bool beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator< ( AgedOrderedContainer< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const & other ) const

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

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

bool beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator<= ( AgedOrderedContainer< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const & other ) const

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

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

bool beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator> ( AgedOrderedContainer< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const & other ) const

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

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

bool beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::operator>= ( AgedOrderedContainer< OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator > const & other ) const

Definition at line 1127 of file aged_ordered_container.h.

◆ touch() [3/3]

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

template<bool IsConst, class Iterator, class>

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

private

Definition at line 1744 of file aged_ordered_container.h.

◆ swapData() [1/2]

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

template<bool MaybePropagate>

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

privatenoexcept

Definition at line 1757 of file aged_ordered_container.h.

◆ swapData() [2/2]

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

template<bool MaybePropagate>

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

privatenoexcept

Definition at line 1768 of file aged_ordered_container.h.

◆ 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<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::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::at ( K const & k ) const

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

class beast::detail::AgedOrderedContainer::ChronologicalT beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::chronological

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

ConfigT beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::config_

private

Definition at line 1161 of file aged_ordered_container.h.

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

cont_type beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator >::cont_

mutableprivate

Definition at line 1162 of file aged_ordered_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

◆ ElementAllocator

◆ ElementAllocatorTraits

◆ key_compare

◆ value_compare

◆ allocator_type

◆ reference

◆ const_reference

◆ pointer

◆ const_pointer

◆ iterator

◆ const_iterator

◆ reverse_iterator

◆ const_reverse_iterator

Constructor & Destructor Documentation

◆ AgedOrderedContainer() [1/17]

◆ AgedOrderedContainer() [2/17]

◆ AgedOrderedContainer() [3/17]

◆ AgedOrderedContainer() [4/17]

◆ AgedOrderedContainer() [5/17]

◆ AgedOrderedContainer() [6/17]

◆ AgedOrderedContainer() [7/17]

◆ AgedOrderedContainer() [8/17]

◆ AgedOrderedContainer() [9/17]

◆ AgedOrderedContainer() [10/17]

◆ AgedOrderedContainer() [11/17]

◆ AgedOrderedContainer() [12/17]

◆ AgedOrderedContainer() [13/17]

◆ AgedOrderedContainer() [14/17]

◆ AgedOrderedContainer() [15/17]

◆ AgedOrderedContainer() [16/17]

◆ AgedOrderedContainer() [17/17]

◆ ~AgedOrderedContainer()

Member Function Documentation

◆ extract()

◆ newElement()

◆ deleteElement()

◆ unlinkAndDeleteElement()

◆ operator=() [1/3]

◆ operator=() [2/3]

◆ operator=() [3/3]

◆ getAllocator()

◆ clock() [1/2]

◆ clock() [2/2]

◆ at() [1/3]

◆ at() [2/3]

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ begin() [1/2]

◆ begin() [2/2]

◆ cbegin()

◆ end() [1/2]

◆ end() [2/2]

◆ cend()

◆ rbegin() [1/2]

◆ rbegin() [2/2]

◆ crbegin()

◆ rend() [1/2]