# Interval Container Library Reference

ICL_COMPARE ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT)
`closed_interval`< DomainT, Compare >
DomainT
typedef `Compare` `DomainT`
DomainT
DomainT
DomainT
DomainT

Default constructor; yields an empty interval `[0,0)`.

const DomainT &

Constructor for a closed singleton interval `[val,val]`

const DomainT &
const DomainT &

Interval from `low` to `up` with bounds `bounds`

ICL_COMPARE
closed_interval< DomainT
Compare >
interval_bound_type
bound_type
value
interval_bounds::static_closed
ICL_COMPARE
icl::closed_interval< DomainT
Compare >
DomainT
`icl::closed_interval`< DomainT, Compare >
typedef `Compare` `DomainT`
`interval_type` `const domain_type &` `const domain_type &`
domain_type `const `interval_type` &`
domain_type `const `interval_type` &`
ICL_COMPARE
icl::closed_interval< DomainT
Compare >
std::string
icl::closed_interval< DomainT >
std::size_t `const `icl::closed_interval`< DomainT > &`
ICL_COMPARE ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT)
`continuous_interval`< DomainT, Compare >
DomainT
`bounded_value`< DomainT >::`type`
typedef `Compare` `DomainT`
domain_type
domain_type
`interval_bounds`

Default constructor; yields an empty interval `[0,0)`.

const DomainT &

Constructor for a closed singleton interval `[val,val]`

const DomainT &
const DomainT &
interval_bounds
interval_bounds::right_open()
continuous_interval
*
0

Interval from `low` to `up` with bounds `bounds`

`continuous_interval` `const DomainT &` `const DomainT &`
`continuous_interval` `const DomainT &` `const DomainT &`
`continuous_interval` `const DomainT &` `const DomainT &`
`continuous_interval` `const DomainT &` `const DomainT &`
ICL_COMPARE
boost::icl::continuous_interval< DomainT
Compare >
`dynamic_interval_traits`
`boost::icl::continuous_interval`< DomainT, Compare >
DomainT
typedef `Compare` `DomainT`
`interval_type` `const domain_type` `const domain_type` ``interval_bounds``
`interval_type` `const `bounded_value`< DomainT > &` `const `bounded_value`< DomainT > &`
ICL_COMPARE
continuous_interval< DomainT
Compare >
interval_bound_type
bound_type
value
interval_bounds::dynamic
ICL_COMPARE
icl::continuous_interval< DomainT
Compare >
`interval_traits`
DomainT
`icl::continuous_interval`< DomainT, Compare >
typedef `Compare` `DomainT`
`interval_type` `const domain_type &` `const domain_type &`
domain_type `const `interval_type` &`
domain_type `const `interval_type` &`
ICL_COMPARE
continuous_interval< DomainT
Compare >
is_continuous_interval< `continuous_interval`< DomainT, Compare > >
bool
value
true
ICL_COMPARE
icl::continuous_interval< DomainT
Compare >
std::string
icl::continuous_interval< DomainT >
std::size_t `const `icl::continuous_interval`< DomainT > &`
ICL_COMPARE ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT)
`discrete_interval`< DomainT, Compare >
DomainT
`bounded_value`< DomainT >::`type`
typedef `Compare` `DomainT`
domain_type
domain_type
`interval_bounds`

Default constructor; yields an empty interval `[0,0)`.

const DomainT &

Constructor for a closed singleton interval `[val,val]`

const DomainT &
const DomainT &
interval_bounds
interval_bounds::right_open()
discrete_interval
*
0

Interval from `low` to `up` with bounds `bounds`

`discrete_interval` `const DomainT &` `const DomainT &`
`discrete_interval` `const DomainT &` `const DomainT &`
`discrete_interval` `const DomainT &` `const DomainT &`
`discrete_interval` `const DomainT &` `const DomainT &`
ICL_COMPARE
boost::icl::discrete_interval< DomainT
Compare >
`dynamic_interval_traits`
`boost::icl::discrete_interval`< DomainT, Compare >
DomainT
typedef `Compare` `DomainT`
`interval_type` `const domain_type &` `const domain_type &` ``interval_bounds``
`interval_type` `const `bounded_value`< DomainT > &` `const `bounded_value`< DomainT > &`
ICL_COMPARE
discrete_interval< DomainT
Compare >
interval_bound_type
bound_type
value
interval_bounds::dynamic
ICL_COMPARE
icl::discrete_interval< DomainT
Compare >
`interval_traits`
DomainT
`icl::discrete_interval`< DomainT, Compare >
typedef `Compare` `DomainT`
`interval_type` `const domain_type &` `const domain_type &`
domain_type `const `interval_type` &`
domain_type `const `interval_type` &`
ICL_COMPARE
discrete_interval< DomainT
Compare >
is_discrete_interval< `discrete_interval`< DomainT, Compare > >
bool
value
is_discrete< DomainT >::value
ICL_COMPARE
icl::discrete_interval< DomainT
Compare >
std::string
icl::discrete_interval< DomainT >
std::size_t `const `icl::discrete_interval`< DomainT > &`
Type::domain_type
Type::domain_compare
Type `const domain_type &` `const domain_type &` ``interval_bounds``
Type `const `bounded_value`< domain_type > &` `const `bounded_value`< domain_type > &`
`conversion`< Combiner >
remove_const< typename remove_reference< typename Combiner::first_argument_type >::`type` >::`type`
argument_type `const argument_type &`
argument_type `const argument_type &`
Type &
const Type &
void
Type
boost::icl::identity_based_inplace_combine< Type >
`inplace_bit_add`< Type >
void `Type &` `const Type &`
void `Type &`
boost::icl::identity_based_inplace_combine< Type >
`inplace_bit_and`< Type >
void `Type &` `const Type &`
boost::icl::identity_based_inplace_combine< Type >
`inplace_bit_subtract`< Type >
void `Type &` `const Type &`
boost::icl::identity_based_inplace_combine< Type >
`inplace_bit_xor`< Type >
void `Type &` `const Type &`
boost::icl::identity_based_inplace_combine< Type >
`inplace_caret`< Type >
void `Type &` `const Type &`
boost::icl::identity_based_inplace_combine< Type >
`inplace_erase`< Type >
void `Type &` `const Type &`
boost::icl::identity_based_inplace_combine< Type >
`inplace_erasure`< Type >
`identity_based_inplace_combine`< Type >
void `Type &` `const Type &`
boost::icl::identity_based_inplace_combine< Type >
`inplace_et`< Type >
void `Type &` `const Type &`
boost::icl::identity_based_inplace_combine< Type >
`inplace_identity`< Type >
void `Type &` `const Type &`
boost::icl::identity_based_inplace_combine< Type >
`inplace_insert`< Type >
void `Type &` `const Type &`
boost::icl::identity_based_inplace_combine< Type >
`inplace_max`< Type >
void `Type &` `const Type &`
boost::icl::identity_based_inplace_combine< Type >
`inplace_min`< Type >
void `Type &` `const Type &`
boost::icl::identity_based_inplace_combine< Type >
`inplace_minus`< Type >
void `Type &` `const Type &`
boost::icl::identity_based_inplace_combine< Type >
`inplace_plus`< Type >
void `Type &` `const Type &`
void `Type &`
boost::icl::identity_based_inplace_combine< Type >
`inplace_slash`< Type >
void `Type &` `const Type &`
boost::icl::identity_based_inplace_combine< Type >
`inplace_star`< Type >
void `Type &` `const Type &`
boost::icl::identity_based_inplace_combine< Type >
boost::mpl::if_< has_set_semantics< Type >, `icl::inplace_et`< Type >, `icl::inplace_plus`< Type > >::type
void `Type &` `const Type &`
remove_reference< typename Functor::first_argument_type >::`type`
`icl::inplace_erasure`< argument_type >
icl::inplace_bit_add< Type >
`icl::inplace_bit_subtract`< Type >
icl::inplace_bit_and< Type >
`icl::inplace_bit_xor`< Type >
icl::inplace_bit_subtract< Type >
`icl::inplace_bit_add`< Type >
icl::inplace_bit_xor< Type >
`icl::inplace_bit_and`< Type >
icl::inplace_caret< Type >
`icl::inplace_et`< Type >
icl::inplace_et< Type >
`icl::inplace_caret`< Type >
icl::inplace_identity< Type >
`icl::inplace_erasure`< Type >
icl::inplace_max< Type >
`icl::inplace_min`< Type >
icl::inplace_min< Type >
`icl::inplace_max`< Type >
icl::inplace_minus< Type >
`icl::inplace_plus`< Type >
icl::inplace_plus< Type >
`icl::inplace_minus`< Type >
icl::inplace_slash< Type >
`icl::inplace_star`< Type >
icl::inplace_star< Type >
`icl::inplace_slash`< Type >
icl::inter_section< Type >
boost::icl::identity_based_inplace_combine< Type >
boost::mpl::if_< has_set_semantics< Type >, `icl::inplace_caret`< Type >, `icl::inplace_minus`< Type > >::type
void `Type &` `const Type &`
`is_negative`< Functor >
bool
value
false
icl::inplace_bit_subtract< Type >
`is_negative`
bool
value
true
icl::inplace_minus< Type >
`is_negative`
bool
value
true
Type &
const Type &
void
Type
boost::icl::conversion< Combiner >
`version`< Combiner >
`conversion`< Combiner >
base_type::argument_type
argument_type `const argument_type &`
icl::inplace_minus< double >
double `double`
icl::inplace_minus< float >
float `float`
icl::inplace_minus< int >
int `int`
icl::inplace_minus< long >
long `long`
icl::inplace_minus< long double >
long double `long double`
icl::inplace_minus< long long >
long long `long long`
icl::inplace_minus< short >
short `short`
icl::inplace_minus< Type >
boost::icl::conversion< icl::inplace_minus< Type > >
`version`< `icl::inplace_minus`< Type > >
`conversion`< `icl::inplace_minus`< Type > >
base_type::argument_type
Type `const Type &`
boost::gregorian::date
boost::gregorian::date_duration
boost::gregorian::date
has_difference
bool
value
true
boost::gregorian::date_duration
has_difference
bool
value
true
boost::gregorian::date_duration
boost::gregorian::date_duration
boost::gregorian::date
is_discrete
bool
value
true
boost::gregorian::date_duration
is_discrete
bool
value
true
boost::gregorian::date
boost::gregorian::date_duration
boost::gregorian::date_duration
boost::gregorian::date_duration
boost::gregorian::date `boost::gregorian::date &`
boost::gregorian::date `boost::gregorian::date &`
boost::gregorian::date_duration `boost::gregorian::date_duration &`
boost::gregorian::date_duration `boost::gregorian::date_duration &`
ICL_COMPARE ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT)
interval_type_default< DomainT, Compare >::type
interval_type
interval_type `const DomainT &` `const DomainT &`
interval_type `const DomainT &` `const DomainT &`
interval_type `const DomainT &` `const DomainT &`
interval_type `const DomainT &` `const DomainT &`
interval_type `const DomainT &` `const DomainT &`
bool
bound_type
bound_type
bound_type
bound_type
IntervalT
false
PretendedBounds
RepresentedBounds
`interval_traits`< IntervalT >::domain_type
IntervalT `const domain_type &` `const domain_type &`
bound_type
bound_type
IntervalT
true
PretendedBounds
RepresentedBounds
`interval_traits`< IntervalT >::domain_type
IntervalT `const domain_type &` `const domain_type &`
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::interval_base_map< SubType
DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
absorbs_identities< `icl::interval_base_map`< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
bool
value
(Traits::absorbs_identities)
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::interval_base_map< SubType
DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
has_inverse< `icl::interval_base_map`< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
bool
value
(has_inverse< CodomainT >::value)

boost::icl::partial_absorber

icl::partial_absorber
ICL_COMPARE ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT)
ICL_COMBINE ICL_COMBINE_INSTANCE(`icl::inplace_plus`, CodomainT)
ICL_SECTION ICL_SECTION_INSTANCE(`icl::inter_section`, CodomainT)
ICL_INTERVAL(ICL_COMPARE) ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare)
ICL_ALLOC std::allocator
Implements a map as a map of intervals (base class)
bool
Type
false
Type::interval_type
Type::codomain_type
Type::segment_type
Type::codomain_combine
void `Type &` `interval_type &` `const codomain_type &` `const codomain_type &`
Type
true
Type::interval_type
Type::codomain_type
Type::segment_type
Type::codomain_combine
Type::inverse_codomain_intersect
void `Type &` `interval_type &` `const codomain_type &` `const codomain_type &`
bool
Type
false
void `Type &` `const Type &` `const segment_type &`
Type
true
void `Type &` `const Type &` `const segment_type &`
bool
Type
false
Type::segment_type
Type::inverse_codomain_combine
void `Type &` `const segment_type &`
Type
true
Type::segment_type
Type::inverse_codomain_combine
void `Type &` `const segment_type &`
bool
bool
bool
Type
false
absorbs_identities
Type::segment_type
Type::codomain_type
Type::interval_type
Type::value_type
Type::const_iterator
Type::set_type
Type::inverse_codomain_intersect
void `Type &` `const segment_type &`
Type
true
false
Type::segment_type
Type::codomain_type
void `Type &` `const segment_type &`
Type
true
true
void `Type &` `const typename Type::segment_type &`
`interval_base_map`< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >
The designated derived or sub_type of this base class.
SubType
Auxilliary type for overloadresolution.
`type`
Traits of an itl map.
Traits
The atomized type representing the corresponding container of elements.
`icl::map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >
Domain type (type of the keys) of the map.
DomainT
boost::call_traits< DomainT >::param_type
Domain type (type of the keys) of the map.
CodomainT
Auxiliary type to help the compiler resolve ambiguities when using std::make_pair.
`mapping_pair`< domain_type, codomain_type >
Conceptual is a map a set of elements of type `element_type`.
domain_mapping_type
Auxiliary type for overload resolution.
std::pair< interval_type, CodomainT >
Type of an interval containers segment, that is spanned by an interval.
std::pair< interval_type, CodomainT >
The difference type of an interval which is sometimes different form the domain_type.
difference_type_of< domain_type >::`type`
The size type of an interval which is mostly std::size_t.
size_type_of< domain_type >::`type`
Inverse Combine functor for codomain value aggregation.
`inverse`< codomain_combine >::`type`
Intersection functor for codomain values.
mpl::if_< has_set_semantics< codomain_type >, ICL_SECTION_CODOMAIN(Section, CodomainT), codomain_combine >::`type`
Inverse Combine functor for codomain value intersection.
`inverse`< codomain_intersect >::`type`
Comparison functor for intervals which are keys as well.
exclusive_less_than< interval_type >
Comparison functor for keys.
exclusive_less_than< interval_type >
The allocator type of the set.
Alloc< std::pair< const interval_type, codomain_type > >
Container type for the implementation.
ICL_IMPL_SPACE::map< interval_type, codomain_type, key_compare, allocator_type >
key type of the implementing container
ImplMapT::key_type
value type of the implementing container
ImplMapT::value_type
data type of the implementing container
ImplMapT::value_type::second_type
pointer type
ImplMapT::pointer
const pointer type
ImplMapT::const_pointer
reference type
ImplMapT::reference
const reference type
ImplMapT::const_reference
iterator for iteration over intervals
ImplMapT::iterator
const_iterator for iteration over intervals
ImplMapT::const_iterator
iterator for reverse iteration over intervals
ImplMapT::reverse_iterator
const_iterator for iteration over intervals
ImplMapT::const_reverse_iterator
element iterator: Depreciated, see documentation.
boost::icl::element_iterator< iterator >
const element iterator: Depreciated, see documentation.
boost::icl::element_iterator< const_iterator >
element reverse iterator: Depreciated, see documentation.
boost::icl::element_iterator< reverse_iterator >
element const reverse iterator: Depreciated, see documentation.
boost::icl::element_iterator< const_reverse_iterator >
on_absorbtion< `type`, codomain_combine, Traits::absorbs_identities >::`type`
typedef `Interval` `DomainT` `Compare` The interval type of the map.
typedef `Compare` `DomainT` Comparison functor for domain values.
typedef `Compare` `segment_type`
typedef `Combine` `CodomainT` Combine functor for codomain value aggregation.
bool
is_total_invertible
(Traits::is_total &&has_inverse< codomain_type >::value)
int
fineness
0
void ``interval_base_map` &`

swap the content of containers

void

clear the map

bool

is the map empty?

size_type

An interval map's size is it's cardinality

std::size_t

Size of the iteration over this container

const_iterator `const domain_type &`

Find the interval value pair, that contains `key`

const_iterator `const interval_type &`

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

codomain_type `const domain_type &`

Total select function.

SubType & `const element_type &`

Addition of a key value pair to the map

SubType & `const segment_type &`

Addition of an interval value pair to the map.

iterator `iterator` `const segment_type &`

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.

SubType & `const element_type &`

Subtraction of a key value pair from the map

SubType & `const segment_type &`

Subtraction of an interval value pair from the map.

SubType & `const element_type &`

Insertion of a `key_value_pair` into the map.

SubType & `const segment_type &`

Insertion of an `interval_value_pair` into the map.

iterator `iterator` `const segment_type &`

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

SubType & `const element_type &`

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

SubType & `const segment_type &`

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

SubType & `const element_type &`

Erase a `key_value_pair` from the map.

SubType & `const segment_type &`

Erase an `interval_value_pair` from the map.

SubType & `const domain_type &`

Erase a key value pair for `key`.

SubType & `const interval_type &`

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

void `iterator`

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

void `iterator` `iterator`

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

void `SubType &` `const segment_type &`

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

SubType & `const element_type &`

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

SubType & `const segment_type &`

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

iterator `const key_type &`
iterator `const key_type &`
const_iterator `const key_type &`
const_iterator `const key_type &`
std::pair< iterator, iterator > `const key_type &`
std::pair< const_iterator, const_iterator > `const key_type &`
iterator
iterator
const_iterator
const_iterator
reverse_iterator
reverse_iterator
const_reverse_iterator
const_reverse_iterator

Default constructor for the empty object

const `interval_base_map` &

Copy constructor

interval_base_map
&&

Move constructor

`interval_base_map` & ``interval_base_map``

Move assignment operator

iterator `const segment_type &`
iterator `iterator` `const segment_type &`
void `const segment_type &`
iterator `const segment_type &`
iterator `iterator` `const segment_type &`
void `const interval_type &` `const CodomainT &` `iterator &`
void `interval_type &` `const CodomainT &` `iterator &` `const iterator &`
void `const interval_type &` `const CodomainT &` `iterator &`
void `const interval_type &` `iterator &`
void `const interval_type &` `iterator &`
void `const CodomainT &` `iterator &` `const iterator &`
void `interval_type &` `const CodomainT &` `iterator &`
void `const interval_type &` `const CodomainT &` `iterator &` `const iterator &`
void `interval_type &` `const CodomainT &` `iterator &` `const iterator &`
void `SubType &` `const FragmentT &`
void `SubType &` `const segment_type &`
void `SubType &` `const element_type &`
iterator `iterator` `const interval_type &` `const codomain_type &`
std::pair< iterator, bool > `const iterator &` `const interval_type &` `const codomain_type &`
std::pair< iterator, bool > `const iterator &` `const interval_type &` `const codomain_type &`
sub_type *
const sub_type *
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::interval_base_map< SubType
DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
is_interval_container< `icl::interval_base_map`< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
bool
value
true
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::interval_base_map< SubType
DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
is_map< `icl::interval_base_map`< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
bool
value
true
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::interval_base_map< SubType
DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
is_total< `icl::interval_base_map`< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
bool
value
(Traits::is_total)
DomainT
CodomainT
const DomainT &
const CodomainT &
const std::pair< DomainT, CodomainT > &
ICL_COMPARE ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT)
ICL_INTERVAL(ICL_COMPARE) ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare)
ICL_ALLOC std::allocator
Implements a set as a set of intervals (base class)
`interval_base_set`< SubType, DomainT, Compare, Interval, Alloc >
The designated derived or sub_type of this base class.
SubType
Auxilliary type for overloadresolution.
`type`
The domain type of the set.
DomainT
The codomaintype is the same as domain_type.
DomainT
The element type of the set.
DomainT
The segment type of the set.
interval_type
The difference type of an interval which is sometimes different form the data_type.
difference_type_of< domain_type >::`type`
The size type of an interval which is mostly std::size_t.
size_type_of< domain_type >::`type`
Comparison functor for intervals.
exclusive_less_than< interval_type >
Comparison functor for keys.
exclusive_less_than< interval_type >
The atomized type representing the corresponding container of elements.
ICL_IMPL_SPACE::set< DomainT, domain_compare, Alloc< DomainT > >
The allocator type of the set.
Alloc< interval_type >
allocator type of the corresponding element set
Alloc< DomainT >
Container type for the implementation.
ICL_IMPL_SPACE::set< interval_type, key_compare, allocator_type >
key type of the implementing container
ImplSetT::key_type
data type of the implementing container
ImplSetT::key_type
value type of the implementing container
ImplSetT::value_type
pointer type
ImplSetT::pointer
const pointer type
ImplSetT::const_pointer
reference type
ImplSetT::reference
const reference type
ImplSetT::const_reference
iterator for iteration over intervals
ImplSetT::iterator
const_iterator for iteration over intervals
ImplSetT::const_iterator
iterator for reverse iteration over intervals
ImplSetT::reverse_iterator
const_iterator for iteration over intervals
ImplSetT::const_reverse_iterator
element iterator: Depreciated, see documentation.
boost::icl::element_iterator< iterator >
element const iterator: Depreciated, see documentation.
boost::icl::element_iterator< const_iterator >
element reverse iterator: Depreciated, see documentation.
boost::icl::element_iterator< reverse_iterator >
element const reverse iterator: Depreciated, see documentation.
boost::icl::element_iterator< const_reverse_iterator >
typedef `Interval` `DomainT` `Compare` The interval type of the set.
typedef `Compare` `DomainT` Comparison functor for domain values.
typedef `Compare` `segment_type`
int
fineness
0
void ``interval_base_set` &`

swap the content of containers

void

sets the container empty

bool

is the container empty?

size_type

An interval set's size is it's cardinality

std::size_t

Size of the iteration over this container

const_iterator `const element_type &`

Find the interval, that contains element `key_value`

const_iterator `const interval_type &`

Find the first interval, that collides with interval `key_interval`

SubType & `const element_type &`

Add a single element `key` to the set

SubType & `const segment_type &`

Add an interval of elements `inter_val` to the set

iterator `iterator` `const segment_type &`

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

SubType & `const element_type &`

Subtract a single element `key` from the set

SubType & `const segment_type &`

Subtract an interval of elements `inter_val` from the set

SubType & `const element_type &`

Insert an element `key` into the set

SubType & `const segment_type &`

Insert an interval of elements `inter_val` to the set

iterator `iterator` `const segment_type &`

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

SubType & `const element_type &`

Erase an element `key` from the set

SubType & `const segment_type &`

Erase an interval of elements `inter_val` from the set

void `iterator`

Erase the interval that iterator `position` points to.

void `iterator` `iterator`

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

SubType & `const element_type &`

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

SubType & `const segment_type &`

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

iterator
iterator
const_iterator
const_iterator
reverse_iterator
reverse_iterator
const_reverse_iterator
const_reverse_iterator
iterator `const value_type &`
iterator `const value_type &`
const_iterator `const value_type &`
const_iterator `const value_type &`
std::pair< iterator, iterator > `const key_type &`
std::pair< const_iterator, const_iterator > `const key_type &`

Default constructor for the empty object

const `interval_base_set` &

Copy constructor

interval_base_set
&&

Move constructor

`interval_base_set` & ``interval_base_set``

Move assignment operator

iterator `const segment_type &`
iterator `iterator` `const segment_type &`
void `const interval_type &` `iterator &`
void `interval_type &` `iterator &` `const iterator &`
void `const interval_type &` `iterator &`
void `const interval_type &` `iterator &`
sub_type *
const sub_type *
ICL_COMPARE
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::interval_base_set< SubType
DomainT
Compare
Interval
Alloc >
is_interval_container< `icl::interval_base_set`< SubType, DomainT, Compare, Interval, Alloc > >
bool
value
true
ICL_COMPARE
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::interval_base_set< SubType
DomainT
Compare
Interval
Alloc >
is_set< `icl::interval_base_set`< SubType, DomainT, Compare, Interval, Alloc > >
bool
value
true
DomainT
`bounded_value`< DomainT >
domain_type
`interval_bounds`
const domain_type &
interval_bounds
bound_type
bound_type
static_open
0
bound_type
static_left_open
1
bound_type
static_right_open
2
bound_type
static_closed
3
bound_type
dynamic
4
bound_type
undefined
5
bound_type
_open
0
bound_type
_left_open
1
bound_type
_right_open
2
bound_type
_closed
3
bound_type
_right
1
bound_type
_left
2
bound_type
_all
3
`interval_bounds`
`interval_bounds`
`interval_bounds`
`interval_bounds`
`interval_bounds`
bound_type
bound_type
`interval_bounds`
`interval_bounds`
`interval_bounds`
`interval_bounds`
unsigned char
int
unknown
0
int
joining
1
int
separating
2
int
splitting
3
int
elemental
4
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::interval_map< DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
absorbs_identities< `icl::interval_map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
bool
value
(Traits::absorbs_identities)
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::interval_map< DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
has_inverse< `icl::interval_map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
bool
value
(has_inverse< CodomainT >::value)

boost::icl::partial_absorber

icl::partial_absorber
ICL_COMPARE ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT)
ICL_COMBINE ICL_COMBINE_INSTANCE(`icl::inplace_plus`, CodomainT)
ICL_SECTION ICL_SECTION_INSTANCE(`icl::inter_section`, CodomainT)
ICL_INTERVAL(ICL_COMPARE) ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare)
ICL_ALLOC std::allocator
boost::icl::interval_base_map< interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, 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.
= 1
Traits
`interval_map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >
`split_interval_map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >
`type`
`type`
`interval_base_map`< `type`, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >
base_type::iterator
base_type::value_type
base_type::element_type
base_type::segment_type
base_type::domain_type
base_type::codomain_type
base_type::domain_mapping_type
base_type::interval_mapping_type
base_type::ImplMapT
base_type::size_type
base_type::codomain_combine
`interval_set`< DomainT, Compare, Interval, Alloc >
`interval_set_type`
`set_type`
typedef `Interval` `DomainT` `Compare`
void `const `interval_base_map`< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &` Assignment from a base `interval_map`.
Default constructor for the empty object.
const `interval_map` &
Copy constructor.
const `interval_base_map`< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &
Copy constructor for base_type.
const `domain_mapping_type` &
const value_type &
`interval_map` & `const `interval_base_map`< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &` Assignment operator for base type.
interval_map
&&
Move constructor.
`interval_map` & ``interval_map`` Move assignment operator.
iterator `iterator`
void `iterator` `iterator`
void `iterator`
void `iterator`
void `iterator` `iterator &`
void `iterator` `iterator`
void `iterator`
void `iterator &` `iterator` `const interval_type &` `const codomain_type &`
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::interval_map< DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
is_interval_container< `icl::interval_map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
bool
value
true
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::interval_map< DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
is_map< `icl::interval_map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
bool
value
true
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::interval_map< DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
is_total< `icl::interval_map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
bool
value
(Traits::is_total)
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::interval_map< DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
std::string
ICL_COMPARE ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT)
ICL_INTERVAL(ICL_COMPARE) ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare)
ICL_ALLOC std::allocator
boost::icl::interval_base_set< interval_set< DomainT, Compare, Interval, Alloc >, DomainT, Compare, Interval, Alloc >
Implements a set as a set of intervals - merging adjoining intervals.
= 1
`interval_set`< DomainT, Compare, Interval, Alloc >
The base_type of this class.
`interval_base_set`< `type`, DomainT, Compare, Interval, Alloc >
`type`
`type`
`type`
The domain type of the set.
DomainT
The codomaintype is the same as domain_type.
DomainT
The element type of the set.
DomainT
The segment type of the set.
interval_type
Comparison functor for intervals.
exclusive_less_than< interval_type >
Comparison functor for keys.
exclusive_less_than< interval_type >
The allocator type of the set.
Alloc< interval_type >
allocator type of the corresponding element set
Alloc< DomainT >
The corresponding atomized type representing this interval container of elements.
base_type::atomized_type
Container type for the implementation.
base_type::ImplSetT
key type of the implementing container
ImplSetT::key_type
data type of the implementing container
ImplSetT::value_type
value type of the implementing container
ImplSetT::value_type
iterator for iteration over intervals
ImplSetT::iterator
const_iterator for iteration over intervals
ImplSetT::const_iterator
typedef `Interval` `DomainT` `Compare` The interval type of the set.
typedef `Compare` `DomainT` Comparison functor for domain values.
void `const `interval_base_set`< SubType, DomainT, Compare, Interval, Alloc > &` Assignment from a base `interval_set`.
Default constructor for the empty object.
const `interval_set` &
Copy constructor.
const `interval_base_set`< SubType, DomainT, Compare, Interval, Alloc > &
Copy constructor for base_type.
const domain_type &
Constructor for a single element.
const interval_type &
Constructor for a single interval.
`interval_set` & `const `interval_base_set`< SubType, DomainT, Compare, Interval, Alloc > &` Assignment operator for base type.
interval_set
&&
Move constructor.
`interval_set` & ``interval_set`` Move assignment operator.
iterator `iterator`
iterator `const interval_type &` `iterator`
iterator `const interval_type &`
ICL_COMPARE
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::interval_set< DomainT
Compare
Interval
Alloc >
is_interval_container< `icl::interval_set`< DomainT, Compare, Interval, Alloc > >
bool
value
true
ICL_COMPARE
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::interval_set< DomainT
Compare
Interval
Alloc >
is_interval_joiner< `icl::interval_set`< DomainT, Compare, Interval, Alloc > >
bool
value
true
ICL_COMPARE
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::interval_set< DomainT
Compare
Interval
Alloc >
is_set< `icl::interval_set`< DomainT, Compare, Interval, Alloc > >
bool
value
true
ICL_COMPARE
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::interval_set< DomainT
Compare
Interval
Alloc >
std::string
interval_traits< Type >
`interval_traits`< Type >::domain_type
difference_type_of< domain_type >::type
interval_traits< Type >
`interval_traits`< Type >::domain_type
`interval_traits`
domain_type_of< Type >::`type`
Type `const domain_type &` `const domain_type &`
domain_type `const Type &`
domain_type `const Type &`
interval_traits< Type >
`interval_traits`< Type >::domain_type
size_type_of< domain_type >::type
Performes an addition using a container's memberfunction add, when operator= is called.
The container's type.
ContainerT
std::output_iterator_tag
void
void
void
void
`add_iterator` &
`add_iterator` &
`add_iterator` & `int`
ContainerT &
typename ContainerT::iterator

An `add_iterator` is constructed with a container and a position that has to be maintained.

`add_iterator` & `typename ContainerT::const_reference`

This assignment operator adds the `value` before the current position. It maintains it's position by incrementing after addition.

Performes an insertion using a container's memberfunction add, when operator= is called.
The container's type.
ContainerT
std::output_iterator_tag
void
void
void
void
`insert_iterator` &
`insert_iterator` &
`insert_iterator` & `int`
ContainerT &
typename ContainerT::iterator

An `insert_iterator` is constructed with a container and a position that has to be maintained.

`insert_iterator` & `typename ContainerT::const_reference`

This assignment operator adds the `value` before the current position. It maintains it's position by incrementing after addition.

`add_iterator`< ContainerT > `ContainerT &` `IteratorT`

Function adder creates and initializes an `add_iterator`

`insert_iterator`< ContainerT > `ContainerT &` `IteratorT`

Function inserter creates and initializes an `insert_iterator`

ICL_COMPARE
left_open_interval< DomainT
Compare >
interval_bound_type
bound_type
value
interval_bounds::static_left_open
ICL_COMPARE
icl::left_open_interval< DomainT
Compare >
DomainT
`icl::left_open_interval`< DomainT, Compare >
typedef `Compare` `DomainT`
`interval_type` `const domain_type &` `const domain_type &`
domain_type `const `interval_type` &`
domain_type `const `interval_type` &`
ICL_COMPARE ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT)
`left_open_interval`< DomainT, Compare >
DomainT
typedef `Compare` `DomainT`
DomainT
DomainT

Default constructor; yields an empty interval `(0,0]`.

const DomainT &

Constructor for a left-open singleton interval `(val-1,val]`

const DomainT &
const DomainT &

Interval from `low` to `up` with bounds `bounds`

ICL_COMPARE
icl::left_open_interval< DomainT
Compare >
std::string
ICL_COMPARE
icl::left_open_interval< DomainT
Compare >
std::size_t `const `icl::left_open_interval`< DomainT > &`
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_ALLOC
icl::map< DomainT
CodomainT
Traits
Compare
Combine
Section
Alloc >
absorbs_identities
int
value
Traits::absorbs_identities
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_ALLOC
icl::map< DomainT
CodomainT
Traits
Compare
Combine
Section
Alloc >
has_inverse< `icl::map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > >
bool
value
(has_inverse< CodomainT >::value)
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_ALLOC
icl::map< DomainT
CodomainT
Traits
Compare
Combine
Section
Alloc >
is_map< `icl::map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > >
bool
value
true
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_ALLOC
icl::map< DomainT
CodomainT
Traits
Compare
Combine
Section
Alloc >
is_total
int
value
Traits::is_total

boost::icl::partial_absorber

icl::partial_absorber
ICL_COMPARE ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT)
ICL_COMBINE ICL_COMBINE_INSTANCE(`icl::inplace_plus`, CodomainT)
ICL_SECTION ICL_SECTION_INSTANCE(`icl::inter_section`, CodomainT)
ICL_ALLOC std::allocator
ICL_IMPL_SPACE::map< DomainT, CodomainT, ICL_COMPARE_DOMAIN(Compare, DomainT), Alloc< std::pair< const DomainT, CodomainT > > >
Addable, subractable and intersectable maps.
bool
bool
Type
false
false
void `Type &` `typename Type::iterator` `const typename Type::codomain_type &`
Type
false
true
void `Type &` `typename Type::iterator` `const typename Type::codomain_type &`
Type
true
false
Type::inverse_codomain_intersect
void `Type &` `typename Type::iterator` `const typename Type::codomain_type &`
Type
true
true
Type::inverse_codomain_intersect
void `Type &` `typename Type::iterator` `const typename Type::codomain_type &`
bool
Type
false
void `Type &` `const Type &` `const element_type &`
Type
true
void `Type &` `const Type &` `const element_type &`
bool
Type
false
Type::element_type
Type::inverse_codomain_combine
void `Type &` `const element_type &`
Type
true
Type::element_type
Type::inverse_codomain_combine
void `Type &` `const element_type &`
bool
bool
Type
false
false
Type::element_type
Type::codomain_type
Type::iterator
Type::inverse_codomain_intersect
void `Type &` `const element_type &`
Type
false
true
Type::element_type
Type::codomain_type
Type::iterator
Type::inverse_codomain_intersect
void `Type &` `const element_type &`
Type
true
false
Type::element_type
Type::codomain_type
void `Type &` `const element_type &`
Type
true
true
Type::element_type
void `Type &` `const typename Type::element_type &`
Alloc< typename std::pair< const DomainT, CodomainT > >
`icl::map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >
ICL_IMPL_SPACE::map< DomainT, CodomainT, ICL_COMPARE_DOMAIN(Compare, DomainT), allocator_type >
Traits
DomainT
boost::call_traits< DomainT >::param_type
DomainT
CodomainT
CodomainT
CodomainT
std::pair< const DomainT, CodomainT >
std::pair< const DomainT, CodomainT >
domain_compare
`inverse`< codomain_combine >::`type`
mpl::if_< has_set_semantics< codomain_type >, ICL_SECTION_CODOMAIN(Section, CodomainT), codomain_combine >::`type`
`inverse`< codomain_intersect >::`type`
base_type::value_compare
ICL_IMPL_SPACE::set< DomainT, domain_compare, Alloc< DomainT > >
set_type
on_absorbtion< `type`, codomain_combine, Traits::absorbs_identities >
base_type::pointer
base_type::const_pointer
base_type::reference
base_type::const_reference
base_type::iterator
base_type::const_iterator
base_type::size_type
base_type::difference_type
base_type::reverse_iterator
base_type::const_reverse_iterator
typedef `Compare` `DomainT`
typedef `Combine` `CodomainT`
typedef `Compare` `element_type`
bool
_total
(Traits::is_total)
bool
_absorbs
(Traits::absorbs_identities)
bool
total_invertible
(mpl::and_< is_total< `type` >, has_inverse< codomain_type > >::value)
bool
is_total_invertible
(Traits::is_total &&has_inverse< codomain_type >::value)
int
fineness
4
void ``map` &`
bool `const SubObject &`
bool `const `map` &`
std::size_t

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

codomain_type `const domain_type &`

Total select function.

`map` & `const value_type &`

`add` inserts `value_pair` into the map if it's key does not exist in the map. If `value_pairs's` key value exists in the map, it's data value is added to the data value already found in the map.

iterator `iterator` `const value_type &`

`add` add `value_pair` into the map using `prior` as a hint to insert `value_pair` after the position `prior` is pointing to.

`map` & `const element_type &`

If the `value_pair's` key value is in the map, it's data value is subtraced from the data value stored in the map.

`map` & `const domain_type &`
std::pair< iterator, bool > `const value_type &`
iterator `iterator` `const value_type &`
iterator `Iterator` `Iterator`
`map` & `const element_type &`

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

size_type `const element_type &`

erase `key_value_pair` from the map. Erase only if, the exact value content `val` is stored for the given key.

void ``map` &` `const element_type &`

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

`map` & `const element_type &`
`map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > & `const element_type &`
`map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > & `const value_type &`
const key_compare &
InputIterator
InputIterator
InputIterator
InputIterator
const key_compare &
const `map` &
const element_type &
map
&&
`map` & ``map``
`map` & `const element_type &`
iterator `iterator` `const element_type &`
`map` & `const element_type &`
void ``type` &` `const FragmentT &`
void ``type` &` `const element_type &`
= true
= false
= false
= false
= true
= true
= false
= true
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_ALLOC
icl::map< DomainT
CodomainT
Traits
Compare
Combine
Section
Alloc >
std::string
ICL_COMPARE
open_interval< DomainT
Compare >
interval_bound_type
bound_type
value
interval_bounds::static_open
ICL_COMPARE
icl::open_interval< DomainT
Compare >
DomainT
`icl::open_interval`< DomainT, Compare >
typedef `Compare` `DomainT`
`interval_type` `const domain_type &` `const domain_type &`
domain_type `const `interval_type` &`
domain_type `const `interval_type` &`
ICL_COMPARE ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT)
`open_interval`< DomainT, Compare >
DomainT
typedef `Compare` `DomainT`
DomainT
DomainT

Default constructor; yields an empty interval `(0,0)`.

const DomainT &

Constructor for an open singleton interval `(val-1,val+1)`

const DomainT &
const DomainT &

Interval from `low` to `up` with bounds `bounds`

ICL_COMPARE
icl::open_interval< DomainT
Compare >
std::string
ICL_COMPARE
icl::open_interval< DomainT
Compare >
std::size_t `const `icl::open_interval`< DomainT > &`
boost::posix_time::ptime
boost::posix_time::time_duration
boost::posix_time::ptime
has_difference
bool
value
true
boost::posix_time::time_duration
has_difference
bool
value
true
boost::posix_time::ptime
is_discrete
bool
value
true
boost::posix_time::time_duration
is_discrete
bool
value
true
boost::posix_time::ptime
boost::posix_time::time_duration
boost::posix_time::time_duration
boost::posix_time::time_duration
boost::posix_time::ptime `boost::posix_time::ptime &`
boost::posix_time::ptime `boost::posix_time::ptime &`
boost::posix_time::time_duration `boost::posix_time::time_duration &`
boost::posix_time::time_duration `boost::posix_time::time_duration &`
boost::rational< Integral >
has_inverse
bool
value
(boost::is_signed< Integral >::value)
boost::rational< Integral >
is_continuous
bool
value
true
boost::rational< Integral >
is_discrete
bool
value
false
boost::rational< Integral >
is_numeric
bool
value
true
ICL_COMPARE
right_open_interval< DomainT
Compare >
interval_bound_type
bound_type
value
interval_bounds::static_right_open
ICL_COMPARE
icl::right_open_interval< DomainT
Compare >
DomainT
`icl::right_open_interval`< DomainT, Compare >
typedef `Compare` `DomainT`
`interval_type` `const domain_type &` `const domain_type &`
domain_type `const `interval_type` &`
domain_type `const `interval_type` &`
ICL_COMPARE ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT)
`right_open_interval`< DomainT, Compare >
DomainT
typedef `Compare` `DomainT`
domain_type
domain_type

Default constructor; yields an empty interval `[0,0)`.

const DomainT &

Constructor for a singleton interval `[val,val+1)`

const DomainT &
const DomainT &

Interval from `low` to `up` with bounds `bounds`

ICL_COMPARE
icl::right_open_interval< DomainT
Compare >
std::string
ICL_COMPARE
icl::right_open_interval< DomainT
Compare >
std::size_t `const `icl::right_open_interval`< DomainT > &`
ICL_COMPARE
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::separate_interval_set< DomainT
Compare
Interval
Alloc >
is_interval_container< `icl::separate_interval_set`< DomainT, Compare, Interval, Alloc > >
bool
value
true
ICL_COMPARE
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::separate_interval_set< DomainT
Compare
Interval
Alloc >
is_interval_separator< `icl::separate_interval_set`< DomainT, Compare, Interval, Alloc > >
bool
value
true
ICL_COMPARE
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::separate_interval_set< DomainT
Compare
Interval
Alloc >
is_set< `icl::separate_interval_set`< DomainT, Compare, Interval, Alloc > >
bool
value
true
ICL_COMPARE ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT)
ICL_INTERVAL(ICL_COMPARE) ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare)
ICL_ALLOC std::allocator
boost::icl::interval_base_set< separate_interval_set< DomainT, Compare, Interval, Alloc >, DomainT, Compare, Interval, Alloc >
Implements a set as a set of intervals - leaving adjoining intervals separate.
= 2
`separate_interval_set`< DomainT, Compare, Interval, Alloc >
`interval_base_set`< `type`, DomainT, Compare, Interval, Alloc >
`type`
`type`
`interval_set`< DomainT, Compare, Interval, Alloc >
The domain type of the set.
DomainT
The codomaintype is the same as domain_type.
DomainT
The element type of the set.
DomainT
The segment type of the set.
interval_type
Comparison functor for intervals.
exclusive_less_than< interval_type >
Comparison functor for keys.
exclusive_less_than< interval_type >
The allocator type of the set.
Alloc< interval_type >
allocator type of the corresponding element set
Alloc< DomainT >
The corresponding atomized type representing this interval container of elements.
base_type::atomized_type
Container type for the implementation.
base_type::ImplSetT
key type of the implementing container
ImplSetT::key_type
data type of the implementing container
ImplSetT::value_type
value type of the implementing container
ImplSetT::value_type
iterator for iteration over intervals
ImplSetT::iterator
const_iterator for iteration over intervals
ImplSetT::const_iterator
typedef `Interval` `DomainT` `Compare` The interval type of the set.
typedef `Compare` `DomainT` Comparison functor for domain values.
void `const `interval_base_set`< SubType, DomainT, Compare, Interval, Alloc > &` Assignment from a base `interval_set`.
Default constructor for the empty object.
const `separate_interval_set` &
Copy constructor.
const `interval_base_set`< SubType, DomainT, Compare, Interval, Alloc > &
Copy constructor for base_type.
const domain_type &
Constructor for a single element.
const interval_type &
Constructor for a single interval.
`separate_interval_set` & `const `interval_base_set`< SubType, DomainT, Compare, Interval, Alloc > &` Assignment operator for base type.
separate_interval_set
&&
Move constructor.
`separate_interval_set` & ``separate_interval_set`` Move assignment operator.
iterator `iterator`
iterator `const interval_type &` `iterator`
iterator `const interval_type &`
ICL_COMPARE
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::separate_interval_set< DomainT
Compare
Interval
Alloc >
std::string
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::split_interval_map< DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
absorbs_identities< `icl::split_interval_map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
bool
value
(Traits::absorbs_identities)
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::split_interval_map< DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
has_inverse< `icl::split_interval_map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
bool
value
(has_inverse< CodomainT >::value)
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::split_interval_map< DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
is_interval_container< `icl::split_interval_map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
bool
value
true
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::split_interval_map< DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
is_interval_splitter< `icl::split_interval_map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
bool
value
true
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::split_interval_map< DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
is_map< `icl::split_interval_map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
bool
value
true
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::split_interval_map< DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
is_total< `icl::split_interval_map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
bool
value
(Traits::is_total)

boost::icl::partial_absorber

icl::partial_absorber
ICL_COMPARE ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT)
ICL_COMBINE ICL_COMBINE_INSTANCE(`icl::inplace_plus`, CodomainT)
ICL_SECTION ICL_SECTION_INSTANCE(`icl::inter_section`, CodomainT)
ICL_INTERVAL(ICL_COMPARE) ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare)
ICL_ALLOC std::allocator
boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, 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.
= 3
Traits
`split_interval_map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >
`interval_map`< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >
`type`
`interval_base_map`< `type`, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >
DomainT
CodomainT
base_type::iterator
base_type::value_type
base_type::element_type
base_type::segment_type
base_type::domain_mapping_type
base_type::interval_mapping_type
base_type::ImplMapT
base_type::codomain_combine
`interval_set`< DomainT, Compare, Interval, Alloc >
`interval_set_type`
`set_type`
typedef `Interval` `DomainT` `Compare`
void `const `interval_base_map`< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &` Assignment from a base `interval_map`.
Default constructor for the empty object.
const `split_interval_map` &
Copy constructor.
const `domain_mapping_type` &
const value_type &
`split_interval_map` & `const `interval_base_map`< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &` Assignment operator for base type.
split_interval_map
&&
Move constructor.
`split_interval_map` & ``split_interval_map`` Move assignment operator.
iterator `iterator`
void `iterator` `iterator`
void `iterator`
void `iterator`
void `iterator` `iterator &`
void `iterator` `iterator`
void `iterator`
void `iterator &` `iterator` `const interval_type &` `const codomain_type &`
ICL_COMPARE
ICL_COMBINE
ICL_SECTION
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::split_interval_map< DomainT
CodomainT
Traits
Compare
Combine
Section
Interval
Alloc >
std::string
ICL_COMPARE
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::split_interval_set< DomainT
Compare
Interval
Alloc >
is_interval_container< `icl::split_interval_set`< DomainT, Compare, Interval, Alloc > >
bool
value
true
ICL_COMPARE
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::split_interval_set< DomainT
Compare
Interval
Alloc >
is_interval_splitter< `icl::split_interval_set`< DomainT, Compare, Interval, Alloc > >
bool
value
true
ICL_COMPARE
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::split_interval_set< DomainT
Compare
Interval
Alloc >
is_set< `icl::split_interval_set`< DomainT, Compare, Interval, Alloc > >
bool
value
true
ICL_COMPARE ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT)
ICL_INTERVAL(ICL_COMPARE) ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare)
ICL_ALLOC std::allocator
boost::icl::interval_base_set< split_interval_set< DomainT, Compare, Interval, Alloc >, DomainT, Compare, Interval, Alloc >
implements a set as a set of intervals - on insertion overlapping intervals are split
= 3
`split_interval_set`< DomainT, Compare, Interval, Alloc >
`interval_base_set`< `type`, DomainT, Compare, Interval, Alloc >
`interval_set`< DomainT, Compare, Interval, Alloc >
`type`
`type`
The domain type of the set.
DomainT
The codomaintype is the same as domain_type.
DomainT
The element type of the set.
DomainT
The segment type of the set.
interval_type
Comparison functor for intervals.
exclusive_less_than< interval_type >
Comparison functor for keys.
exclusive_less_than< interval_type >
The allocator type of the set.
Alloc< interval_type >
allocator type of the corresponding element set
Alloc< DomainT >
The corresponding atomized type representing this interval container of elements.
base_type::atomized_type
Container type for the implementation.
base_type::ImplSetT
key type of the implementing container
ImplSetT::key_type
data type of the implementing container
ImplSetT::value_type
value type of the implementing container
ImplSetT::value_type
iterator for iteration over intervals
ImplSetT::iterator
const_iterator for iteration over intervals
ImplSetT::const_iterator
typedef `Interval` `DomainT` `Compare` The interval type of the set.
typedef `Compare` `DomainT` Comparison functor for domain values.
void `const `interval_base_set`< SubType, DomainT, Compare, Interval, Alloc > &` Assignment from a base `interval_set`.
Default constructor for the empty object.
const `split_interval_set` &
Copy constructor.
const `interval_base_set`< SubType, DomainT, Compare, Interval, Alloc > &
Copy constructor for base_type.
const interval_type &
Constructor for a single element.
const domain_type &
Constructor for a single interval.
`split_interval_set` & `const `interval_base_set`< SubType, DomainT, Compare, Interval, Alloc > &` Assignment operator for base type.
split_interval_set
&&
Move constructor.
`split_interval_set` & ``split_interval_set`` Move assignment operator.
iterator `iterator`
iterator `const interval_type &` `iterator`
iterator `const interval_type &`
ICL_COMPARE
ICL_INTERVAL(ICL_COMPARE)
ICL_ALLOC
icl::split_interval_set< DomainT
Compare
Interval
Alloc >
std::string