boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc > Class Template Reference

Implements a set as a set of intervals (base class). More...

Inheritance diagram for boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >:

List of all members.

Public Types
typedef Alloc< interval_type >	allocator_type
	The allocator type of the set.
typedef itl::set< DomainT, Compare, Alloc >	atomized_type
	The atomized type representing the corresponding container of elements.
typedef DomainT	codomain_type
	The codomaintype is the same as domain_type.
typedef ImplSetT::const_iterator	const_iterator
	const_iterator for iteration over intervals
typedef ImplSetT::const_pointer	const_pointer
	const pointer type
typedef ImplSetT::const_reference	const_reference
	const reference type
typedef ImplSetT::const_reverse_iterator	const_reverse_iterator
	const_iterator for iteration over intervals
typedef ImplSetT::key_type	data_type
	data type of the implementing container
typedef interval_type::difference_type	difference_type
	The difference type of an interval which is sometimes different form the data_type.
typedef Alloc< DomainT >	domain_allocator_type
	allocator type of the corresponding element set
typedef DomainT	domain_type
	The domain type of the set.
typedef boost::itl::element_iterator < const_iterator >	element_const_iterator
	element const iterator: Depreciated, see documentation.
typedef boost::itl::element_iterator < const_reverse_iterator >	element_const_reverse_iterator
	element const reverse iterator: Depreciated, see documentation.
typedef boost::itl::element_iterator < iterator >	element_iterator
	element iterator: Depreciated, see documentation.
typedef boost::itl::element_iterator < reverse_iterator >	element_reverse_iterator
	element reverse iterator: Depreciated, see documentation.
typedef DomainT	element_type
	The element type of the set.
typedef ITL_IMPL_SPACE::set < interval_type, key_compare, allocator_type >	ImplSetT
	Container type for the implementation.
typedef exclusive_less < interval_type >	interval_compare
	Comparison functor for intervals.
typedef Interval< DomainT, Compare >	interval_type
	The interval type of the set.
typedef ImplSetT::iterator	iterator
	iterator for iteration over intervals
typedef exclusive_less < interval_type >	key_compare
	Comparison functor for keys.
typedef ImplSetT::key_type	key_type
	key type of the implementing container
typedef type	overloadable_type
	Auxilliary type for overloadresolution.
typedef ImplSetT::pointer	pointer
	pointer type
typedef ImplSetT::reference	reference
	reference type
typedef ImplSetT::reverse_iterator	reverse_iterator
	iterator for reverse iteration over intervals
typedef interval_type	segment_type
	The segment type of the set.
typedef interval_type::size_type	size_type
	The size type of an interval which is mostly std::size_t.
typedef SubType	sub_type
	The designated derived or sub_type of this base class.
typedef ImplSetT::value_type	value_type
	value type of the implementing container
Public Member Functions
iterator	add (iterator prior_, const segment_type &inter_val)
SubType &	add (const segment_type &inter_val)
SubType &	add (const element_type &key)
template<template< class DomT, ITL_COMPARE Comp, template< class DomT2, ITL_COMPARE >class Interv, ITL_ALLOC Allc > class IntervalSet>
void	add_intersection (interval_base_set &intersection, const IntervalSet< DomainT, Compare, Interval, Alloc > &sectant) const
void	add_intersection (interval_base_set &section, const segment_type &inter_val) const
void	add_intersection (interval_base_set &section, const element_type &key) const
const std::string	as_string () const
size_type	cardinality () const
void	clear ()
template<template< class DomT, ITL_COMPARE Comp, template< class DomT2, ITL_COMPARE >class Interv, ITL_ALLOC Allc > class IntervalSet>
bool	contained_in (const IntervalSet< DomainT, Compare, Interval, Alloc > &super) const
template<template< class DomT, ITL_COMPARE Comp, template< class DomT2, ITL_COMPARE >class Interv, ITL_ALLOC Allc > class IntervalSet>
bool	contains (const IntervalSet< DomainT, Compare, Interval, Alloc > &sub) const
bool	contains (const interval_base_set &sub) const
bool	contains (const segment_type &sub_interval) const
bool	contains (const element_type &key) const
bool	empty () const
void	erase (iterator first, iterator past)
void	erase (iterator position)
SubType &	erase (const segment_type &inter_val)
SubType &	erase (const element_type &key)
const_iterator	find (const element_type &key) const
DomainT	first () const
template<class SubType2 >
SubType &	flip (const interval_base_set< SubType2, DomainT, Compare, Interval, Alloc > &operand)
SubType &	flip (const segment_type &inter_val)
SubType &	flip (const element_type &key)
iterator	insert (iterator prior_, const segment_type &inter_val)
SubType &	insert (const segment_type &inter_val)
SubType &	insert (const element_type &key)
bool	intersects (const interval_type &inter_val) const
bool	intersects (const element_type &key) const
	interval_base_set (const interval_base_set &src)
	interval_base_set ()
std::size_t	interval_count () const
std::size_t	iterative_size () const
typedef	ITL_COMPARE_DOMAIN (Compare, DomainT) domain_compare
	Comparison functor for domain values.
interval_base_set &	join ()
DomainT	last () const
difference_type	length () const
DomainT	lower () const
interval_base_set &	operator= (const interval_base_set &src)
size_type	size () const
SubType &	subtract (const segment_type &inter_val)
SubType &	subtract (const element_type &key)
void	swap (interval_base_set &x)
void	uniform_bounds (itl::bound_type bounded)
DomainT	upper () const

---

Detailed Description

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

Implements a set as a set of intervals (base class).

---

Member Typedef Documentation

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

typedef SubType boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::sub_type

The designated derived or sub_type of this base class.

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

typedef type boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::overloadable_type

Auxilliary type for overloadresolution.

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

typedef itl::set<DomainT,Compare,Alloc> boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::atomized_type

The atomized type representing the corresponding container of elements.

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

typedef DomainT boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::domain_type

The domain type of the set.

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

typedef DomainT boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::codomain_type

The codomaintype is the same as domain_type.

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

typedef DomainT boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::element_type

The element type of the set.

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

typedef Interval<DomainT,Compare> boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::interval_type

The interval type of the set.

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

typedef interval_type boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::segment_type

The segment type of the set.

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

typedef interval_type::difference_type boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::difference_type

The difference type of an interval which is sometimes different form the data_type.

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

typedef interval_type::size_type boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::size_type

The size type of an interval which is mostly std::size_t.

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

typedef exclusive_less<interval_type> boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::interval_compare

Comparison functor for intervals.

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

typedef exclusive_less<interval_type> boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::key_compare

Comparison functor for keys.

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

typedef Alloc<interval_type> boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::allocator_type

The allocator type of the set.

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

typedef Alloc<DomainT> boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::domain_allocator_type

allocator type of the corresponding element set

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

typedef ITL_IMPL_SPACE::set<interval_type,key_compare,allocator_type> boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::ImplSetT

Container type for the implementation.

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

typedef ImplSetT::key_type boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::key_type

key type of the implementing container

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

typedef ImplSetT::key_type boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::data_type

data type of the implementing container

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

typedef ImplSetT::value_type boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::value_type

value type of the implementing container

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

typedef ImplSetT::pointer boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::pointer

pointer type

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

typedef ImplSetT::const_pointer boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::const_pointer

const pointer type

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

typedef ImplSetT::reference boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::reference

reference type

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

typedef ImplSetT::const_reference boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::const_reference

const reference type

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

typedef ImplSetT::iterator boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::iterator

iterator for iteration over intervals

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

typedef ImplSetT::const_iterator boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::const_iterator

const_iterator for iteration over intervals

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

typedef ImplSetT::reverse_iterator boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::reverse_iterator

iterator for reverse iteration over intervals

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

typedef ImplSetT::const_reverse_iterator boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::const_reverse_iterator

const_iterator for iteration over intervals

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

typedef boost::itl::element_iterator<iterator> boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::element_iterator

element iterator: Depreciated, see documentation.

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

typedef boost::itl::element_iterator<const_iterator> boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::element_const_iterator

element const iterator: Depreciated, see documentation.

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

typedef boost::itl::element_iterator<reverse_iterator> boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::element_reverse_iterator

element reverse iterator: Depreciated, see documentation.

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

typedef boost::itl::element_iterator<const_reverse_iterator> boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::element_const_reverse_iterator

element const reverse iterator: Depreciated, see documentation.

---

Constructor & Destructor Documentation

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

boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::interval_base_set

(

)

[inline]

Default constructor for the empty object

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

boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::interval_base_set

(

const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &

src

)

[inline]

Copy constructor

---

Member Function Documentation

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

typedef boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::ITL_COMPARE_DOMAIN	(	Compare	,
		DomainT
	)

Comparison functor for domain values.

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

interval_base_set& boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::operator=

(

const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &

src

)

[inline]

Assignment operator

Reimplemented in boost::itl::interval_set< DomainT, Compare, Interval, Alloc >, boost::itl::separate_interval_set< DomainT, Compare, Interval, Alloc >, and boost::itl::split_interval_set< DomainT, Compare, Interval, Alloc >.

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

void boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::swap

(

interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &

x

)

[inline]

swap the content of containers

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

void boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::clear

(

)

[inline]

sets the container empty

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

bool boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::empty

(

)

const [inline]

is the container empty?

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

bool boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::contains

(

const element_type &

key

)

const [inline]

Does the container contain the element key ?

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

bool boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::contains

(

const segment_type &

sub_interval

)

const [inline]

Does the container contain the interval sub_interval ?

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

bool boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::contains

(

const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &

sub

)

const [inline]

Does the container contain the subcontainer sub ?

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

template<template< class DomT, ITL_COMPARE Comp, template< class DomT2, ITL_COMPARE >class Interv, ITL_ALLOC Allc > class IntervalSet>

bool boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::contains

(

const IntervalSet< DomainT, Compare, Interval, Alloc > &

sub

)

const [inline]

Does *this container contain sub?

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

template<template< class DomT, ITL_COMPARE Comp, template< class DomT2, ITL_COMPARE >class Interv, ITL_ALLOC Allc > class IntervalSet>

bool boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::contained_in

(

const IntervalSet< DomainT, Compare, Interval, Alloc > &

super

)

const [inline]

Is *this container contained in super?

template<class SubType , class DomainT , ITL_COMPARE Compare, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::size_type boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::cardinality

(

)

const [inline]

Number of elements in the set (cardinality). Infinite for continuous domain datatyps

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

size_type boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::size

(

)

const [inline]

An interval set's size is it's cardinality

template<class SubType , class DomainT , ITL_COMPARE Compare, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::difference_type boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::length

(

)

const [inline]

The length of the interval container which is the sum of interval lengths

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

std::size_t boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::interval_count

(

)

const [inline]

Number of intervals which is also the size of the iteration over the object

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

std::size_t boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::iterative_size

(

)

const [inline]

Size of the iteration over this container

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

DomainT boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::lower

(

)

const [inline]

lower bound of all intervals in the object

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

DomainT boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::upper

(

)

const [inline]

upper bound of all intervals in the object

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

DomainT boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::first

(

)

const [inline]

Smallest element of the set (wrt. the partial ordering on DomainT). first() does not exist for continuous datatypes and open interval bounds.

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

DomainT boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::last

(

)

const [inline]

Largest element of the set (wrt. the partial ordering on DomainT). last() does not exist for continuous datatypes and open interval bounds.

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

const_iterator boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::find

(

const element_type &

key

)

const [inline]

Find the interval value pair, that contains element key

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

SubType& boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::add

(

const element_type &

key

)

[inline]

Add a single element key to the set

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

SubType& boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::add

(

const segment_type &

inter_val

)

[inline]

Add an interval of elements inter_val to the set

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

iterator boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::add	(	iterator	prior_,
		const segment_type &	inter_val
	)			[inline]

Add an interval of elements inter_val to the set. Iterator prior_ is a hint to the position inter_val can be inserted after.

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

SubType& boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::subtract

(

const element_type &

key

)

[inline]

Subtract a single element key from the set

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

SubType& boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::subtract

(

const segment_type &

inter_val

)

[inline]

Subtract an interval of elements inter_val from the set

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

SubType& boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::insert

(

const element_type &

key

)

[inline]

Insert an element key into the set

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

SubType& boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::insert

(

const segment_type &

inter_val

)

[inline]

Insert an interval of elements inter_val to the set

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

iterator boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::insert	(	iterator	prior_,
		const segment_type &	inter_val
	)			[inline]

Insert an interval of elements inter_val to the set. Iterator prior_ is a hint to the position inter_val can be inserted after.

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

SubType& boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::erase

(

const element_type &

key

)

[inline]

Erase an element key from the set

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

SubType& boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::erase

(

const segment_type &

inter_val

)

[inline]

Erase an interval of elements inter_val from the set

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

void boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::erase

(

iterator

position

)

[inline]

Erase the interval that iterator position points to.

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

void boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::erase	(	iterator	first,
		iterator	past
	)			[inline]

Erase all intervals in the range [first,past) of iterators.

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

void boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::add_intersection	(	interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &	section,
		const element_type &	key
	)			const [inline]

The intersection of key in *this set is added to section. The function can be used as a find function.

template<class SubType , class DomainT , ITL_COMPARE Compare, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

void boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::add_intersection	(	interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &	section,
		const segment_type &	inter_val
	)			const [inline]

The intersection of inter_val in *this set is added to section.

template<class SubType , class DomainT , ITL_COMPARE Compare, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

template<template< class DomT, ITL_COMPARE Comp, template< class DomT2, ITL_COMPARE >class Interv, ITL_ALLOC Allc > class IntervalSet>

void boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::add_intersection	(	interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &	intersection,
		const IntervalSet< DomainT, Compare, Interval, Alloc > &	sectant
	)			const [inline]

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

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

bool boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::intersects

(

const element_type &

key

)

const [inline]

Returns true, if element key is found in *this map. Complexity: logarithmic.

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

bool boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::intersects

(

const interval_type &

inter_val

)

const [inline]

Returns true, if inter_val intersects with *this map. Complexity: logarithmic.

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

SubType& boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::flip

(

const element_type &

key

)

[inline]

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

template<class SubType , class DomainT , ITL_COMPARE Compare, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

SubType & boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::flip

(

const segment_type &

inter_val

)

[inline]

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

template<class SubType , class DomainT , ITL_COMPARE Compare, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

template<class SubType2 >

SubType & boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::flip

(

const interval_base_set< SubType2, DomainT, Compare, Interval, Alloc > &

operand

)

[inline]

The intersection of *this and operand is erased from *this. The complemenary elements are added to *this.

template<class SubType , class DomainT , ITL_COMPARE Compare, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

interval_base_set< SubType, DomainT, Compare, Interval, Alloc > & boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::join

(

)

[inline]

Join bordering intervals

template<class SubType , class DomainT , ITL_COMPARE Compare, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

void boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::uniform_bounds

(

itl::bound_type

bounded

)

[inline]

Set interval bounds to the type bt for intervals in the set. Interval bounds of different types are created by opeations on interval sets. This function allows to reset them uniformly without, of course, changing their value. This is only possible for discrete domain datatypes.

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

const std::string boost::itl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::as_string

(

)

const [inline]

Interval container's string representation

---

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

• boost/itl/interval_base_set.hpp