boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > Class Template Reference

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

Inheritance diagram for boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >:

List of all members.

Public Types
typedef Alloc< std::pair < const interval_type, codomain_type > >	allocator_type
	The allocator type of the set.
typedef itl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >	atomized_type
	The atomized type representing the corresponding container of elements.
typedef CodomainT	codomain_type
	Domain type (type of the keys) of the map.
typedef ImplMapT::const_iterator	const_iterator
	const_iterator for iteration over intervals
typedef ImplMapT::const_pointer	const_pointer
	const pointer type
typedef ImplMapT::const_reference	const_reference
	const reference type
typedef ImplMapT::const_reverse_iterator	const_reverse_iterator
	const_iterator for iteration over intervals
typedef ImplMapT::value_type::second_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 domain_type.
typedef mapping_pair < domain_type, codomain_type >	domain_mapping_type
	Auxiliary type to help the compiler resolve ambiguities when using std::make_pair.
typedef DomainT	domain_type
	Domain type (type of the keys) of the map.
typedef boost::itl::element_iterator < const_iterator >	element_const_iterator
	const element 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 domain_mapping_type	element_type
	Conceptual is a map a set of elements of type element_type.
typedef ITL_IMPL_SPACE::map < interval_type, codomain_type, key_compare, allocator_type >	ImplMapT
	Container type for the implementation.
typedef exclusive_less < interval_type >	interval_compare
	Comparison functor for intervals which are keys as well.
typedef std::pair < interval_type, CodomainT >	interval_mapping_type
	Auxiliary type for overload resolution.
typedef Interval< DomainT, Compare >	interval_type
	The interval type of the map.
typedef inverse < codomain_combine >::type	inverse_codomain_combine
	Inverse Combine functor for codomain value aggregation.
typedef inverse < codomain_intersect >::type	inverse_codomain_intersect
	Inverse Combine functor for codomain value intersection.
typedef ImplMapT::iterator	iterator
	iterator for iteration over intervals
typedef exclusive_less < interval_type >	key_compare
	Comparison functor for keys.
typedef ImplMapT::key_type	key_type
	key type of the implementing container
typedef type	overloadable_type
	Auxilliary type for overloadresolution.
typedef ImplMapT::pointer	pointer
	pointer type
typedef ImplMapT::reference	reference
	reference type
typedef ImplMapT::reverse_iterator	reverse_iterator
	iterator for reverse iteration over intervals
typedef std::pair < interval_type, CodomainT >	segment_type
	Type of an interval containers segment, that is spanned by an interval.
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 Traits	traits
	Traits of an itl map.
typedef ImplMapT::value_type	value_type
	value type of the implementing container
Public Member Functions
void	absorb_neutrons ()
iterator	add (iterator prior_, const segment_type &interval_value_pair)
SubType &	add (const segment_type &interval_value_pair)
SubType &	add (const element_type &key_value_pair)
template<template< class DomT, class CodomT, class Trts, ITL_COMPARE Comp, ITL_COMBINE Combi, ITL_SECTION Sect, template< class DomT2, ITL_COMPARE >class Interv, ITL_ALLOC Allc > class IntervalMap>
void	add_intersection (interval_base_map &intersection, const IntervalMap< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &sectant) const
template<template< class DomT, ITL_COMPARE Comp, template< class DomT2, ITL_COMPARE >class Interv, ITL_ALLOC Allc > class IntervalSet>
void	add_intersection (interval_base_map &section, const IntervalSet< DomainT, Compare, Interval, Alloc > &sectant) const
void	add_intersection (interval_base_map &section, const interval_type &inter_val) const
void	add_intersection (interval_base_map &section, const segment_type &interval_value_pair) const
void	add_intersection (interval_base_map &section, const element_type &key_value_pair) const
void	add_intersection (interval_base_map &section, const domain_type &key) const
std::string	as_string () const
template<class Predicate >
SubType &	assign_if (const interval_base_map &src, const Predicate &pred)
size_type	cardinality () const
void	clear ()
template<class MapType >
bool	contained_in (const interval_base_map< MapType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &super) const
template<class MapType >
bool	contains (const interval_base_map< MapType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &sub) const
bool	contains (const segment_type &interval_value_pair) const
bool	contains (const element_type &key_value_pair) const
template<class SetType >
bool	contains (const interval_base_set< SetType, DomainT, Compare, Interval, Alloc > &sub_set) const
bool	contains (const interval_type &sub_interval) const
bool	contains (const domain_type &key) const
template<template< class DomT, ITL_COMPARE Comp, template< class DomT2, ITL_COMPARE >class Interv, ITL_ALLOC Allc > class IntervalSet>
void	domain (IntervalSet< DomainT, Compare, Interval, Alloc > &dom) const
bool	empty () const
void	erase (iterator first, iterator past)
void	erase (iterator position)
SubType &	erase (const interval_base_map &eraser)
template<class SetSubType >
SubType &	erase (const interval_base_set< SetSubType, DomainT, Compare, Interval, Alloc > &operand)
SubType &	erase (const interval_type &inter_val)
SubType &	erase (const domain_type &key)
SubType &	erase (const segment_type &interval_value_pair)
SubType &	erase (const element_type &key_value_pair)
template<class Predicate >
SubType &	erase_if (const Predicate &pred)
const_iterator	find (const domain_type &key) const
DomainT	first () const
template<class SubType2 >
SubType &	flip (const interval_base_map< SubType2, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &operand)
SubType &	flip (const segment_type &interval_value_pair)
SubType &	flip (const element_type &key_value_pair)
iterator	insert (iterator prior_, const segment_type &interval_value_pair)
SubType &	insert (const segment_type &interval_value_pair)
SubType &	insert (const element_type &key_value_pair)
bool	intersects (const segment_type &interval_value_pair) const
bool	intersects (const element_type &key_value_pair) const
bool	intersects (const interval_type &inter_val) const
bool	intersects (const domain_type &key) const
	interval_base_map (const interval_base_map &src)
	interval_base_map ()
size_t	interval_count () const
size_t	iterative_size () const
typedef	ITL_COMBINE_CODOMAIN (Combine, CodomainT) codomain_combine
	Combine functor for codomain value aggregation.
typedef	ITL_COMPARE_DOMAIN (Compare, DomainT) domain_compare
	Comparison functor for domain values.
typedef	ITL_SECTION_CODOMAIN (Section, CodomainT) codomain_intersect
	Intersection functor for codomain values.
interval_base_map &	join ()
DomainT	last () const
difference_type	length () const
DomainT	lower () const
codomain_type	operator() (const domain_type &key) const
interval_base_map &	operator= (const interval_base_map &src)
SubType &	set (const segment_type &interval_value_pair)
SubType &	set (const element_type &key_value_pair)
size_type	size () const
SubType &	subtract (const segment_type &interval_value_pair)
SubType &	subtract (const element_type &key_value_pair)
void	swap (interval_base_map &object)
void	uniform_bounds (itl::bound_type bounded)
DomainT	upper () const

---

Detailed Description

template<class SubType, typename DomainT, typename CodomainT, class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>
class boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >

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

---

Member Typedef Documentation

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef SubType boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::sub_type

The designated derived or sub_type of this base class.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef type boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::overloadable_type

Auxilliary type for overloadresolution.

Reimplemented in boost::itl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::interval_map< ItvDomTV, episode_product< ItvDomTV, TypeDomTV > >, and boost::itl::interval_map< DomainT, BitSetT, boost::itl::partial_absorber, std::less, boost::itl::inplace_bit_add< Type >, boost::itl::inplace_bit_and< Type > >.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef Traits boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::traits

Traits of an itl map.

Reimplemented in boost::itl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::interval_map< ItvDomTV, episode_product< ItvDomTV, TypeDomTV > >, and boost::itl::interval_map< DomainT, BitSetT, boost::itl::partial_absorber, std::less, boost::itl::inplace_bit_add< Type >, boost::itl::inplace_bit_and< Type > >.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef itl::map<DomainT,CodomainT, Traits,Compare,Combine,Section,Alloc> boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::atomized_type

The atomized type representing the corresponding container of elements.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef DomainT boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::domain_type

Domain type (type of the keys) of the map.

Reimplemented in boost::itl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef CodomainT boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::codomain_type

Domain type (type of the keys) of the map.

Reimplemented in boost::itl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef mapping_pair<domain_type,codomain_type> boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::domain_mapping_type

Auxiliary type to help the compiler resolve ambiguities when using std::make_pair.

Reimplemented in boost::itl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::interval_map< ItvDomTV, episode_product< ItvDomTV, TypeDomTV > >, and boost::itl::interval_map< DomainT, BitSetT, boost::itl::partial_absorber, std::less, boost::itl::inplace_bit_add< Type >, boost::itl::inplace_bit_and< Type > >.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef domain_mapping_type boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::element_type

Conceptual is a map a set of elements of type element_type.

Reimplemented in boost::itl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::interval_map< ItvDomTV, episode_product< ItvDomTV, TypeDomTV > >, and boost::itl::interval_map< DomainT, BitSetT, boost::itl::partial_absorber, std::less, boost::itl::inplace_bit_add< Type >, boost::itl::inplace_bit_and< Type > >.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef Interval<DomainT,Compare> boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::interval_type

The interval type of the map.

Reimplemented in boost::itl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::interval_map< ItvDomTV, episode_product< ItvDomTV, TypeDomTV > >, and boost::itl::interval_map< DomainT, BitSetT, boost::itl::partial_absorber, std::less, boost::itl::inplace_bit_add< Type >, boost::itl::inplace_bit_and< Type > >.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef std::pair<interval_type,CodomainT> boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::interval_mapping_type

Auxiliary type for overload resolution.

Reimplemented in boost::itl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::interval_map< ItvDomTV, episode_product< ItvDomTV, TypeDomTV > >, and boost::itl::interval_map< DomainT, BitSetT, boost::itl::partial_absorber, std::less, boost::itl::inplace_bit_add< Type >, boost::itl::inplace_bit_and< Type > >.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef std::pair<interval_type,CodomainT> boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::segment_type

Type of an interval containers segment, that is spanned by an interval.

Reimplemented in boost::itl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::interval_map< ItvDomTV, episode_product< ItvDomTV, TypeDomTV > >, and boost::itl::interval_map< DomainT, BitSetT, boost::itl::partial_absorber, std::less, boost::itl::inplace_bit_add< Type >, boost::itl::inplace_bit_and< Type > >.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef interval_type::difference_type boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::difference_type

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

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef interval_type::size_type boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::size_type

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

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef inverse<codomain_combine>::type boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::inverse_codomain_combine

Inverse Combine functor for codomain value aggregation.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef inverse<codomain_intersect>::type boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::inverse_codomain_intersect

Inverse Combine functor for codomain value intersection.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef exclusive_less<interval_type> boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::interval_compare

Comparison functor for intervals which are keys as well.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef exclusive_less<interval_type> boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::key_compare

Comparison functor for keys.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef Alloc<std::pair<const interval_type, codomain_type> > boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::allocator_type

The allocator type of the set.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef ITL_IMPL_SPACE::map<interval_type,codomain_type, key_compare,allocator_type> boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::ImplMapT

Container type for the implementation.

Reimplemented in boost::itl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::interval_map< ItvDomTV, episode_product< ItvDomTV, TypeDomTV > >, and boost::itl::interval_map< DomainT, BitSetT, boost::itl::partial_absorber, std::less, boost::itl::inplace_bit_add< Type >, boost::itl::inplace_bit_and< Type > >.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef ImplMapT::key_type boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::key_type

key type of the implementing container

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef ImplMapT::value_type boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::value_type

value type of the implementing container

Reimplemented in boost::itl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::product_history< ItvDomTV, TypeDomTV >, boost::itl::interval_map< ItvDomTV, episode_product< ItvDomTV, TypeDomTV > >, boost::itl::interval_map< DomainT, BitSetT, boost::itl::partial_absorber, std::less, boost::itl::inplace_bit_add< Type >, boost::itl::inplace_bit_and< Type > >, and boost::itl::product_history< Time, HospitalTypeDomain >.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef ImplMapT::value_type::second_type boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::data_type

data type of the implementing container

Reimplemented in boost::itl::product_history< ItvDomTV, TypeDomTV >, and boost::itl::product_history< Time, HospitalTypeDomain >.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef ImplMapT::pointer boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::pointer

pointer type

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef ImplMapT::const_pointer boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::const_pointer

const pointer type

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef ImplMapT::reference boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::reference

reference type

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef ImplMapT::const_reference boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::const_reference

const reference type

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef ImplMapT::iterator boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::iterator

iterator for iteration over intervals

Reimplemented in boost::itl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, boost::itl::interval_map< ItvDomTV, episode_product< ItvDomTV, TypeDomTV > >, and boost::itl::interval_map< DomainT, BitSetT, boost::itl::partial_absorber, std::less, boost::itl::inplace_bit_add< Type >, boost::itl::inplace_bit_and< Type > >.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef ImplMapT::const_iterator boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::const_iterator

const_iterator for iteration over intervals

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef ImplMapT::reverse_iterator boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::reverse_iterator

iterator for reverse iteration over intervals

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef ImplMapT::const_reverse_iterator boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::const_reverse_iterator

const_iterator for iteration over intervals

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef boost::itl::element_iterator<iterator> boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::element_iterator

element iterator: Depreciated, see documentation.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef boost::itl::element_iterator<const_iterator> boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::element_const_iterator

const element iterator: Depreciated, see documentation.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef boost::itl::element_iterator<reverse_iterator> boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::element_reverse_iterator

element reverse iterator: Depreciated, see documentation.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), 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_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::element_const_reverse_iterator

element const reverse iterator: Depreciated, see documentation.

---

Constructor & Destructor Documentation

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::interval_base_map

(

)

[inline]

Default constructor for the empty object

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::interval_base_map

(

const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &

src

)

[inline]

Copy constructor

---

Member Function Documentation

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::ITL_COMPARE_DOMAIN	(	Compare	,
		DomainT
	)

Comparison functor for domain values.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::ITL_COMBINE_CODOMAIN	(	Combine	,
		CodomainT
	)

Combine functor for codomain value aggregation.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

typedef boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::ITL_SECTION_CODOMAIN	(	Section	,
		CodomainT
	)

Intersection functor for codomain values.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

interval_base_map& boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::operator=

(

const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &

src

)

[inline]

Assignment operator

Reimplemented in boost::itl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, and boost::itl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

void boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::swap

(

interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &

object

)

[inline]

swap the content of containers

template<class SubType , class DomainT , class CodomainT , class Traits , ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

template<class Predicate >

SubType & boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::assign_if	(	const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &	src,
		const Predicate &	pred
	)			[inline]

Copy all elements if predicate pred holds

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

void boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::clear

(

)

[inline]

clear the map

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

bool boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::empty

(

)

const [inline]

is the map empty?

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

bool boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::contains

(

const domain_type &

key

)

const [inline]

Does the map contain the domain element key?

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

bool boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::contains

(

const interval_type &

sub_interval

)

const [inline]

Does the map contain the interval sub_interval ?

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

template<class SetType >

bool boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::contains

(

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

sub_set

)

const [inline]

Does the map contain the key key set sub_set ?

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

bool boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::contains

(

const element_type &

key_value_pair

)

const [inline]

Does the map contain the key_value_pair = (key,value)?

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

bool boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::contains

(

const segment_type &

interval_value_pair

)

const

Does the map contain all element value pairs represented by the interval_value_pair ?

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

template<class MapType >

bool boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::contains

(

const interval_base_map< MapType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &

sub

)

const [inline]

Does *this container contain sub?

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

template<class MapType >

bool boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::contained_in

(

const interval_base_map< MapType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &

super

)

const [inline]

*this is subset of super?

template<class SubType , class DomainT , class CodomainT , class Traits , ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::size_type boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::cardinality

(

)

const [inline]

Number of elements in the map (cardinality).

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

size_type boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::size

(

)

const [inline]

An interval map's size is it's cardinality

template<class SubType , class DomainT , class CodomainT , class Traits , ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::difference_type boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::length

(

)

const [inline]

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

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

size_t boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::interval_count

(

)

const [inline]

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

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

size_t boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::iterative_size

(

)

const [inline]

Size of the iteration over this container

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

DomainT boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::lower

(

)

const [inline]

Lower bound of the first interval

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

DomainT boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::upper

(

)

const [inline]

Upper bound of the last interval

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

DomainT boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::first

(

)

const [inline]

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

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

DomainT boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::last

(

)

const [inline]

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

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

const_iterator boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::find

(

const domain_type &

key

)

const [inline]

Find the interval value pair, that contains key

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

codomain_type boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::operator()

(

const domain_type &

key

)

const [inline]

Total select function.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

SubType& boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::add

(

const element_type &

key_value_pair

)

[inline]

Addition of a key value pair to the map

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

SubType& boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::add

(

const segment_type &

interval_value_pair

)

[inline]

Addition of an interval value pair to the map.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

iterator boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::add	(	iterator	prior_,
		const segment_type &	interval_value_pair
	)			[inline]

Addition of an interval value pair interval_value_pair to the map. Iterator prior_ is a hint to the position interval_value_pair can be inserted after.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

SubType& boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::subtract

(

const element_type &

key_value_pair

)

[inline]

Subtraction of a key value pair from the map

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

SubType& boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::subtract

(

const segment_type &

interval_value_pair

)

[inline]

Subtraction of an interval value pair from the map.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

SubType& boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::insert

(

const element_type &

key_value_pair

)

[inline]

Insertion of a key_value_pair into the map.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

SubType& boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::insert

(

const segment_type &

interval_value_pair

)

[inline]

Insertion of an interval_value_pair into the map.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

iterator boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::insert	(	iterator	prior_,
		const segment_type &	interval_value_pair
	)			[inline]

Insertion of an interval_value_pair into the map. Iterator prior_. serves as a hint to insert after the element prior point to.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

SubType& boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::set

(

const element_type &

key_value_pair

)

[inline]

With key_value_pair = (k,v) set value v for key k

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

SubType& boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::set

(

const segment_type &

interval_value_pair

)

[inline]

With interval_value_pair = (I,v) set value v for all keys in interval I in the map.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

SubType& boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase

(

const element_type &

key_value_pair

)

[inline]

Erase a key_value_pair from the map.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

SubType& boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase

(

const segment_type &

interval_value_pair

)

[inline]

Erase an interval_value_pair from the map.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

SubType& boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase

(

const domain_type &

key

)

[inline]

Erase a key value pair for key.

template<class SubType , class DomainT , class CodomainT , class Traits , ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

SubType & boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase

(

const interval_type &

inter_val

)

[inline]

Erase all value pairs within the range of the interval inter_val from the map.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

template<class SetSubType >

SubType& boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase

(

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

operand

)

[inline]

Erase all value pairs for a set of intervals.

template<class SubType , class DomainT , class CodomainT , class Traits , ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

SubType & boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase

(

const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &

eraser

)

[inline]

Erase all value pairs from *this map that are elements of map

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

void boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase

(

iterator

position

)

[inline]

Erase all value pairs within the range of the interval that iterator position points to.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

void boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase	(	iterator	first,
		iterator	past
	)			[inline]

Erase all value pairs for a range of iterators [first,past).

template<class SubType , class DomainT , class CodomainT , class Traits , ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

template<class Predicate >

SubType & boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase_if

(

const Predicate &

pred

)

[inline]

Remove all elements where property p holds, keep all others

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

void boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::add_intersection	(	interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &	section,
		const domain_type &	key
	)			const [inline]

The intersection of key in *this map is added to section. This can also be used to find key in *this map

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

void boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::add_intersection	(	interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &	section,
		const element_type &	key_value_pair
	)			const [inline]

The intersection of key_value_pair and *this map is added to section.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

void boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::add_intersection	(	interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &	section,
		const segment_type &	interval_value_pair
	)			const

The intersection of interval_value_pair and *this map is added to section.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

void boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::add_intersection	(	interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &	section,
		const interval_type &	inter_val
	)			const

The intersection of inter_val with *this map is added to section.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), 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>

void boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::add_intersection	(	interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &	section,
		const IntervalSet< DomainT, Compare, Interval, Alloc > &	sectant
	)			const [inline]

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

template<class SubType , class DomainT , class CodomainT , class Traits , ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

template<template< class DomT, class CodomT, class Trts, ITL_COMPARE Comp, ITL_COMBINE Combi, ITL_SECTION Sect, template< class DomT2, ITL_COMPARE >class Interv, ITL_ALLOC Allc > class IntervalMap>

void boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::add_intersection	(	interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &	intersection,
		const IntervalMap< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &	sectant
	)			const [inline]

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

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

bool boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::intersects

(

const domain_type &

key

)

const [inline]

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

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

bool boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::intersects

(

const interval_type &

inter_val

)

const [inline]

Returns true, if inter_val intersects with *this map. Complexity: Logarithmic in iterative size.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

bool boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::intersects

(

const element_type &

key_value_pair

)

const [inline]

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

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

bool boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::intersects

(

const segment_type &

interval_value_pair

)

const [inline]

Returns true, if interval_value_pair intersects with *this map: Complexity: Linear in iterative_size.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

SubType& boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::flip

(

const element_type &

key_value_pair

)

[inline]

If *this map contains key_value_pair it is erased, otherwise it is added.

template<class SubType , class DomainT , class CodomainT , class Traits , ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

SubType & boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::flip

(

const segment_type &

interval_value_pair

)

[inline]

If *this map contains interval_value_pair it is erased, otherwise it is added.

template<class SubType , class DomainT , class CodomainT , class Traits , ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

template<class SubType2 >

SubType & boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::flip

(

const interval_base_map< SubType2, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &

operand

)

[inline]

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

template<class SubType , class DomainT , class CodomainT , class Traits , ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

std::string boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::as_string

(

)

const [inline]

Object as string

template<class SubType , class DomainT , class CodomainT , class Traits , ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::join

(

)

[inline]

Join bounding intervals

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), template< class, ITL_COMPARE >class Interval = itl::interval, ITL_ALLOC Alloc = std::allocator>

void boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::absorb_neutrons

(

)

[inline]

All value pairs (I,y) that have neutral elements y==codomain_type() as associated values are removed form the map.

template<class SubType , class DomainT , class CodomainT , class Traits , ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template< class, ITL_COMPARE >class Interval, ITL_ALLOC Alloc>

void boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::uniform_bounds

(

itl::bound_type

bounded

)

[inline]

Set all intervals in the map to be of type bounded. Requires Integral<domain_type>.

Interval bounds of different types are created by opeations on interval maps. This function allows to reset them uniformly without, of course, changing their value. This is only possible for discrete domain datatypes.

template<class SubType , typename DomainT , typename CodomainT , class Traits = itl::partial_absorber, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT), ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT), ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), 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>

void boost::itl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::domain

(

IntervalSet< DomainT, Compare, Interval, Alloc > &

dom

)

const [inline]

Gives the domain of the map as interval set

---

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

• boost/itl/interval_base_map.hpp