Boost  v1.57.0
doxygen for www.boost.org
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > Class Template Reference

implements a map as a map of intervals - on insertion overlapping intervals are split and associated values are combined. More...

#include <split_interval_map.hpp>

Inheritance diagram for boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >:
Collaboration diagram for boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >:

Public Types

enum  { fineness = 3 }
 
typedef Traits traits
 
typedef split_interval_map
< DomainT, CodomainT, Traits,
Compare, Combine, Section,
Interval, Alloc > 
type
 
typedef interval_map< DomainT,
CodomainT, Traits, Compare,
Combine, Section, Interval,
Alloc > 
joint_type
 
typedef type overloadable_type
 
typedef interval_base_map
< type, DomainT, CodomainT,
Traits, Compare, Combine,
Section, Interval, Alloc > 
base_type
 
typedef DomainT domain_type
 
typedef CodomainT codomain_type
 
typedef base_type::iterator iterator
 
typedef base_type::value_type value_type
 
typedef base_type::element_type element_type
 
typedef base_type::segment_type segment_type
 
typedef
base_type::domain_mapping_type 
domain_mapping_type
 
typedef
base_type::interval_mapping_type 
interval_mapping_type
 
typedef base_type::ImplMapT ImplMapT
 
typedef base_type::codomain_combine codomain_combine
 
typedef interval_set< DomainT,
Compare, Interval, Alloc > 
interval_set_type
 
typedef interval_set_type set_type
 
typedef set_type key_object_type
 
typedef split_interval_map
< DomainT, CodomainT, Traits,
Compare, Combine, Section,
Interval, Alloc > 
sub_type
 The designated derived or sub_type of this base class. More...
 
typedef icl::map< DomainT,
CodomainT, Traits, Compare,
Combine, Section, Alloc > 
atomized_type
 The atomized type representing the corresponding container of elements. More...
 
typedef boost::call_traits
< DomainT >::param_type 
domain_param
 
typedef difference_type_of
< domain_type >::type 
difference_type
 The difference type of an interval which is sometimes different form the domain_type. More...
 
typedef size_type_of
< domain_type >::type 
size_type
 The size type of an interval which is mostly std::size_t. More...
 
typedef inverse
< codomain_combine >::type 
inverse_codomain_combine
 Inverse Combine functor for codomain value aggregation. More...
 
typedef mpl::if_
< has_set_semantics
< codomain_type >
, ICL_SECTION_CODOMAIN(Section,
CodomainT), codomain_combine >
::type 
codomain_intersect
 Intersection functor for codomain values. More...
 
typedef inverse
< codomain_intersect >::type 
inverse_codomain_intersect
 Inverse Combine functor for codomain value intersection. More...
 
typedef exclusive_less_than
< interval_type > 
interval_compare
 Comparison functor for intervals which are keys as well. More...
 
typedef exclusive_less_than
< interval_type > 
key_compare
 Comparison functor for keys. More...
 
typedef Alloc< std::pair
< const interval_type,
codomain_type > > 
allocator_type
 The allocator type of the set. More...
 
typedef ImplMapT::key_type key_type
 key type of the implementing container More...
 
typedef
ImplMapT::value_type::second_type 
data_type
 data type of the implementing container More...
 
typedef ImplMapT::pointer pointer
 pointer type More...
 
typedef ImplMapT::const_pointer const_pointer
 const pointer type More...
 
typedef ImplMapT::reference reference
 reference type More...
 
typedef ImplMapT::const_reference const_reference
 const reference type More...
 
typedef ImplMapT::const_iterator const_iterator
 const_iterator for iteration over intervals More...
 
typedef ImplMapT::reverse_iterator reverse_iterator
 iterator for reverse iteration over intervals More...
 
typedef
ImplMapT::const_reverse_iterator 
const_reverse_iterator
 const_iterator for iteration over intervals More...
 
typedef
boost::icl::element_iterator
< iterator
element_iterator
 element iterator: Depreciated, see documentation. More...
 
typedef
boost::icl::element_iterator
< const_iterator
element_const_iterator
 const element iterator: Depreciated, see documentation. More...
 
typedef
boost::icl::element_iterator
< reverse_iterator
element_reverse_iterator
 element reverse iterator: Depreciated, see documentation. More...
 
typedef
boost::icl::element_iterator
< const_reverse_iterator
element_const_reverse_iterator
 element const reverse iterator: Depreciated, see documentation. More...
 
typedef on_absorbtion< type,
codomain_combine,
Traits::absorbs_identities >
::type 
on_codomain_absorbtion
 

Public Member Functions

typedef ICL_INTERVAL_TYPE (Interval, DomainT, Compare) interval_type
 
 split_interval_map ()
 Default constructor for the empty object. More...
 
 split_interval_map (const split_interval_map &src)
 Copy constructor. More...
 
 split_interval_map (const domain_mapping_type &base_pair)
 
 split_interval_map (const value_type &value_pair)
 
template<class SubType >
void assign (const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &src)
 Assignment from a base interval_map. More...
 
template<class SubType >
split_interval_mapoperator= (const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &src)
 Assignment operator for base type. More...
 
 split_interval_map (split_interval_map &&src)
 Move constructor. More...
 
split_interval_mapoperator= (split_interval_map src)
 Move assignment operator. More...
 
typedef ICL_COMPARE_DOMAIN (Compare, DomainT) domain_compare
 Comparison functor for domain values. More...
 
typedef ICL_COMPARE_DOMAIN (Compare, segment_type) segment_compare
 
typedef ICL_COMBINE_CODOMAIN (Combine, CodomainT) codomain_combine
 Combine functor for codomain value aggregation. More...
 
 BOOST_STATIC_CONSTANT (bool, is_total_invertible=(Traits::is_total &&has_inverse< codomain_type >::value))
 
 BOOST_STATIC_CONSTANT (int, fineness=0)
 
void swap (interval_base_map &object)
 swap the content of containers More...
 
void clear ()
 clear the map More...
 
bool empty () const
 is the map empty? More...
 
size_type size () const
 An interval map's size is it's cardinality. More...
 
std::size_t iterative_size () const
 Size of the iteration over this container. More...
 
const_iterator find (const domain_type &key_value) const
 Find the interval value pair, that contains key. More...
 
const_iterator find (const interval_type &key_interval) const
 Find the first interval value pair, that collides with interval key_interval. More...
 
codomain_type operator() (const domain_type &key_value) const
 Total select function. More...
 
split_interval_map< DomainT,
CodomainT, Traits, Compare,
Combine, Section, Interval,
Alloc > & 
add (const element_type &key_value_pair)
 Addition of a key value pair to the map. More...
 
split_interval_map< DomainT,
CodomainT, Traits, Compare,
Combine, Section, Interval,
Alloc > & 
add (const segment_type &interval_value_pair)
 Addition of an interval value pair to the map. More...
 
iterator add (iterator prior_, const segment_type &interval_value_pair)
 Addition of an interval value pair interval_value_pair to the map. More...
 
split_interval_map< DomainT,
CodomainT, Traits, Compare,
Combine, Section, Interval,
Alloc > & 
subtract (const element_type &key_value_pair)
 Subtraction of a key value pair from the map. More...
 
split_interval_map< DomainT,
CodomainT, Traits, Compare,
Combine, Section, Interval,
Alloc > & 
subtract (const segment_type &interval_value_pair)
 Subtraction of an interval value pair from the map. More...
 
split_interval_map< DomainT,
CodomainT, Traits, Compare,
Combine, Section, Interval,
Alloc > & 
insert (const element_type &key_value_pair)
 Insertion of a key_value_pair into the map. More...
 
split_interval_map< DomainT,
CodomainT, Traits, Compare,
Combine, Section, Interval,
Alloc > & 
insert (const segment_type &interval_value_pair)
 Insertion of an interval_value_pair into the map. More...
 
iterator insert (iterator prior, const segment_type &interval_value_pair)
 Insertion of an interval_value_pair into the map. More...
 
split_interval_map< DomainT,
CodomainT, Traits, Compare,
Combine, Section, Interval,
Alloc > & 
set (const element_type &key_value_pair)
 With key_value_pair = (k,v) set value v for key k. More...
 
split_interval_map< DomainT,
CodomainT, Traits, Compare,
Combine, Section, Interval,
Alloc > & 
set (const segment_type &interval_value_pair)
 With interval_value_pair = (I,v) set value v for all keys in interval I in the map. More...
 
split_interval_map< DomainT,
CodomainT, Traits, Compare,
Combine, Section, Interval,
Alloc > & 
erase (const element_type &key_value_pair)
 Erase a key_value_pair from the map. More...
 
split_interval_map< DomainT,
CodomainT, Traits, Compare,
Combine, Section, Interval,
Alloc > & 
erase (const segment_type &interval_value_pair)
 Erase an interval_value_pair from the map. More...
 
split_interval_map< DomainT,
CodomainT, Traits, Compare,
Combine, Section, Interval,
Alloc > & 
erase (const domain_type &key)
 Erase a key value pair for key. More...
 
split_interval_map< DomainT,
CodomainT, Traits, Compare,
Combine, Section, Interval,
Alloc > & 
erase (const interval_type &inter_val)
 Erase all value pairs within the range of the interval inter_val from the map. More...
 
void erase (iterator position)
 Erase all value pairs within the range of the interval that iterator position points to. More...
 
void erase (iterator first, iterator past)
 Erase all value pairs for a range of iterators [first,past). More...
 
void add_intersection (split_interval_map< 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. More...
 
split_interval_map< DomainT,
CodomainT, Traits, Compare,
Combine, Section, Interval,
Alloc > & 
flip (const element_type &key_value_pair)
 If *this map contains key_value_pair it is erased, otherwise it is added. More...
 
split_interval_map< DomainT,
CodomainT, Traits, Compare,
Combine, Section, Interval,
Alloc > & 
flip (const segment_type &interval_value_pair)
 If *this map contains interval_value_pair it is erased, otherwise it is added. More...
 
iterator lower_bound (const key_type &interval)
 
const_iterator lower_bound (const key_type &interval) const
 
iterator upper_bound (const key_type &interval)
 
const_iterator upper_bound (const key_type &interval) const
 
std::pair< iterator, iteratorequal_range (const key_type &interval)
 
std::pair< const_iterator,
const_iterator
equal_range (const key_type &interval) const
 
iterator begin ()
 
const_iterator begin () const
 
iterator end ()
 
const_iterator end () const
 
reverse_iterator rbegin ()
 
const_reverse_iterator rbegin () const
 
reverse_iterator rend ()
 
const_reverse_iterator rend () const
 

Protected Member Functions

iterator gap_insert (iterator prior_, const interval_type &inter_val, const codomain_type &co_val)
 
std::pair< iterator, bool > add_at (const iterator &prior_, const interval_type &inter_val, const codomain_type &co_val)
 
std::pair< iterator, bool > insert_at (const iterator &prior_, const interval_type &inter_val, const codomain_type &co_val)
 
sub_typethat ()
 
const sub_typethat () const
 

Protected Attributes

ImplMapT _map
 

Friends

class interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >
 

Detailed Description

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
class boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >

implements a map as a map of intervals - on insertion overlapping intervals are split and associated values are combined.

Member Typedef Documentation

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

The allocator type of the set.

typedef icl::map<DomainT,CodomainT, Traits,Compare,Combine,Section,Alloc> boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::atomized_type
inherited

The atomized type representing the corresponding container of elements.

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef interval_base_map<type, DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::base_type
template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef base_type::codomain_combine boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::codomain_combine
typedef mpl::if_<has_set_semantics<codomain_type> , ICL_SECTION_CODOMAIN(Section,CodomainT) , codomain_combine >::type boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::codomain_intersect
inherited

Intersection functor for codomain values.

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef CodomainT boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::codomain_type
typedef ImplMapT::const_iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::const_iterator
inherited

const_iterator for iteration over intervals

typedef ImplMapT::const_pointer boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::const_pointer
inherited

const pointer type

typedef ImplMapT::const_reference boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::const_reference
inherited

const reference type

typedef ImplMapT::const_reverse_iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::const_reverse_iterator
inherited

const_iterator for iteration over intervals

typedef ImplMapT::value_type::second_type boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::data_type
inherited

data type of the implementing container

typedef difference_type_of<domain_type>::type boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::difference_type
inherited

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

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef base_type::domain_mapping_type boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::domain_mapping_type
typedef boost::call_traits<DomainT>::param_type boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::domain_param
inherited
template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef DomainT boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::domain_type
typedef boost::icl::element_iterator<const_iterator> boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::element_const_iterator
inherited

const element iterator: Depreciated, see documentation.

typedef boost::icl::element_iterator<const_reverse_iterator> boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::element_const_reverse_iterator
inherited

element const reverse iterator: Depreciated, see documentation.

typedef boost::icl::element_iterator<iterator> boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::element_iterator
inherited

element iterator: Depreciated, see documentation.

typedef boost::icl::element_iterator<reverse_iterator> boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::element_reverse_iterator
inherited

element reverse iterator: Depreciated, see documentation.

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef base_type::element_type boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::element_type
template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef base_type::ImplMapT boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::ImplMapT
typedef exclusive_less_than<interval_type> boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::interval_compare
inherited

Comparison functor for intervals which are keys as well.

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef base_type::interval_mapping_type boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::interval_mapping_type
template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef interval_set<DomainT,Compare,Interval,Alloc> boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::interval_set_type
typedef inverse<codomain_combine>::type boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::inverse_codomain_combine
inherited

Inverse Combine functor for codomain value aggregation.

typedef inverse<codomain_intersect>::type boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::inverse_codomain_intersect
inherited

Inverse Combine functor for codomain value intersection.

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef base_type::iterator boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::iterator
template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::joint_type
typedef exclusive_less_than<interval_type> boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::key_compare
inherited

Comparison functor for keys.

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef set_type boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::key_object_type
typedef ImplMapT::key_type boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::key_type
inherited

key type of the implementing container

typedef on_absorbtion<type, codomain_combine, Traits::absorbs_identities>::type boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::on_codomain_absorbtion
inherited
template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef type boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::overloadable_type
typedef ImplMapT::pointer boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::pointer
inherited

pointer type

typedef ImplMapT::reference boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::reference
inherited

reference type

typedef ImplMapT::reverse_iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::reverse_iterator
inherited

iterator for reverse iteration over intervals

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef base_type::segment_type boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::segment_type
template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef interval_set_type boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::set_type
typedef size_type_of<domain_type>::type boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::size_type
inherited

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

typedef split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::sub_type
inherited

The designated derived or sub_type of this base class.

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef Traits boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::traits
template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::type
template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef base_type::value_type boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::value_type

Member Enumeration Documentation

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
anonymous enum
Enumerator
fineness 

Constructor & Destructor Documentation

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::split_interval_map ( )
inline

Default constructor for the empty object.

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::split_interval_map ( const split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &  src)
inline

Copy constructor.

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::split_interval_map ( const domain_mapping_type base_pair)
inlineexplicit

References boost::icl::add().

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::split_interval_map ( const value_type value_pair)
inlineexplicit

References boost::icl::add().

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::split_interval_map ( split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &&  src)
inline

Move constructor.

Member Function Documentation

split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::add ( const element_type key_value_pair)
inlineinherited

Addition of a key value pair to the map.

split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::add ( const segment_type interval_value_pair)
inlineinherited

Addition of an interval value pair to the map.

iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::add ( iterator  prior_,
const segment_type interval_value_pair 
)
inlineinherited

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.

std::pair<iterator, bool> boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::add_at ( const iterator prior_,
const interval_type &  inter_val,
const codomain_type co_val 
)
inlineprotectedinherited
void boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::add_intersection ( split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &  section,
const segment_type interval_value_pair 
) const
inlineinherited

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

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
template<class SubType >
void boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::assign ( const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &  src)
inline

Assignment from a base interval_map.

References boost::icl::clear().

iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::begin ( void  )
inlineinherited
const_iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::begin ( void  ) const
inlineinherited
boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::BOOST_STATIC_CONSTANT ( bool  ,
is_total_invertible  = (   Traits::is_total                                && has_inverse<codomain_type>::value) 
)
inherited
boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::BOOST_STATIC_CONSTANT ( int  ,
fineness  = 0 
)
inherited
void boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::clear ( void  )
inlineinherited

clear the map

bool boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::empty ( void  ) const
inlineinherited

is the map empty?

iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::end ( void  )
inlineinherited
const_iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::end ( void  ) const
inlineinherited
std::pair<iterator,iterator> boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::equal_range ( const key_type interval)
inlineinherited
std::pair<const_iterator,const_iterator> boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::equal_range ( const key_type interval) const
inlineinherited
split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase ( const element_type key_value_pair)
inlineinherited

Erase a key_value_pair from the map.

split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase ( const segment_type interval_value_pair)
inherited

Erase an interval_value_pair from the map.

split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase ( const domain_type key)
inlineinherited

Erase a key value pair for key.

split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase ( const interval_type &  inter_val)
inherited

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

void boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase ( iterator  position)
inlineinherited

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

void boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase ( iterator  first,
iterator  past 
)
inlineinherited

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

const_iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::find ( const domain_type key_value) const
inlineinherited

Find the interval value pair, that contains key.

const_iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::find ( const interval_type &  key_interval) const
inlineinherited

Find the first interval value pair, that collides with interval key_interval.

split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::flip ( const element_type key_value_pair)
inlineinherited

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

split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::flip ( const segment_type interval_value_pair)
inlineinherited

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

iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::gap_insert ( iterator  prior_,
const interval_type &  inter_val,
const codomain_type co_val 
)
inlineprotectedinherited
typedef boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::ICL_COMBINE_CODOMAIN ( Combine  ,
CodomainT   
)
inherited

Combine functor for codomain value aggregation.

typedef boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::ICL_COMPARE_DOMAIN ( Compare  ,
DomainT   
)
inherited

Comparison functor for domain values.

typedef boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::ICL_COMPARE_DOMAIN ( Compare  ,
segment_type   
)
inherited
template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
typedef boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::ICL_INTERVAL_TYPE ( Interval  ,
DomainT  ,
Compare   
)
split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::insert ( const element_type key_value_pair)
inlineinherited

Insertion of a key_value_pair into the map.

split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::insert ( const segment_type interval_value_pair)
inlineinherited

Insertion of an interval_value_pair into the map.

iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::insert ( iterator  prior,
const segment_type interval_value_pair 
)
inlineinherited

Insertion of an interval_value_pair into the map.

Iterator prior_. serves as a hint to insert after the element prior point to.

std::pair<iterator, bool> boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::insert_at ( const iterator prior_,
const interval_type &  inter_val,
const codomain_type co_val 
)
inlineprotectedinherited
std::size_t boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::iterative_size ( ) const
inlineinherited

Size of the iteration over this container.

iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::lower_bound ( const key_type interval)
inlineinherited
const_iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::lower_bound ( const key_type interval) const
inlineinherited
codomain_type boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::operator() ( const domain_type key_value) const
inlineinherited

Total select function.

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
template<class SubType >
split_interval_map& boost::icl::split_interval_map< 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 for base type.

References boost::assign().

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
split_interval_map& boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::operator= ( split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >  src)
inline

Move assignment operator.

References boost::move(), and boost::multiprecision::backends::operator=().

reverse_iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::rbegin ( )
inlineinherited
const_reverse_iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::rbegin ( ) const
inlineinherited
reverse_iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::rend ( )
inlineinherited
const_reverse_iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::rend ( ) const
inlineinherited
split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::set ( const element_type key_value_pair)
inlineinherited

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

split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::set ( const segment_type interval_value_pair)
inlineinherited

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

size_type boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::size ( void  ) const
inlineinherited

An interval map's size is it's cardinality.

split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::subtract ( const element_type key_value_pair)
inlineinherited

Subtraction of a key value pair from the map.

split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::subtract ( const segment_type interval_value_pair)
inlineinherited

Subtraction of an interval value pair from the map.

void boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::swap ( interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &  object)
inlineinherited

swap the content of containers

sub_type* boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::that ( )
inlineprotectedinherited
const sub_type* boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::that ( ) const
inlineprotectedinherited
iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::upper_bound ( const key_type interval)
inlineinherited
const_iterator boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::upper_bound ( const key_type interval) const
inlineinherited

Friends And Related Function Documentation

template<typename DomainT , typename CodomainT , class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), ICL_ALLOC Alloc = std::allocator>
friend class interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >,DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >
friend

Member Data Documentation

ImplMapT boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > , DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::_map
protectedinherited

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