TwiceAsNice: Nice::set< Key, Compare, Allocator > Class Template Reference

TwiceAsNice 2019-02-18

#include <Set.h>

Collaboration diagram for Nice::set< Key, Compare, Allocator >:

Collaboration graph

Public Types
typedef std::set< Key, Compare, Allocator >::iterator	iterator

typedef std::set< Key, Compare, Allocator >::const_iterator	const_iterator

typedef std::set< Key, Compare, Allocator >::reverse_iterator	reverse_iterator

typedef std::set< Key, Compare, Allocator >::const_reverse_iterator	const_reverse_iterator

typedef std::set< Key, Compare, Allocator >::allocator_type	allocator_type

typedef std::set< Key, Compare, Allocator >::size_type	size_type

typedef std::set< Key, Compare, Allocator >::key_compare	key_compare

typedef std::set< Key, Compare, Allocator >::value_compare	value_compare

Public Member Functions
	set (const Compare &comp=Compare(), const Allocator &alloc=Allocator())

template<class InputIterator >
	set (InputIterator first, InputIterator last, const Compare &comp=Compare(), const Allocator &alloc=Allocator())

	set (const Nice::set< Key, Compare, Allocator > &x)

Nice::set< Key, Compare, Allocator > &	operator= (const Nice::set< Key, Compare, Allocator > &x)

	~set (void)

iterator	begin (void)

const_iterator	begin (void) const

iterator	end (void)

const_iterator	end (void) const

reverse_iterator	rbegin (void)

const_reverse_iterator	rbegin (void) const

reverse_iterator	rend (void)

const_reverse_iterator	rend (void) const

size_type	size (void) const

size_type	max_size (void) const

bool	empty (void) const

std::pair< iterator, bool >	insert (const Key &x)

iterator	insert (iterator position, const Key &x)

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

void	erase (iterator pos)

size_type	erase (const Key &x)

void	erase (iterator begin, iterator end)

void	swap (Nice::set< Key, Compare, Allocator > &x)

void	clear (void)

key_compare	key_comp (void) const

value_compare	value_comp (void) const

const_iterator	find (const Key &x) const

iterator	find (const Key &x)

size_type	count (const Key &x) const

const_iterator	lower_bound (const Key &x) const

iterator	lower_bound (const Key &x)

const_iterator	upper_bound (const Key &x) const

iterator	upper_bound (const Key &x)

std::pair< const_iterator, const_iterator >	equal_range (const Key &x) const

std::pair< iterator, iterator >	equal_range (const Key &x)

allocator_type	get_allocator (void) const

	operator std::set< Key, Compare, Allocator > ()

Private Attributes
std::set< Key, Compare, Allocator >	storage

boost::mutex	mutex

Member Typedef Documentation

◆ allocator_type

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

typedef std::set<Key, Compare, Allocator>::allocator_type Nice::set< Key, Compare, Allocator >::allocator_type

◆ const_iterator

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

typedef std::set<Key, Compare, Allocator>::const_iterator Nice::set< Key, Compare, Allocator >::const_iterator

◆ const_reverse_iterator

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

typedef std::set<Key, Compare, Allocator>::const_reverse_iterator Nice::set< Key, Compare, Allocator >::const_reverse_iterator

◆ iterator

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

typedef std::set<Key, Compare, Allocator>::iterator Nice::set< Key, Compare, Allocator >::iterator

◆ key_compare

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

typedef std::set<Key, Compare, Allocator>::key_compare Nice::set< Key, Compare, Allocator >::key_compare

◆ reverse_iterator

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

typedef std::set<Key, Compare, Allocator>::reverse_iterator Nice::set< Key, Compare, Allocator >::reverse_iterator

◆ size_type

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

typedef std::set<Key, Compare, Allocator>::size_type Nice::set< Key, Compare, Allocator >::size_type

◆ value_compare

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

typedef std::set<Key, Compare, Allocator>::value_compare Nice::set< Key, Compare, Allocator >::value_compare

Constructor & Destructor Documentation

◆ set() [1/3]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

Nice::set< Key, Compare, Allocator >::set	(	const Compare &	comp = `Compare()`,
		const Allocator &	alloc = `Allocator()`
	)

inlineexplicit

◆ set() [2/3]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

template<class InputIterator >

Nice::set< Key, Compare, Allocator >::set	(	InputIterator	first,
		InputIterator	last,
		const Compare &	comp = `Compare()`,
		const Allocator &	alloc = `Allocator()`
	)

inline

◆ set() [3/3]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

Nice::set< Key, Compare, Allocator >::set ( const Nice::set< Key, Compare, Allocator > & x )

inline

◆ ~set()

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

Nice::set< Key, Compare, Allocator >::~set ( void )

inline

Member Function Documentation

◆ begin() [1/2]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

iterator Nice::set< Key, Compare, Allocator >::begin ( void )

inline

◆ begin() [2/2]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

const_iterator Nice::set< Key, Compare, Allocator >::begin ( void ) const

inline

◆ clear()

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

void Nice::set< Key, Compare, Allocator >::clear ( void )

inline

◆ count()

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

size_type Nice::set< Key, Compare, Allocator >::count ( const Key & x ) const

inline

◆ empty()

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

bool Nice::set< Key, Compare, Allocator >::empty ( void ) const

inline

◆ end() [1/2]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

iterator Nice::set< Key, Compare, Allocator >::end ( void )

inline

◆ end() [2/2]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

const_iterator Nice::set< Key, Compare, Allocator >::end ( void ) const

inline

◆ equal_range() [1/2]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

std::pair<const_iterator,const_iterator> Nice::set< Key, Compare, Allocator >::equal_range ( const Key & x ) const

inline

◆ equal_range() [2/2]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

std::pair<iterator,iterator> Nice::set< Key, Compare, Allocator >::equal_range ( const Key & x )

inline

◆ erase() [1/3]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

void Nice::set< Key, Compare, Allocator >::erase ( iterator pos )

inline

◆ erase() [2/3]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

size_type Nice::set< Key, Compare, Allocator >::erase ( const Key & x )

inline

◆ erase() [3/3]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

void Nice::set< Key, Compare, Allocator >::erase	(	iterator	begin,
		iterator	end
	)

inline

◆ find() [1/2]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

const_iterator Nice::set< Key, Compare, Allocator >::find ( const Key & x ) const

inline

◆ find() [2/2]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

iterator Nice::set< Key, Compare, Allocator >::find ( const Key & x )

inline

◆ get_allocator()

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

allocator_type Nice::set< Key, Compare, Allocator >::get_allocator ( void ) const

inline

◆ insert() [1/3]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

std::pair<iterator, bool> Nice::set< Key, Compare, Allocator >::insert ( const Key & x )

inline

◆ insert() [2/3]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

iterator Nice::set< Key, Compare, Allocator >::insert	(	iterator	position,
		const Key &	x
	)

inline

◆ insert() [3/3]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

template<class InputIterator >

void Nice::set< Key, Compare, Allocator >::insert	(	InputIterator	first,
		InputIterator	last
	)

inline

◆ key_comp()

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

key_compare Nice::set< Key, Compare, Allocator >::key_comp ( void ) const

inline

◆ lower_bound() [1/2]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

const_iterator Nice::set< Key, Compare, Allocator >::lower_bound ( const Key & x ) const

inline

◆ lower_bound() [2/2]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

iterator Nice::set< Key, Compare, Allocator >::lower_bound ( const Key & x )

inline

◆ max_size()

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

size_type Nice::set< Key, Compare, Allocator >::max_size ( void ) const

inline

◆ operator std::set< Key, Compare, Allocator >()

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

Nice::set< Key, Compare, Allocator >::operator std::set< Key, Compare, Allocator > ( )

inline

◆ operator=()

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

Nice::set<Key, Compare, Allocator>& Nice::set< Key, Compare, Allocator >::operator= ( const Nice::set< Key, Compare, Allocator > & x )

inline

◆ rbegin() [1/2]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

reverse_iterator Nice::set< Key, Compare, Allocator >::rbegin ( void )

inline

◆ rbegin() [2/2]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

const_reverse_iterator Nice::set< Key, Compare, Allocator >::rbegin ( void ) const

inline

◆ rend() [1/2]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

reverse_iterator Nice::set< Key, Compare, Allocator >::rend ( void )

inline

◆ rend() [2/2]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

const_reverse_iterator Nice::set< Key, Compare, Allocator >::rend ( void ) const

inline

◆ size()

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

size_type Nice::set< Key, Compare, Allocator >::size ( void ) const

inline

◆ swap()

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

void Nice::set< Key, Compare, Allocator >::swap ( Nice::set< Key, Compare, Allocator > & x )

inline

◆ upper_bound() [1/2]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

const_iterator Nice::set< Key, Compare, Allocator >::upper_bound ( const Key & x ) const

inline

◆ upper_bound() [2/2]

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

iterator Nice::set< Key, Compare, Allocator >::upper_bound ( const Key & x )

inline

◆ value_comp()

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

value_compare Nice::set< Key, Compare, Allocator >::value_comp ( void ) const

inline

Member Data Documentation

◆ mutex

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

boost::mutex Nice::set< Key, Compare, Allocator >::mutex

mutableprivate

◆ storage

template<class Key , class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

std::set< Key, Compare, Allocator > Nice::set< Key, Compare, Allocator >::storage

private

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

TwiceAsNice/nice/src/libNice/Nice/Util/Set.h