boost::itl::set< DomainT, Compare, Alloc > Class Template Reference

Addable, subractable and intersectable sets. More...

List of all members.

Public Member Functions
iterator	add (iterator prior, const element_type &element)
set &	add (const element_type &element)
void	add_intersection (set &section, const set &sectant) const
void	add_intersection (set &section, const element_type &element) const
std::string	as_string (const char *sep=" ") const
template<class Predicate >
set &	assign_if (const set &src, const Predicate &)
bool	contained_in (const set &super) const
bool	contains (const set &sub) const
bool	contains (const element_type &value) const
	Checks if the element value is in the set.
template<class Predicate >
set &	erase_if (const Predicate &)
set &	flip (const element_type &element)
bool	intersects (const element_type &element) const
bool	is_disjoint (const set &x2) const
size_t	iterative_size () const
set &	subtract (const element_type &element)
Static Public Member Functions
template<typename IteratorT >
static const data_type &	data_value (IteratorT value_)
template<typename LeftIterT , typename RightIterT >
static bool	key_less (LeftIterT lhs_, RightIterT rhs_)
template<typename IteratorT >
static const key_type &	key_value (IteratorT value_)
static value_type	make_element (const key_type &key_val, const data_type &)

---

Detailed Description

template<typename DomainT, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_ALLOC Alloc = std::allocator>
class boost::itl::set< DomainT, Compare, Alloc >

Addable, subractable and intersectable sets.

---

Member Function Documentation

template<typename DomainT , ITL_COMPARE Compare, ITL_ALLOC Alloc>

template<class Predicate >

set< DomainT, Compare, Alloc > & boost::itl::set< DomainT, Compare, Alloc >::assign_if	(	const set< DomainT, Compare, Alloc > &	src,
		const Predicate &	pred
	)			[inline]

Copy the elements in set src to which property hasProperty applies into *this set.

template<typename DomainT , ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_ALLOC Alloc = std::allocator>

bool boost::itl::set< DomainT, Compare, Alloc >::contains

(

const element_type &

value

)

const [inline]

Checks if the element value is in the set.

template<typename DomainT , ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_ALLOC Alloc = std::allocator>

bool boost::itl::set< DomainT, Compare, Alloc >::contained_in

(

const set< DomainT, Compare, Alloc > &

super

)

const [inline]

Is *this contained in super?

template<typename DomainT , ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_ALLOC Alloc = std::allocator>

bool boost::itl::set< DomainT, Compare, Alloc >::contains

(

const set< DomainT, Compare, Alloc > &

sub

)

const [inline]

Does *this contain sub?

template<typename DomainT , ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_ALLOC Alloc = std::allocator>

bool boost::itl::set< DomainT, Compare, Alloc >::is_disjoint

(

const set< DomainT, Compare, Alloc > &

x2

)

const [inline]

*this and x2 are disjoint, if their intersection is empty

template<typename DomainT , ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_ALLOC Alloc = std::allocator>

size_t boost::itl::set< DomainT, Compare, Alloc >::iterative_size

(

)

const [inline]

iterative_size() yields the number of elements that is visited throu complete iteration. For interval sets iterative_size() is different from size().

template<typename DomainT , ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_ALLOC Alloc = std::allocator>

set& boost::itl::set< DomainT, Compare, Alloc >::add

(

const element_type &

element

)

[inline]

Add an element to the set.

template<typename DomainT , ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_ALLOC Alloc = std::allocator>

iterator boost::itl::set< DomainT, Compare, Alloc >::add	(	iterator	prior,
		const element_type &	element
	)			[inline]

Add an element element after prior to the set.

template<typename DomainT , ITL_COMPARE Compare, ITL_ALLOC Alloc>

set< DomainT, Compare, Alloc > & boost::itl::set< DomainT, Compare, Alloc >::subtract

(

const element_type &

element

)

[inline]

Subtract an element from the set.

template<typename DomainT , ITL_COMPARE Compare, ITL_ALLOC Alloc>

template<class Predicate >

set< DomainT, Compare, Alloc > & boost::itl::set< DomainT, Compare, Alloc >::erase_if

(

const Predicate &

pred

)

[inline]

Erase the elements in *this set to which property hasProperty applies. Keep all the rest.

template<typename DomainT , ITL_COMPARE Compare, ITL_ALLOC Alloc>

void boost::itl::set< DomainT, Compare, Alloc >::add_intersection	(	set< DomainT, Compare, Alloc > &	section,
		const element_type &	element
	)			const [inline]

Add element to section, if element is in *this set

template<typename DomainT , ITL_COMPARE Compare, ITL_ALLOC Alloc>

void boost::itl::set< DomainT, Compare, Alloc >::add_intersection	(	set< DomainT, Compare, Alloc > &	section,
		const set< DomainT, Compare, Alloc > &	sectant
	)			const [inline]

The intersection of set sectant with *this set is added to section.

template<typename DomainT , ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_ALLOC Alloc = std::allocator>

bool boost::itl::set< DomainT, Compare, Alloc >::intersects

(

const element_type &

element

)

const [inline]

Returns true, if there is an intersection of element and *this set. Functions intersects and contains are identical on arguments of type element_type. Complexity: Logarithmic in container size.

template<typename DomainT , ITL_COMPARE Compare, ITL_ALLOC Alloc>

itl::set< DomainT, Compare, Alloc > & boost::itl::set< DomainT, Compare, Alloc >::flip

(

const element_type &

element

)

[inline]

If *this set contains element it is erased, otherwise it is added.

template<typename DomainT , ITL_COMPARE Compare, ITL_ALLOC Alloc>

std::string boost::itl::set< DomainT, Compare, Alloc >::as_string

(

const char *

sep = " "

)

const [inline]

Represent this set as a string

template<typename DomainT , ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_ALLOC Alloc = std::allocator>

template<typename IteratorT >

static const key_type& boost::itl::set< DomainT, Compare, Alloc >::key_value

(

IteratorT

value_

)

[inline, static]

key_value allows for a uniform access to key_values which is is used for common algorithms on sets and maps.

template<typename DomainT , ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_ALLOC Alloc = std::allocator>

template<typename IteratorT >

static const data_type& boost::itl::set< DomainT, Compare, Alloc >::data_value

(

IteratorT

value_

)

[inline, static]

data_value allows for a uniform access to data_values which is is used for common algorithms on sets and maps.

template<typename DomainT , ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_ALLOC Alloc = std::allocator>

template<typename LeftIterT , typename RightIterT >

static bool boost::itl::set< DomainT, Compare, Alloc >::key_less	(	LeftIterT	lhs_,
		RightIterT	rhs_
	)			[inline, static]

key_less allows for a uniform notation of key comparison which is used for common algorithms on sets and maps.

template<typename DomainT , ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_ALLOC Alloc = std::allocator>

static value_type boost::itl::set< DomainT, Compare, Alloc >::make_element	(	const key_type &	key_val,
		const data_type &
	)			[inline, static]

make_element allows for a uniform notation of key comparison which is used for common algorithms on sets and maps.

---

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

• boost/itl/set.hpp