closed_interval< DomainT, Compare > DomainT typedefCompareDomainT 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 closed_interval< DomainTCompare >interval_bound_type bound_typevalueinterval_bounds::static_closed icl::closed_interval< DomainTCompare >DomainT icl::closed_interval< DomainT, Compare > typedefCompareDomainT interval_typeconst domain_type &const domain_type & domain_typeconst interval_type & domain_typeconst interval_type & icl::closed_interval< DomainTCompare > std::string icl::closed_interval< DomainT > std::size_tconst icl::closed_interval< DomainT > &

continuous_interval< DomainT, Compare > DomainT bounded_value< DomainT >::type typedefCompareDomainT 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_boundsinterval_bounds::right_open()continuous_interval *0Interval from low to up with bounds bounds continuous_intervalconst DomainT &const DomainT & continuous_intervalconst DomainT &const DomainT & continuous_intervalconst DomainT &const DomainT & continuous_intervalconst DomainT &const DomainT & boost::icl::continuous_interval< DomainTCompare >dynamic_interval_traits boost::icl::continuous_interval< DomainT, Compare > DomainT typedefCompareDomainT interval_typeconst domain_typeconst domain_typeinterval_bounds interval_typeconst bounded_value< DomainT > &const bounded_value< DomainT > & continuous_interval< DomainTCompare >interval_bound_type bound_typevalueinterval_bounds::dynamic icl::continuous_interval< DomainTCompare >interval_traits DomainT icl::continuous_interval< DomainT, Compare > typedefCompareDomainT interval_typeconst domain_type &const domain_type & domain_typeconst interval_type & domain_typeconst interval_type & continuous_interval< DomainTCompare >is_continuous_interval< continuous_interval< DomainT, Compare > > boolvaluetrue icl::continuous_interval< DomainTCompare > std::string icl::continuous_interval< DomainT > std::size_tconst icl::continuous_interval< DomainT > &

discrete_interval< DomainT, Compare > DomainT bounded_value< DomainT >::type typedefCompareDomainT 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_boundsinterval_bounds::right_open()discrete_interval *0Interval from low to up with bounds bounds discrete_intervalconst DomainT &const DomainT & discrete_intervalconst DomainT &const DomainT & discrete_intervalconst DomainT &const DomainT & discrete_intervalconst DomainT &const DomainT & boost::icl::discrete_interval< DomainTCompare >dynamic_interval_traits boost::icl::discrete_interval< DomainT, Compare > DomainT typedefCompareDomainT interval_typeconst domain_type &const domain_type &interval_bounds interval_typeconst bounded_value< DomainT > &const bounded_value< DomainT > & discrete_interval< DomainTCompare >interval_bound_type bound_typevalueinterval_bounds::dynamic icl::discrete_interval< DomainTCompare >interval_traits DomainT icl::discrete_interval< DomainT, Compare > typedefCompareDomainT interval_typeconst domain_type &const domain_type & domain_typeconst interval_type & domain_typeconst interval_type & discrete_interval< DomainTCompare >is_discrete_interval< discrete_interval< DomainT, Compare > > boolvalueis_discrete< DomainT >::value icl::discrete_interval< DomainTCompare > std::string icl::discrete_interval< DomainT > std::size_tconst icl::discrete_interval< DomainT > &

Type::domain_type Type::domain_compare Typeconst domain_type &const domain_type &interval_bounds Typeconst bounded_value< domain_type > &const bounded_value< domain_type > &

conversion< Combiner > remove_const< typename remove_reference< typename Combiner::first_argument_type >::type >::type argument_typeconst argument_type & argument_typeconst argument_type & Type & const Type & void Type boost::icl::identity_based_inplace_combine< Type >inplace_bit_add< Type > voidType &const Type & voidType & boost::icl::identity_based_inplace_combine< Type >inplace_bit_and< Type > voidType &const Type & boost::icl::identity_based_inplace_combine< Type >inplace_bit_subtract< Type > voidType &const Type & boost::icl::identity_based_inplace_combine< Type >inplace_bit_xor< Type > voidType &const Type & boost::icl::identity_based_inplace_combine< Type >inplace_caret< Type > voidType &const Type & boost::icl::identity_based_inplace_combine< Type >inplace_erase< Type > voidType &const Type & boost::icl::identity_based_inplace_combine< Type >inplace_erasure< Type > identity_based_inplace_combine< Type > voidType &const Type & boost::icl::identity_based_inplace_combine< Type >inplace_et< Type > voidType &const Type & boost::icl::identity_based_inplace_combine< Type >inplace_identity< Type > voidType &const Type & boost::icl::identity_based_inplace_combine< Type >inplace_insert< Type > voidType &const Type & boost::icl::identity_based_inplace_combine< Type >inplace_max< Type > voidType &const Type & boost::icl::identity_based_inplace_combine< Type >inplace_min< Type > voidType &const Type & boost::icl::identity_based_inplace_combine< Type >inplace_minus< Type > voidType &const Type & boost::icl::identity_based_inplace_combine< Type >inplace_plus< Type > voidType &const Type & voidType & boost::icl::identity_based_inplace_combine< Type >inplace_slash< Type > voidType &const Type & boost::icl::identity_based_inplace_combine< Type >inplace_star< Type > voidType &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 voidType &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 voidType &const Type & is_negative< Functor > boolvaluefalse icl::inplace_bit_subtract< Type >is_negative boolvaluetrue icl::inplace_minus< Type >is_negative boolvaluetrue Type & const Type & void Type boost::icl::conversion< Combiner >version< Combiner > conversion< Combiner > base_type::argument_type argument_typeconst argument_type & icl::inplace_minus< double > doubledouble icl::inplace_minus< float > floatfloat icl::inplace_minus< int > intint icl::inplace_minus< long > longlong icl::inplace_minus< long double > long doublelong double icl::inplace_minus< long long > long longlong long icl::inplace_minus< short > shortshort 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 Typeconst Type &

boost::gregorian::dateboost::gregorian::date_duration boost::gregorian::datehas_difference boolvaluetrue boost::gregorian::date_durationhas_difference boolvaluetrue boost::gregorian::date_duration boost::gregorian::date_duration boost::gregorian::dateis_discrete boolvaluetrue boost::gregorian::date_durationis_discrete boolvaluetrue boost::gregorian::dateboost::gregorian::date_duration boost::gregorian::date_durationboost::gregorian::date_duration boost::gregorian::dateboost::gregorian::date & boost::gregorian::dateboost::gregorian::date & boost::gregorian::date_durationboost::gregorian::date_duration & boost::gregorian::date_durationboost::gregorian::date_duration &

interval_type_default< DomainT, Compare >::type interval_type interval_typeconst DomainT &const DomainT & interval_typeconst DomainT &const DomainT & interval_typeconst DomainT &const DomainT & interval_typeconst DomainT &const DomainT & interval_typeconst DomainT &const DomainT & IntervalTfalsePretendedBoundsRepresentedBoundsinterval_traits< IntervalT >::domain_type IntervalTconst domain_type &const domain_type & IntervalTtruePretendedBoundsRepresentedBoundsinterval_traits< IntervalT >::domain_type IntervalTconst domain_type &const domain_type &

icl::interval_base_map< SubTypeDomainTCodomainTTraitsCompareCombineSectionIntervalAlloc >absorbs_identities< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > boolvalue(Traits::absorbs_identities) icl::interval_base_map< SubTypeDomainTCodomainTTraitsCompareCombineSectionIntervalAlloc >has_inverse< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > boolvalue(has_inverse< CodomainT >::value) Implements a map as a map of intervals (base class) TypefalseType::interval_type Type::codomain_type Type::segment_type Type::codomain_combine voidType &interval_type &const codomain_type &const codomain_type & TypetrueType::interval_type Type::codomain_type Type::segment_type Type::codomain_combine Type::inverse_codomain_intersect voidType &interval_type &const codomain_type &const codomain_type & Typefalse voidType &const Type &const segment_type & Typetrue voidType &const Type &const segment_type & TypefalseType::segment_type Type::inverse_codomain_combine voidType &const segment_type & TypetrueType::segment_type Type::inverse_codomain_combine voidType &const segment_type & Typefalseabsorbs_identitiesType::segment_type Type::codomain_type Type::interval_type Type::value_type Type::const_iterator Type::set_type Type::inverse_codomain_intersect voidType &const segment_type & TypetruefalseType::segment_type Type::codomain_type voidType &const segment_type & Typetruetrue voidType &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 typedefIntervalDomainTCompareThe interval type of the map. typedefCompareDomainTComparison functor for domain values. typedefComparesegment_type typedefCombineCodomainTCombine functor for codomain value aggregation. boolis_total_invertible(Traits::is_total &&has_inverse< codomain_type >::value) intfineness0 voidinterval_base_map &swap the content of containers voidclear the map boolis the map empty? size_typeAn interval map's size is it's cardinality std::size_tSize of the iteration over this container const_iteratorconst domain_type &Find the interval value pair, that contains key const_iteratorconst interval_type &Find the first interval value pair, that collides with interval key_interval codomain_typeconst 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. iteratoriteratorconst 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. iteratoriteratorconst 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. voiditeratorErase all value pairs within the range of the interval that iterator position points to. voiditeratoriteratorErase all value pairs for a range of iterators [first,past). voidSubType &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. iteratorconst key_type & iteratorconst key_type & const_iteratorconst key_type & const_iteratorconst 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_mapMove assignment operator iteratorconst segment_type & iteratoriteratorconst segment_type & voidconst segment_type & iteratorconst segment_type & iteratoriteratorconst segment_type & voidconst interval_type &const CodomainT &iterator & voidinterval_type &const CodomainT &iterator &const iterator & voidconst interval_type &const CodomainT &iterator & voidconst interval_type &iterator & voidconst interval_type &iterator & voidconst CodomainT &iterator &const iterator & voidinterval_type &const CodomainT &iterator & voidconst interval_type &const CodomainT &iterator &const iterator & voidinterval_type &const CodomainT &iterator &const iterator & voidSubType &const FragmentT & voidSubType &const segment_type & voidSubType &const element_type & iteratoriteratorconst 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::interval_base_map< SubTypeDomainTCodomainTTraitsCompareCombineSectionIntervalAlloc >is_interval_container< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > boolvaluetrue icl::interval_base_map< SubTypeDomainTCodomainTTraitsCompareCombineSectionIntervalAlloc >is_map< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > boolvaluetrue icl::interval_base_map< SubTypeDomainTCodomainTTraitsCompareCombineSectionIntervalAlloc >is_total< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > boolvalue(Traits::is_total) DomainT CodomainT const DomainT &const CodomainT & const std::pair< DomainT, CodomainT > &

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 > typedefIntervalDomainTCompareThe interval type of the set. typedefCompareDomainTComparison functor for domain values. typedefComparesegment_type intfineness0 voidinterval_base_set &swap the content of containers voidsets the container empty boolis the container empty? size_typeAn interval set's size is it's cardinality std::size_tSize of the iteration over this container const_iteratorconst element_type &Find the interval, that contains element key_value const_iteratorconst 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 iteratoriteratorconst 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 iteratoriteratorconst 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 voiditeratorErase the interval that iterator position points to. voiditeratoriteratorErase 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 iteratorconst value_type & iteratorconst value_type & const_iteratorconst value_type & const_iteratorconst 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_setMove assignment operator iteratorconst segment_type & iteratoriteratorconst segment_type & voidconst interval_type &iterator & voidinterval_type &iterator &const iterator & voidconst interval_type &iterator & voidconst interval_type &iterator & sub_type * const sub_type * icl::interval_base_set< SubTypeDomainTCompareIntervalAlloc >is_interval_container< icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc > > boolvaluetrue icl::interval_base_set< SubTypeDomainTCompareIntervalAlloc >is_set< icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc > > boolvaluetrue

DomainT bounded_value< DomainT > domain_type interval_bounds const domain_type &interval_bounds bound_type bound_typestatic_open0 bound_typestatic_left_open1 bound_typestatic_right_open2 bound_typestatic_closed3 bound_typedynamic4 bound_typeundefined5 bound_type_open0 bound_type_left_open1 bound_type_right_open2 bound_type_closed3 bound_type_right1 bound_type_left2 bound_type_all3 interval_bounds interval_bounds interval_bounds interval_bounds interval_bounds bound_type bound_type interval_bounds interval_bounds interval_bounds interval_bounds unsigned char

intunknown0 intjoining1 intseparating2 intsplitting3 intelemental4

icl::interval_map< DomainTCodomainTTraitsCompareCombineSectionIntervalAlloc >absorbs_identities< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > boolvalue(Traits::absorbs_identities) icl::interval_map< DomainTCodomainTTraitsCompareCombineSectionIntervalAlloc >has_inverse< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > boolvalue(has_inverse< CodomainT >::value) 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 typedefIntervalDomainTCompare voidconst 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_mapMove assignment operator. iteratoriterator voiditeratoriterator voiditerator voiditerator voiditeratoriterator & voiditeratoriterator voiditerator voiditerator &iteratorconst interval_type &const codomain_type & icl::interval_map< DomainTCodomainTTraitsCompareCombineSectionIntervalAlloc >is_interval_container< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > boolvaluetrue icl::interval_map< DomainTCodomainTTraitsCompareCombineSectionIntervalAlloc >is_map< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > boolvaluetrue icl::interval_map< DomainTCodomainTTraitsCompareCombineSectionIntervalAlloc >is_total< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > boolvalue(Traits::is_total) icl::interval_map< DomainTCodomainTTraitsCompareCombineSectionIntervalAlloc > std::string

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 typedefIntervalDomainTCompareThe interval type of the set. typedefCompareDomainTComparison functor for domain values. voidconst 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_setMove assignment operator. iteratoriterator iteratorconst interval_type &iterator iteratorconst interval_type & icl::interval_set< DomainTCompareIntervalAlloc >is_interval_container< icl::interval_set< DomainT, Compare, Interval, Alloc > > boolvaluetrue icl::interval_set< DomainTCompareIntervalAlloc >is_interval_joiner< icl::interval_set< DomainT, Compare, Interval, Alloc > > boolvaluetrue icl::interval_set< DomainTCompareIntervalAlloc >is_set< icl::interval_set< DomainT, Compare, Interval, Alloc > > boolvaluetrue icl::interval_set< DomainTCompareIntervalAlloc > 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 Typeconst domain_type &const domain_type & domain_typeconst Type & domain_typeconst 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::iteratorAn add_iterator is constructed with a container and a position that has to be maintained. add_iterator &typename ContainerT::const_referenceThis 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::iteratorAn insert_iterator is constructed with a container and a position that has to be maintained. insert_iterator &typename ContainerT::const_referenceThis assignment operator adds the value before the current position. It maintains it's position by incrementing after addition. add_iterator< ContainerT >ContainerT &IteratorTFunction adder creates and initializes an add_iterator insert_iterator< ContainerT >ContainerT &IteratorTFunction inserter creates and initializes an insert_iterator

left_open_interval< DomainTCompare >interval_bound_type bound_typevalueinterval_bounds::static_left_open icl::left_open_interval< DomainTCompare >DomainT icl::left_open_interval< DomainT, Compare > typedefCompareDomainT interval_typeconst domain_type &const domain_type & domain_typeconst interval_type & domain_typeconst interval_type & left_open_interval< DomainT, Compare > DomainT typedefCompareDomainT 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::left_open_interval< DomainTCompare > std::string icl::left_open_interval< DomainTCompare > std::size_tconst icl::left_open_interval< DomainT > &

icl::map< DomainTCodomainTTraitsCompareCombineSectionAlloc >absorbs_identities intvalueTraits::absorbs_identities icl::map< DomainTCodomainTTraitsCompareCombineSectionAlloc >has_inverse< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > > boolvalue(has_inverse< CodomainT >::value) icl::map< DomainTCodomainTTraitsCompareCombineSectionAlloc >is_map< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > > boolvaluetrue icl::map< DomainTCodomainTTraitsCompareCombineSectionAlloc >is_total intvalueTraits::is_total ICL_IMPL_SPACE::map< DomainT, CodomainT, ICL_COMPARE_DOMAIN(Compare, DomainT), Alloc< std::pair< const DomainT, CodomainT > > >Addable, subractable and intersectable maps. Typefalsefalse voidType &typename Type::iteratorconst typename Type::codomain_type & Typefalsetrue voidType &typename Type::iteratorconst typename Type::codomain_type & TypetruefalseType::inverse_codomain_intersect voidType &typename Type::iteratorconst typename Type::codomain_type & TypetruetrueType::inverse_codomain_intersect voidType &typename Type::iteratorconst typename Type::codomain_type & Typefalse voidType &const Type &const element_type & Typetrue voidType &const Type &const element_type & TypefalseType::element_type Type::inverse_codomain_combine voidType &const element_type & TypetrueType::element_type Type::inverse_codomain_combine voidType &const element_type & TypefalsefalseType::element_type Type::codomain_type Type::iterator Type::inverse_codomain_intersect voidType &const element_type & TypefalsetrueType::element_type Type::codomain_type Type::iterator Type::inverse_codomain_intersect voidType &const element_type & TypetruefalseType::element_type Type::codomain_type voidType &const element_type & TypetruetrueType::element_type voidType &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 typedefCompareDomainT typedefCombineCodomainT typedefCompareelement_type bool_total(Traits::is_total) bool_absorbs(Traits::absorbs_identities) booltotal_invertible(mpl::and_< is_total< type >, has_inverse< codomain_type > >::value) boolis_total_invertible(Traits::is_total &&has_inverse< codomain_type >::value) intfineness4 voidmap & boolconst SubObject & boolconst map & std::size_titerative_size() yields the number of elements that is visited throu complete iteration. For interval sets iterative_size() is different from size(). codomain_typeconst 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. iteratoriteratorconst 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 & iteratoriteratorconst value_type & iteratorIteratorIterator map &const element_type &With key_value_pair = (k,v) set value v for key k size_typeconst element_type &erase key_value_pair from the map. Erase only if, the exact value content val is stored for the given key. voidmap &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 & InputIteratorInputIterator InputIteratorInputIteratorconst key_compare & const map & const element_type & map && map &map map &const element_type & iteratoriteratorconst element_type & map &const element_type & voidtype &const FragmentT & voidtype &const element_type & = true = false = false = false = true = true = false = true icl::map< DomainTCodomainTTraitsCompareCombineSectionAlloc > std::string

open_interval< DomainTCompare >interval_bound_type bound_typevalueinterval_bounds::static_open icl::open_interval< DomainTCompare >DomainT icl::open_interval< DomainT, Compare > typedefCompareDomainT interval_typeconst domain_type &const domain_type & domain_typeconst interval_type & domain_typeconst interval_type & open_interval< DomainT, Compare > DomainT typedefCompareDomainT 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::open_interval< DomainTCompare > std::string icl::open_interval< DomainTCompare > std::size_tconst icl::open_interval< DomainT > &

boost::posix_time::ptimeboost::posix_time::time_duration boost::posix_time::ptimehas_difference boolvaluetrue boost::posix_time::time_durationhas_difference boolvaluetrue boost::posix_time::ptimeis_discrete boolvaluetrue boost::posix_time::time_durationis_discrete boolvaluetrue boost::posix_time::ptimeboost::posix_time::time_duration boost::posix_time::time_durationboost::posix_time::time_duration boost::posix_time::ptimeboost::posix_time::ptime & boost::posix_time::ptimeboost::posix_time::ptime & boost::posix_time::time_durationboost::posix_time::time_duration & boost::posix_time::time_durationboost::posix_time::time_duration &

boost::rational< Integral >has_inverse boolvalue(boost::is_signed< Integral >::value) boost::rational< Integral >is_continuous boolvaluetrue boost::rational< Integral >is_discrete boolvaluefalse boost::rational< Integral >is_numeric boolvaluetrue

right_open_interval< DomainTCompare >interval_bound_type bound_typevalueinterval_bounds::static_right_open icl::right_open_interval< DomainTCompare >DomainT icl::right_open_interval< DomainT, Compare > typedefCompareDomainT interval_typeconst domain_type &const domain_type & domain_typeconst interval_type & domain_typeconst interval_type & right_open_interval< DomainT, Compare > DomainT typedefCompareDomainT 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::right_open_interval< DomainTCompare > std::string icl::right_open_interval< DomainTCompare > std::size_tconst icl::right_open_interval< DomainT > &

icl::separate_interval_set< DomainTCompareIntervalAlloc >is_interval_container< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > boolvaluetrue icl::separate_interval_set< DomainTCompareIntervalAlloc >is_interval_separator< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > boolvaluetrue icl::separate_interval_set< DomainTCompareIntervalAlloc >is_set< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > boolvaluetrue 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 typedefIntervalDomainTCompareThe interval type of the set. typedefCompareDomainTComparison functor for domain values. voidconst 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_setMove assignment operator. iteratoriterator iteratorconst interval_type &iterator iteratorconst interval_type & icl::separate_interval_set< DomainTCompareIntervalAlloc > std::string

icl::split_interval_map< DomainTCodomainTTraitsCompareCombineSectionIntervalAlloc >absorbs_identities< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > boolvalue(Traits::absorbs_identities) icl::split_interval_map< DomainTCodomainTTraitsCompareCombineSectionIntervalAlloc >has_inverse< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > boolvalue(has_inverse< CodomainT >::value) icl::split_interval_map< DomainTCodomainTTraitsCompareCombineSectionIntervalAlloc >is_interval_container< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > boolvaluetrue icl::split_interval_map< DomainTCodomainTTraitsCompareCombineSectionIntervalAlloc >is_interval_splitter< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > boolvaluetrue icl::split_interval_map< DomainTCodomainTTraitsCompareCombineSectionIntervalAlloc >is_map< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > boolvaluetrue icl::split_interval_map< DomainTCodomainTTraitsCompareCombineSectionIntervalAlloc >is_total< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > boolvalue(Traits::is_total) 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 typedefIntervalDomainTCompare voidconst 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_mapMove assignment operator. iteratoriterator voiditeratoriterator voiditerator voiditerator voiditeratoriterator & voiditeratoriterator voiditerator voiditerator &iteratorconst interval_type &const codomain_type & icl::split_interval_map< DomainTCodomainTTraitsCompareCombineSectionIntervalAlloc > std::string

icl::split_interval_set< DomainTCompareIntervalAlloc >is_interval_container< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > boolvaluetrue icl::split_interval_set< DomainTCompareIntervalAlloc >is_interval_splitter< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > boolvaluetrue icl::split_interval_set< DomainTCompareIntervalAlloc >is_set< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > boolvaluetrue 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 typedefIntervalDomainTCompareThe interval type of the set. typedefCompareDomainTComparison functor for domain values. voidconst 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_setMove assignment operator. iteratoriterator iteratorconst interval_type &iterator iteratorconst interval_type & icl::split_interval_set< DomainTCompareIntervalAlloc > std::string