diff --git a/doc/concepts.qbk b/doc/concepts.qbk index 871583e..bb1ec18 100644 --- a/doc/concepts.qbk +++ b/doc/concepts.qbk @@ -75,7 +75,7 @@ aspect is called __bi_conceptual__. The second and minor aspect is called __bi_i [[Practical][interval_sets(maps) can be used as sets(maps) of elements(element value pairs) ] [Segmentation information is available. - See e.g. [link boost_icl.examples.month_and_week_grid Time grids for months and weeks]]] + See e.g. [link boost_icl.examples.time_grids Time grids for months and weeks]]] ] On the __conceptual__ aspect @@ -173,7 +173,7 @@ and intervals that again serve for implementing `operator +=` and `operator -=`. [endsect][/ Abstract Sets and Maps] -[section Addability, Subtractability and Aggregate on Overlap] +[section:aggrovering Addability, Subtractability and Aggregate on Overlap] While ['*addition*] and ['*subtraction*] on `Sets` are implemented as ['*set union*] and ['*set difference*], diff --git a/doc/examples.qbk b/doc/examples.qbk index e309270..af85bc8 100644 --- a/doc/examples.qbk +++ b/doc/examples.qbk @@ -39,7 +39,7 @@ [Using /aggregate on overlap/ the heights of the party's tallest guests are computed. Associated values are aggregated via a maximum functor, that can be chosen as template parameter of an interval_map class template.]] - [[advanced][[link boost_icl.examples.time_grids_for_months_and_weeks Time grids for months and weeks]] + [[advanced][[link boost_icl.examples.time_grids Time grids for months and weeks]] [__spl_itv_set__] [Shows how the ['*border preserving*] __spl_itv_set__ can be used to create time partitions where different @@ -234,7 +234,7 @@ intervals. [endsect] -[section Time grids for months and weeks] +[section:time_grids Time grids for months and weeks] A __spl_itv_set__ preserves all interval borders on insertion and intersection operations. So given a __spl_itv_set__ and an addition of an interval diff --git a/doc/functions.qbk b/doc/functions.qbk index b8864ed..612afb0 100644 --- a/doc/functions.qbk +++ b/doc/functions.qbk @@ -35,7 +35,7 @@ introduced in section [link boost_icl.interface.function_synopsis Function Synop This section covers the most important polymorphical and namespace global functions of the *icl*. More specific functions can be looked up in the doxygen generated -[link interval_template_library_reference reference documentation]. +[link interval_container_library_reference reference documentation]. [section Overload tables] diff --git a/doc/functions_addition.qbk b/doc/functions_addition.qbk index c126c5f..ea8ce64 100644 --- a/doc/functions_addition.qbk +++ b/doc/functions_addition.qbk @@ -49,7 +49,7 @@ a /set union/ semantics is often attached `operators |=` and `|`. for element maps and /aggregate on overlap/ for interval maps. Find more on - [link boost_icl.concepts.addability__subtractability_and_aggregate_on_overlap ['addability of maps]] + [link boost_icl.concepts.aggrovering ['addability of maps]] and related [link boost_icl.semantics.maps ['semantic issues]] following the links. diff --git a/doc/functions_equivs_orderings.qbk b/doc/functions_equivs_orderings.qbk index b7f9455..cb398b8 100644 --- a/doc/functions_equivs_orderings.qbk +++ b/doc/functions_equivs_orderings.qbk @@ -34,7 +34,7 @@ [section Less on Intervals] -[ +[table [[ ] [Types][]] [[`x < y`] [__i] [`x` begins before `y` or, for equal beginnings `x` ends before `y`]] ] @@ -53,13 +53,11 @@ perceived as the sequence of elements between their lower and upper bound. This generalized lexicogrphical comparison in intervals can also be specified this way: -`x < y := x` begins before `y` or, for equal beginnings `x` ends before `y` - -[ +[table [] -[[`x < y`] [`:=`] [`x` begins before `y` or, for equal beginnings `x` ends before `y`. +[[`x < y`] [`:=`] [`x` begins before `y` or, for equal beginnings `x` ends before `y`.]] - The other operators can be deduced in the usual way]] +[[] [] [The other operators can be deduced in the usual way]] [[`x > y`] [`:=`] [`y < x`] ] [[`x <= y`] [`:=`] [`!(y < x)`] ] [[`x >= y`] [`:=`] [`!(x < y)`] ] diff --git a/doc/functions_subtraction.qbk b/doc/functions_subtraction.qbk index 873b757..af48a24 100644 --- a/doc/functions_subtraction.qbk +++ b/doc/functions_subtraction.qbk @@ -37,7 +37,7 @@ are given in the table above. the effect of the corresponding addition function. Find more on - [link boost_icl.concepts.addability__subtractability_and_aggregate_on_overlap ['subtractability of maps]] + [link boost_icl.concepts.aggrovering ['subtractability of maps]] and related [link boost_icl.semantics.maps ['semantic issues]] following the links. diff --git a/doc/html/ICL_IMPL_SPACE.html b/doc/html/ICL_IMPL_SPACE.html index 9901757..d4952ea 100644 --- a/doc/html/ICL_IMPL_SPACE.html +++ b/doc/html/ICL_IMPL_SPACE.html @@ -1,13 +1,13 @@
- +ICL_IMPL_SPACE
// In header: <boost/icl/impl_config.hpp>
+
+ICL_IMPL_SPACE| - |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct absorbs_identities<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct absorbs_identities<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct absorbs_identities<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef absorbs_identities type; + + // public member functions + BOOST_STATIC_CONSTANT(int, value = Traits::absorbs_identities); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct absorbs_identities<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct absorbs_identities<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct absorbs_identities<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct absorbs_identities<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct absorbs_identities<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef absorbs_identities type; + + // public member functions + BOOST_STATIC_CONSTANT(int, value = Traits::absorbs_identities); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct absorbs_identities<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct absorbs_identities<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct absorbs_identities<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct absorbs_identities<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct absorbs_identities<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef absorbs_identities type; + + // public member functions + BOOST_STATIC_CONSTANT(int, value = Traits::absorbs_identities); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct absorbs_identities<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct absorbs_identities<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct absorbs_identities<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct absorbs_identities<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct absorbs_identities<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct absorbs_identities<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef absorbs_identities type; + + // public member functions + BOOST_STATIC_CONSTANT(int, value = Traits::absorbs_identities); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct absorbs_identities<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef absorbs_identities type; + + // public member functions + BOOST_STATIC_CONSTANT(int, value = Traits::absorbs_identities); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct absorbs_identities<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef absorbs_identities type; + + // public member functions + BOOST_STATIC_CONSTANT(int, value = Traits::absorbs_identities); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct absorbs_identities<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct absorbs_identities<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::absorbs_identities<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct absorbs_identities<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef absorbs_identities< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::add_iterator — Performes an addition using a container's memberfunction add, when operator= is called.
+// In header: <boost/icl/iterator.hpp> + +template<typename ContainerT> +class add_iterator { +public: + // types + typedef ContainerT container_type; // The container's type. + typedef std::output_iterator_tag iterator_category; + + // construct/copy/destruct + add_iterator(ContainerT &, typename ContainerT::iterator); + add_iterator& operator=(typename ContainerT::const_reference); + + // public member functions + add_iterator & operator*(); + add_iterator & operator++(); + add_iterator & operator++(int); +};
add_iterator
+ public
+ construct/copy/destructadd_iterator(ContainerT & cont, typename ContainerT::iterator iter);+
An add_iterator is constructed with a container and a position that has to be maintained.
+add_iterator& operator=(typename ContainerT::const_reference value);+
This assignment operator adds the value before the current position. It maintains it's position by incrementing after addition.
add_iterator public member functionsadd_iterator & operator*();
add_iterator & operator++();
add_iterator & operator++(int);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::adder
+// In header: <boost/icl/iterator.hpp> + + +template<typename ContainerT, typename IteratorT> + add_iterator< ContainerT > adder(ContainerT & cont, IteratorT iter_);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::bounded_value
+// In header: <boost/icl/interval_bounds.hpp> + +template<typename DomainT> +class bounded_value { +public: + // types + typedef DomainT domain_type; + typedef bounded_value< DomainT > type; + + // construct/copy/destruct + bounded_value(const domain_type &, interval_bounds); + + // public member functions + domain_type value() const; + interval_bounds bound() const; +};
bounded_value
+ public
+ construct/copy/destructbounded_value(const domain_type & value, interval_bounds bound);
bounded_value public member functionsdomain_type value() const;
interval_bounds bound() const;
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::closed_interval
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, + ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, DomainT)> +class closed_interval { +public: + // types + typedef closed_interval< DomainT, Compare > type; + typedef DomainT domain_type; + + // construct/copy/destruct + closed_interval(); + closed_interval(const DomainT &); + closed_interval(const DomainT &, const DomainT &); + + // public member functions + DomainT lower() const; + DomainT upper() const; + DomainT first() const; + DomainT last() const; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::continuous_interval
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, + ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, DomainT)> +class continuous_interval { +public: + // types + typedef continuous_interval< DomainT, Compare > type; + typedef DomainT domain_type; + typedef bounded_value< DomainT >::type bounded_domain_type; + + // construct/copy/destruct + continuous_interval(); + continuous_interval(const DomainT &); + continuous_interval(const DomainT &, const DomainT &, + interval_bounds = interval_bounds::right_open(), + continuous_interval * = 0); + + // public member functions + domain_type lower() const; + domain_type upper() const; + interval_bounds bounds() const; + + // public static functions + static continuous_interval open(const DomainT &, const DomainT &); + static continuous_interval right_open(const DomainT &, const DomainT &); + static continuous_interval left_open(const DomainT &, const DomainT &); + static continuous_interval closed(const DomainT &, const DomainT &); +};
continuous_interval
+ public
+ construct/copy/destructcontinuous_interval();+
Default constructor; yields an empty interval [0,0).
continuous_interval(const DomainT & val);+
Constructor for a closed singleton interval [val,val]
continuous_interval(const DomainT & low, const DomainT & up, + interval_bounds bounds = interval_bounds::right_open(), + continuous_interval * = 0);+
Interval from low to up with bounds bounds
continuous_interval public member functionsdomain_type lower() const;
domain_type upper() const;
interval_bounds bounds() const;
continuous_interval public static functionsstatic continuous_interval open(const DomainT & lo, const DomainT & up);
static continuous_interval right_open(const DomainT & lo, const DomainT & up);
static continuous_interval left_open(const DomainT & lo, const DomainT & up);
static continuous_interval closed(const DomainT & lo, const DomainT & up);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::conversion
+// In header: <boost/icl/functors.hpp> + +template<typename Combiner> +struct conversion { + // types + typedef conversion< Combiner > type; + typedef remove_const< typename remove_reference< typename Combiner::first_argument_type >::type >::type argument_type; + + // public static functions + static argument_type proversion(const argument_type &); + static argument_type inversion(const argument_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct difference_type_of<boost::gregorian::date> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct difference_type_of<boost::gregorian::date> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct difference_type_of<boost::posix_time::ptime> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct difference_type_of<boost::gregorian::date> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct difference_type_of<boost::gregorian::date> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct difference_type_of<boost::gregorian::date> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct difference_type_of<boost::gregorian::date> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct difference_type_of<boost::posix_time::ptime> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct difference_type_of<boost::posix_time::ptime> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct difference_type_of<boost::posix_time::ptime> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct difference_type_of<boost::posix_time::ptime> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct difference_type_of<boost::posix_time::ptime> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct difference_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type domain_type; + typedef difference_type_of< domain_type >::type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct difference_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type domain_type; + typedef difference_type_of< domain_type >::type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct difference_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type domain_type; + typedef difference_type_of< domain_type >::type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct difference_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type domain_type; + typedef difference_type_of< domain_type >::type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct difference_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type domain_type; + typedef difference_type_of< domain_type >::type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::difference_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct difference_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type domain_type; + typedef difference_type_of< domain_type >::type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::discrete_interval
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, + ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, DomainT)> +class discrete_interval { +public: + // types + typedef discrete_interval< DomainT, Compare > type; + typedef DomainT domain_type; + typedef bounded_value< DomainT >::type bounded_domain_type; + + // construct/copy/destruct + discrete_interval(); + discrete_interval(const DomainT &); + discrete_interval(const DomainT &, const DomainT &, + interval_bounds = interval_bounds::right_open(), + discrete_interval * = 0); + + // public member functions + domain_type lower() const; + domain_type upper() const; + interval_bounds bounds() const; + + // public static functions + static discrete_interval open(const DomainT &, const DomainT &); + static discrete_interval right_open(const DomainT &, const DomainT &); + static discrete_interval left_open(const DomainT &, const DomainT &); + static discrete_interval closed(const DomainT &, const DomainT &); +};
discrete_interval
+ public
+ construct/copy/destructdiscrete_interval();+
Default constructor; yields an empty interval [0,0).
discrete_interval(const DomainT & val);+
Constructor for a closed singleton interval [val,val]
discrete_interval(const DomainT & low, const DomainT & up, + interval_bounds bounds = interval_bounds::right_open(), + discrete_interval * = 0);+
Interval from low to up with bounds bounds
discrete_interval public member functionsdomain_type lower() const;
domain_type upper() const;
interval_bounds bounds() const;
discrete_interval public static functionsstatic discrete_interval open(const DomainT & lo, const DomainT & up);
static discrete_interval right_open(const DomainT & lo, const DomainT & up);
static discrete_interval left_open(const DomainT & lo, const DomainT & up);
static discrete_interval closed(const DomainT & lo, const DomainT & up);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::domain_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct domain_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::domain_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct domain_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::domain_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct domain_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::domain_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct domain_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::domain_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct domain_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::domain_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct domain_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::dynamic_interval_traits
+// In header: <boost/icl/dynamic_interval_traits.hpp> + +template<typename Type> +struct dynamic_interval_traits { + // types + typedef Type::domain_type domain_type; + typedef Type::domain_compare domain_compare; + + // public static functions + static Type construct(const domain_type &, const domain_type &, + interval_bounds); + static Type construct_bounded(const bounded_value< domain_type > &, + const bounded_value< domain_type > &); +};
dynamic_interval_traits public static functionsstatic Type construct(const domain_type & lo, const domain_type & up, + interval_bounds bounds);
static Type construct_bounded(const bounded_value< domain_type > & lo, + const bounded_value< domain_type > & up);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::dynamic_interval_traits<boost::icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct dynamic_interval_traits<boost::icl::continuous_interval< DomainT, Compare >> { + // types + typedef dynamic_interval_traits type; + typedef boost::icl::continuous_interval< DomainT, Compare > interval_type; + typedef DomainT domain_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type + construct(const domain_type, const domain_type, interval_bounds); + static interval_type + construct_bounded(const bounded_value< DomainT > &, + const bounded_value< DomainT > &); +};
dynamic_interval_traits public static functionsstatic interval_type +construct(const domain_type lo, const domain_type up, interval_bounds bounds);
static interval_type +construct_bounded(const bounded_value< DomainT > & lo, + const bounded_value< DomainT > & up);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::dynamic_interval_traits<boost::icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct dynamic_interval_traits<boost::icl::discrete_interval< DomainT, Compare >> { + // types + typedef dynamic_interval_traits type; + typedef boost::icl::discrete_interval< DomainT, Compare > interval_type; + typedef DomainT domain_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type + construct(const domain_type &, const domain_type &, interval_bounds); + static interval_type + construct_bounded(const bounded_value< DomainT > &, + const bounded_value< DomainT > &); +};
dynamic_interval_traits public static functionsstatic interval_type +construct(const domain_type & lo, const domain_type & up, + interval_bounds bounds);
static interval_type +construct_bounded(const bounded_value< DomainT > & lo, + const bounded_value< DomainT > & up);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::dynamic_interval_traits<boost::icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct dynamic_interval_traits<boost::icl::continuous_interval< DomainT, Compare >> { + // types + typedef dynamic_interval_traits type; + typedef boost::icl::continuous_interval< DomainT, Compare > interval_type; + typedef DomainT domain_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type + construct(const domain_type, const domain_type, interval_bounds); + static interval_type + construct_bounded(const bounded_value< DomainT > &, + const bounded_value< DomainT > &); +};
dynamic_interval_traits public static functionsstatic interval_type +construct(const domain_type lo, const domain_type up, interval_bounds bounds);
static interval_type +construct_bounded(const bounded_value< DomainT > & lo, + const bounded_value< DomainT > & up);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::dynamic_interval_traits<boost::icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct dynamic_interval_traits<boost::icl::discrete_interval< DomainT, Compare >> { + // types + typedef dynamic_interval_traits type; + typedef boost::icl::discrete_interval< DomainT, Compare > interval_type; + typedef DomainT domain_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type + construct(const domain_type &, const domain_type &, interval_bounds); + static interval_type + construct_bounded(const bounded_value< DomainT > &, + const bounded_value< DomainT > &); +};
dynamic_interval_traits public static functionsstatic interval_type +construct(const domain_type & lo, const domain_type & up, + interval_bounds bounds);
static interval_type +construct_bounded(const bounded_value< DomainT > & lo, + const bounded_value< DomainT > & up);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::dynamic_interval_traits<boost::icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct dynamic_interval_traits<boost::icl::continuous_interval< DomainT, Compare >> { + // types + typedef dynamic_interval_traits type; + typedef boost::icl::continuous_interval< DomainT, Compare > interval_type; + typedef DomainT domain_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type + construct(const domain_type, const domain_type, interval_bounds); + static interval_type + construct_bounded(const bounded_value< DomainT > &, + const bounded_value< DomainT > &); +};
dynamic_interval_traits public static functionsstatic interval_type +construct(const domain_type lo, const domain_type up, interval_bounds bounds);
static interval_type +construct_bounded(const bounded_value< DomainT > & lo, + const bounded_value< DomainT > & up);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::dynamic_interval_traits<boost::icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct dynamic_interval_traits<boost::icl::discrete_interval< DomainT, Compare >> { + // types + typedef dynamic_interval_traits type; + typedef boost::icl::discrete_interval< DomainT, Compare > interval_type; + typedef DomainT domain_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type + construct(const domain_type &, const domain_type &, interval_bounds); + static interval_type + construct_bounded(const bounded_value< DomainT > &, + const bounded_value< DomainT > &); +};
dynamic_interval_traits public static functionsstatic interval_type +construct(const domain_type & lo, const domain_type & up, + interval_bounds bounds);
static interval_type +construct_bounded(const bounded_value< DomainT > & lo, + const bounded_value< DomainT > & up);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::dynamic_interval_traits<boost::icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct dynamic_interval_traits<boost::icl::continuous_interval< DomainT, Compare >> { + // types + typedef dynamic_interval_traits type; + typedef boost::icl::continuous_interval< DomainT, Compare > interval_type; + typedef DomainT domain_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type + construct(const domain_type, const domain_type, interval_bounds); + static interval_type + construct_bounded(const bounded_value< DomainT > &, + const bounded_value< DomainT > &); +};
dynamic_interval_traits public static functionsstatic interval_type +construct(const domain_type lo, const domain_type up, interval_bounds bounds);
static interval_type +construct_bounded(const bounded_value< DomainT > & lo, + const bounded_value< DomainT > & up);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::dynamic_interval_traits<boost::icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct dynamic_interval_traits<boost::icl::continuous_interval< DomainT, Compare >> { + // types + typedef dynamic_interval_traits type; + typedef boost::icl::continuous_interval< DomainT, Compare > interval_type; + typedef DomainT domain_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type + construct(const domain_type, const domain_type, interval_bounds); + static interval_type + construct_bounded(const bounded_value< DomainT > &, + const bounded_value< DomainT > &); +};
dynamic_interval_traits public static functionsstatic interval_type +construct(const domain_type lo, const domain_type up, interval_bounds bounds);
static interval_type +construct_bounded(const bounded_value< DomainT > & lo, + const bounded_value< DomainT > & up);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::dynamic_interval_traits<boost::icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct dynamic_interval_traits<boost::icl::discrete_interval< DomainT, Compare >> { + // types + typedef dynamic_interval_traits type; + typedef boost::icl::discrete_interval< DomainT, Compare > interval_type; + typedef DomainT domain_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type + construct(const domain_type &, const domain_type &, interval_bounds); + static interval_type + construct_bounded(const bounded_value< DomainT > &, + const bounded_value< DomainT > &); +};
dynamic_interval_traits public static functionsstatic interval_type +construct(const domain_type & lo, const domain_type & up, + interval_bounds bounds);
static interval_type +construct_bounded(const bounded_value< DomainT > & lo, + const bounded_value< DomainT > & up);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::dynamic_interval_traits<boost::icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct dynamic_interval_traits<boost::icl::discrete_interval< DomainT, Compare >> { + // types + typedef dynamic_interval_traits type; + typedef boost::icl::discrete_interval< DomainT, Compare > interval_type; + typedef DomainT domain_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type + construct(const domain_type &, const domain_type &, interval_bounds); + static interval_type + construct_bounded(const bounded_value< DomainT > &, + const bounded_value< DomainT > &); +};
dynamic_interval_traits public static functionsstatic interval_type +construct(const domain_type & lo, const domain_type & up, + interval_bounds bounds);
static interval_type +construct_bounded(const bounded_value< DomainT > & lo, + const bounded_value< DomainT > & up);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::dynamic_interval_traits<boost::icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct dynamic_interval_traits<boost::icl::continuous_interval< DomainT, Compare >> { + // types + typedef dynamic_interval_traits type; + typedef boost::icl::continuous_interval< DomainT, Compare > interval_type; + typedef DomainT domain_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type + construct(const domain_type, const domain_type, interval_bounds); + static interval_type + construct_bounded(const bounded_value< DomainT > &, + const bounded_value< DomainT > &); +};
dynamic_interval_traits public static functionsstatic interval_type +construct(const domain_type lo, const domain_type up, interval_bounds bounds);
static interval_type +construct_bounded(const bounded_value< DomainT > & lo, + const bounded_value< DomainT > & up);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::dynamic_interval_traits<boost::icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct dynamic_interval_traits<boost::icl::discrete_interval< DomainT, Compare >> { + // types + typedef dynamic_interval_traits type; + typedef boost::icl::discrete_interval< DomainT, Compare > interval_type; + typedef DomainT domain_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type + construct(const domain_type &, const domain_type &, interval_bounds); + static interval_type + construct_bounded(const bounded_value< DomainT > &, + const bounded_value< DomainT > &); +};
dynamic_interval_traits public static functionsstatic interval_type +construct(const domain_type & lo, const domain_type & up, + interval_bounds bounds);
static interval_type +construct_bounded(const bounded_value< DomainT > & lo, + const bounded_value< DomainT > & up);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct has_difference<boost::gregorian::date> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct has_difference<boost::gregorian::date_duration> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct has_difference<boost::gregorian::date> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct has_difference<boost::gregorian::date_duration> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct has_difference<boost::gregorian::date> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct has_difference<boost::gregorian::date_duration> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct has_difference<boost::gregorian::date> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct has_difference<boost::gregorian::date_duration> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct has_difference<boost::gregorian::date> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct has_difference<boost::gregorian::date_duration> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct has_difference<boost::gregorian::date> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct has_difference<boost::gregorian::date_duration> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct has_difference<boost::posix_time::ptime> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct has_difference<boost::posix_time::time_duration> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct has_difference<boost::posix_time::ptime> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct has_difference<boost::posix_time::time_duration> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct has_difference<boost::posix_time::ptime> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct has_difference<boost::posix_time::time_duration> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct has_difference<boost::posix_time::ptime> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct has_difference<boost::posix_time::time_duration> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct has_difference<boost::posix_time::ptime> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct has_difference<boost::posix_time::time_duration> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct has_difference<boost::posix_time::ptime> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_difference<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct has_difference<boost::posix_time::time_duration> { + // types + typedef has_difference type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct has_inverse<boost::rational< Integral >> { + // types + typedef has_inverse type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (is_signed< Integral >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct has_inverse<boost::rational< Integral >> { + // types + typedef has_inverse type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (is_signed< Integral >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct has_inverse<boost::rational< Integral >> { + // types + typedef has_inverse type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (is_signed< Integral >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct has_inverse<boost::rational< Integral >> { + // types + typedef has_inverse type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (is_signed< Integral >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct has_inverse<boost::rational< Integral >> { + // types + typedef has_inverse type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (is_signed< Integral >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct has_inverse<boost::rational< Integral >> { + // types + typedef has_inverse type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (is_signed< Integral >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct has_inverse<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct has_inverse<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct has_inverse<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct has_inverse<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct has_inverse<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct has_inverse<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct has_inverse<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct has_inverse<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct has_inverse<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct has_inverse<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct has_inverse<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct has_inverse<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct has_inverse<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef has_inverse< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct has_inverse<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef has_inverse< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct has_inverse<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef has_inverse< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct has_inverse<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef has_inverse< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct has_inverse<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef has_inverse< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct has_inverse<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef has_inverse< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct has_inverse<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct has_inverse<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct has_inverse<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct has_inverse<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct has_inverse<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::has_inverse<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct has_inverse<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef has_inverse< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (has_inverse< CodomainT >::value)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::identity_based_inplace_combine
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct identity_based_inplace_combine { + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::identity_based_inplace_combine
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct identity_based_inplace_combine { + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::identity_based_inplace_combine
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct identity_based_inplace_combine { + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::identity_based_inplace_combine
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct identity_based_inplace_combine { + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::identity_based_inplace_combine
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct identity_based_inplace_combine { + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::identity_based_inplace_combine
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct identity_based_inplace_combine { + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::identity_element<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct identity_element<boost::gregorian::date_duration> { + + // public static functions + static boost::gregorian::date_duration value(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::identity_element<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct identity_element<boost::gregorian::date_duration> { + + // public static functions + static boost::gregorian::date_duration value(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::identity_element<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct identity_element<boost::gregorian::date_duration> { + + // public static functions + static boost::gregorian::date_duration value(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::identity_element<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct identity_element<boost::gregorian::date_duration> { + + // public static functions + static boost::gregorian::date_duration value(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::identity_element<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct identity_element<boost::gregorian::date_duration> { + + // public static functions + static boost::gregorian::date_duration value(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::identity_element<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct identity_element<boost::gregorian::date_duration> { + + // public static functions + static boost::gregorian::date_duration value(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inplace_bit_add
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inplace_bit_add : + public boost::icl::identity_based_inplace_combine< Type > +{ + // types + typedef inplace_bit_add< Type > type; + + // public member functions + void operator()(Type &, const Type &) const; + + // public static functions + static void version(Type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inplace_bit_and
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inplace_bit_and : + public boost::icl::identity_based_inplace_combine< Type > +{ + // types + typedef inplace_bit_and< Type > type; + + // public member functions + void operator()(Type &, const Type &) const; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inplace_bit_subtract
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inplace_bit_subtract : + public boost::icl::identity_based_inplace_combine< Type > +{ + // types + typedef inplace_bit_subtract< Type > type; + + // public member functions + void operator()(Type &, const Type &) const; + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inplace_bit_xor
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inplace_bit_xor : + public boost::icl::identity_based_inplace_combine< Type > +{ + // types + typedef inplace_bit_xor< Type > type; + + // public member functions + void operator()(Type &, const Type &) const; + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inplace_caret
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inplace_caret : + public boost::icl::identity_based_inplace_combine< Type > +{ + // types + typedef inplace_caret< Type > type; + + // public member functions + void operator()(Type &, const Type &) const; + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inplace_erase
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inplace_erase : + public boost::icl::identity_based_inplace_combine< Type > +{ + // types + typedef inplace_erase< Type > type; + + // public member functions + void operator()(Type &, const Type &) const; + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inplace_erasure
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inplace_erasure : + public boost::icl::identity_based_inplace_combine< Type > +{ + // types + typedef inplace_erasure< Type > type; + + // public member functions + void operator()(Type &, const Type &) const; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inplace_et
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inplace_et : public boost::icl::identity_based_inplace_combine< Type > { + // types + typedef inplace_et< Type > type; + + // public member functions + void operator()(Type &, const Type &) const; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inplace_identity
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inplace_identity : + public boost::icl::identity_based_inplace_combine< Type > +{ + // types + typedef inplace_identity< Type > type; + + // public member functions + void operator()(Type &, const Type &) const; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inplace_insert
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inplace_insert : + public boost::icl::identity_based_inplace_combine< Type > +{ + // types + typedef inplace_insert< Type > type; + + // public member functions + void operator()(Type &, const Type &) const; + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inplace_max
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inplace_max : + public boost::icl::identity_based_inplace_combine< Type > +{ + // types + typedef inplace_max< Type > type; + + // public member functions + void operator()(Type &, const Type &) const; + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inplace_min
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inplace_min : + public boost::icl::identity_based_inplace_combine< Type > +{ + // types + typedef inplace_min< Type > type; + + // public member functions + void operator()(Type &, const Type &) const; + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inplace_minus
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inplace_minus : + public boost::icl::identity_based_inplace_combine< Type > +{ + // types + typedef inplace_minus< Type > type; + + // public member functions + void operator()(Type &, const Type &) const; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inplace_plus
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inplace_plus : + public boost::icl::identity_based_inplace_combine< Type > +{ + // types + typedef inplace_plus< Type > type; + + // public member functions + void operator()(Type &, const Type &) const; + + // public static functions + static void version(Type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inplace_slash
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inplace_slash : + public boost::icl::identity_based_inplace_combine< Type > +{ + // types + typedef inplace_slash< Type > type; + + // public member functions + void operator()(Type &, const Type &) const; + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inplace_star
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inplace_star : + public boost::icl::identity_based_inplace_combine< Type > +{ + // types + typedef inplace_star< Type > type; + + // public member functions + void operator()(Type &, const Type &) const; + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::insert_iterator — Performes an insertion using a container's memberfunction add, when operator= is called.
+// In header: <boost/icl/iterator.hpp> + +template<typename ContainerT> +class insert_iterator { +public: + // types + typedef ContainerT container_type; // The container's type. + typedef std::output_iterator_tag iterator_category; + + // construct/copy/destruct + insert_iterator(ContainerT &, typename ContainerT::iterator); + insert_iterator& operator=(typename ContainerT::const_reference); + + // public member functions + insert_iterator & operator*(); + insert_iterator & operator++(); + insert_iterator & operator++(int); +};
insert_iterator
+ public
+ construct/copy/destructinsert_iterator(ContainerT & cont, typename ContainerT::iterator iter);+
An insert_iterator is constructed with a container and a position that has to be maintained.
+insert_iterator& operator=(typename ContainerT::const_reference value);+
This assignment operator adds the value before the current position. It maintains it's position by incrementing after addition.
insert_iterator public member functionsinsert_iterator & operator*();
insert_iterator & operator++();
insert_iterator & operator++(int);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inserter
+// In header: <boost/icl/iterator.hpp> + + +template<typename ContainerT, typename IteratorT> + insert_iterator< ContainerT > inserter(ContainerT & cont, IteratorT iter_);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inter_section
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inter_section : + public boost::icl::identity_based_inplace_combine< Type > +{ + // types + typedef boost::mpl::if_< has_set_semantics< Type >, icl::inplace_et< Type >, icl::inplace_plus< Type > >::type type; + + // public member functions + void operator()(Type &, const Type &) const; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval
+// In header: <boost/icl/interval.hpp> + +template<typename DomainT, + ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, DomainT)> +struct interval { + // types + typedef interval_type_default< DomainT, Compare >::type interval_type; + typedef interval_type type; + + // public static functions + static interval_type right_open(const DomainT &, const DomainT &); + static interval_type left_open(const DomainT &, const DomainT &); + static interval_type open(const DomainT &, const DomainT &); + static interval_type closed(const DomainT &, const DomainT &); + static interval_type construct(const DomainT &, const DomainT &); +};
interval public static functionsstatic interval_type right_open(const DomainT & low, const DomainT & up);
static interval_type left_open(const DomainT & low, const DomainT & up);
static interval_type open(const DomainT & low, const DomainT & up);
static interval_type closed(const DomainT & low, const DomainT & up);
static interval_type construct(const DomainT & low, const DomainT & up);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map — Implements a map as a map of intervals (base class).
+// In header: <boost/icl/interval_base_map.hpp>
+
+template<typename SubType, typename DomainT, typename CodomainT,
+ typename Traits = icl::partial_absorber,
+ ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, DomainT),
+ ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT),
+ ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT),
+ ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare),
+ ICL_ALLOC Alloc = std::allocator>
+class interval_base_map {
+public:
+ // types
+ typedef interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > type;
+ typedef SubType sub_type; // The designated derived or sub_type of this base class.
+ typedef type overloadable_type; // Auxilliary type for overloadresolution.
+ typedef Traits traits; // Traits of an itl map.
+ typedef icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > atomized_type; // The atomized type representing the corresponding container of elements.
+ typedef DomainT domain_type; // Domain type (type of the keys) of the map.
+ typedef boost::call_traits< DomainT >::param_type domain_param;
+ typedef CodomainT codomain_type; // Domain type (type of the keys) of the map.
+ typedef mapping_pair< domain_type, codomain_type > domain_mapping_type; // Auxiliary type to help the compiler resolve ambiguities when using std::make_pair.
+ typedef domain_mapping_type element_type; // Conceptual is a map a set of elements of type element_type.
+ typedef std::pair< interval_type, CodomainT > interval_mapping_type; // Auxiliary type for overload resolution.
+ typedef std::pair< interval_type, CodomainT > segment_type; // Type of an interval containers segment, that is spanned by an interval.
+ typedef difference_type_of< domain_type >::type difference_type; // The difference type of an interval which is sometimes different form the domain_type.
+ typedef size_type_of< domain_type >::type size_type; // The size type of an interval which is mostly std::size_t.
+ typedef inverse< codomain_combine >::type inverse_codomain_combine; // Inverse Combine functor for codomain value aggregation.
+ typedef mpl::if_< has_set_semantics< codomain_type >, ICL_SECTION_CODOMAIN(Section, CodomainT), codomain_combine >::type codomain_intersect; // Intersection functor for codomain values.
+ typedef inverse< codomain_intersect >::type inverse_codomain_intersect; // Inverse Combine functor for codomain value intersection.
+ typedef exclusive_less_than< interval_type > interval_compare; // Comparison functor for intervals which are keys as well.
+ typedef exclusive_less_than< interval_type > key_compare; // Comparison functor for keys.
+ typedef Alloc< std::pair< const interval_type, codomain_type > > allocator_type; // The allocator type of the set.
+ typedef ICL_IMPL_SPACE::map< interval_type, codomain_type, key_compare, allocator_type > ImplMapT; // Container type for the implementation.
+ typedef ImplMapT::key_type key_type; // key type of the implementing container
+ typedef ImplMapT::value_type value_type; // value type of the implementing container
+ typedef ImplMapT::value_type::second_type data_type; // data type of the implementing container
+ typedef ImplMapT::pointer pointer; // pointer type
+ typedef ImplMapT::const_pointer const_pointer; // const pointer type
+ typedef ImplMapT::reference reference; // reference type
+ typedef ImplMapT::const_reference const_reference; // const reference type
+ typedef ImplMapT::iterator iterator; // iterator for iteration over intervals
+ typedef ImplMapT::const_iterator const_iterator; // const_iterator for iteration over intervals
+ typedef ImplMapT::reverse_iterator reverse_iterator; // iterator for reverse iteration over intervals
+ typedef ImplMapT::const_reverse_iterator const_reverse_iterator; // const_iterator for iteration over intervals
+ typedef boost::icl::element_iterator< iterator > element_iterator; // element iterator: Depreciated, see documentation.
+ typedef boost::icl::element_iterator< const_iterator > element_const_iterator; // const element iterator: Depreciated, see documentation.
+ typedef boost::icl::element_iterator< reverse_iterator > element_reverse_iterator; // element reverse iterator: Depreciated, see documentation.
+ typedef boost::icl::element_iterator< const_reverse_iterator > element_const_reverse_iterator; // element const reverse iterator: Depreciated, see documentation.
+ typedef on_absorbtion< type, codomain_combine, Traits::absorbs_identities >::type on_codomain_absorbtion;
+
+ // member classes/structs/unions
+ template<typename Type>
+ struct on_codomain_model<Type, false> {
+ // types
+ typedef Type::interval_type interval_type;
+ typedef Type::codomain_type codomain_type;
+ typedef Type::segment_type segment_type;
+ typedef Type::codomain_combine codomain_combine;
+
+ // public static functions
+ static void add(Type &, interval_type &, const codomain_type &,
+ const codomain_type &);
+ };
+ template<typename Type>
+ struct on_codomain_model<Type, true> {
+ // types
+ typedef Type::interval_type interval_type;
+ typedef Type::codomain_type codomain_type;
+ typedef Type::segment_type segment_type;
+ typedef Type::codomain_combine codomain_combine;
+ typedef Type::inverse_codomain_intersect inverse_codomain_intersect;
+
+ // public static functions
+ static void add(Type &, interval_type &, const codomain_type &,
+ const codomain_type &);
+ };
+ template<typename Type>
+ struct on_definedness<Type, false> {
+
+ // public static functions
+ static void add_intersection(Type &, const Type &, const segment_type &);
+ };
+ template<typename Type>
+ struct on_definedness<Type, true> {
+
+ // public static functions
+ static void add_intersection(Type &, const Type &, const segment_type &);
+ };
+ template<typename Type>
+ struct on_invertible<Type, false> {
+ // types
+ typedef Type::segment_type segment_type;
+ typedef Type::inverse_codomain_combine inverse_codomain_combine;
+
+ // public static functions
+ static void subtract(Type &, const segment_type &);
+ };
+ template<typename Type>
+ struct on_invertible<Type, true> {
+ // types
+ typedef Type::segment_type segment_type;
+ typedef Type::inverse_codomain_combine inverse_codomain_combine;
+
+ // public static functions
+ static void subtract(Type &, const segment_type &);
+ };
+ template<typename Type, bool absorbs_identities>
+ struct on_total_absorbable<Type, false, absorbs_identities> {
+ // types
+ typedef Type::segment_type segment_type;
+ typedef Type::codomain_type codomain_type;
+ typedef Type::interval_type interval_type;
+ typedef Type::value_type value_type;
+ typedef Type::const_iterator const_iterator;
+ typedef Type::set_type set_type;
+ typedef Type::inverse_codomain_intersect inverse_codomain_intersect;
+
+ // public static functions
+ static void flip(Type &, const segment_type &);
+ };
+ template<typename Type>
+ struct on_total_absorbable<Type, true, false> {
+ // types
+ typedef Type::segment_type segment_type;
+ typedef Type::codomain_type codomain_type;
+
+ // public static functions
+ static void flip(Type &, const segment_type &);
+ };
+ template<typename Type>
+ struct on_total_absorbable<Type, true, true> {
+
+ // public static functions
+ static void flip(Type &, const typename Type::segment_type &);
+ };
+
+ // construct/copy/destruct
+ interval_base_map();
+ interval_base_map(const interval_base_map &);
+ interval_base_map& operator=(const interval_base_map &);
+
+ // public member functions
+ typedef ICL_INTERVAL_TYPE(Interval, DomainT, Compare);
+ typedef ICL_COMPARE_DOMAIN(Compare, DomainT);
+ typedef ICL_COMPARE_DOMAIN(Compare, segment_type);
+ typedef ICL_COMBINE_CODOMAIN(Combine, CodomainT);
+ BOOST_STATIC_CONSTANT(bool,
+ is_total_invertible = (Traits::is_total &&has_inverse< codomain_type >::value));
+ BOOST_STATIC_CONSTANT(int, fineness = 0);
+ void swap(interval_base_map &);
+ void clear();
+ bool empty() const;
+ size_type size() const;
+ std::size_t iterative_size() const;
+ const_iterator find(const domain_type &) const;
+ const_iterator find(const interval_type &) const;
+ codomain_type operator()(const domain_type &) const;
+ SubType & add(const element_type &);
+ SubType & add(const segment_type &);
+ iterator add(iterator, const segment_type &);
+ SubType & subtract(const element_type &);
+ SubType & subtract(const segment_type &);
+ SubType & insert(const element_type &);
+ SubType & insert(const segment_type &);
+ iterator insert(iterator, const segment_type &);
+ SubType & set(const element_type &);
+ SubType & set(const segment_type &);
+ SubType & erase(const element_type &);
+ SubType & erase(const segment_type &);
+ SubType & erase(const domain_type &);
+ SubType & erase(const interval_type &);
+ void erase(iterator);
+ void erase(iterator, iterator);
+ void add_intersection(SubType &, const segment_type &) const;
+ SubType & flip(const element_type &);
+ SubType & flip(const segment_type &);
+ iterator lower_bound(const key_type &);
+ iterator upper_bound(const key_type &);
+ const_iterator lower_bound(const key_type &) const;
+ const_iterator upper_bound(const key_type &) const;
+ std::pair< iterator, iterator > equal_range(const key_type &);
+ std::pair< const_iterator, const_iterator >
+ equal_range(const key_type &) const;
+ iterator begin();
+ iterator end();
+ const_iterator begin() const;
+ const_iterator end() const;
+ reverse_iterator rbegin();
+ reverse_iterator rend();
+ const_reverse_iterator rbegin() const;
+ const_reverse_iterator rend() const;
+
+ // private member functions
+ template<typename Combiner> iterator _add(const segment_type &);
+ template<typename Combiner> iterator _add(iterator, const segment_type &);
+ template<typename Combiner> void _subtract(const segment_type &);
+ iterator _insert(const segment_type &);
+ iterator _insert(iterator, const segment_type &);
+ template<typename Combiner>
+ void add_segment(const interval_type &, const CodomainT &, iterator &);
+ template<typename Combiner>
+ void add_main(interval_type &, const CodomainT &, iterator &,
+ const iterator &);
+ template<typename Combiner>
+ void add_rear(const interval_type &, const CodomainT &, iterator &);
+ void add_front(const interval_type &, iterator &);
+ void subtract_front(const interval_type &, iterator &);
+ template<typename Combiner>
+ void subtract_main(const CodomainT &, iterator &, const iterator &);
+ template<typename Combiner>
+ void subtract_rear(interval_type &, const CodomainT &, iterator &);
+ void insert_main(const interval_type &, const CodomainT &, iterator &,
+ const iterator &);
+ void erase_rest(interval_type &, const CodomainT &, iterator &,
+ const iterator &);
+ template<typename FragmentT>
+ void total_add_intersection(SubType &, const FragmentT &) const;
+ void partial_add_intersection(SubType &, const segment_type &) const;
+ void partial_add_intersection(SubType &, const element_type &) const;
+
+ // protected member functions
+ template<typename Combiner>
+ iterator gap_insert(iterator, const interval_type &,
+ const codomain_type &);
+ template<typename Combiner>
+ std::pair< iterator, bool >
+ add_at(const iterator &, const interval_type &, const codomain_type &);
+ std::pair< iterator, bool >
+ insert_at(const iterator &, const interval_type &, const codomain_type &);
+ sub_type * that();
+ const sub_type * that() const;
+};interval_base_map
+ public
+ construct/copy/destructinterval_base_map();+
Default constructor for the empty object
+interval_base_map(const interval_base_map & src);+
Copy constructor
+interval_base_map& operator=(const interval_base_map & src);+
Assignment operator
+interval_base_map public member functionstypedef ICL_INTERVAL_TYPE(Interval, DomainT, Compare);The interval type of the map.
typedef ICL_COMPARE_DOMAIN(Compare, DomainT);Comparison functor for domain values.
typedef ICL_COMPARE_DOMAIN(Compare, segment_type);
typedef ICL_COMBINE_CODOMAIN(Combine, CodomainT);Combine functor for codomain value aggregation.
BOOST_STATIC_CONSTANT(bool, + is_total_invertible = (Traits::is_total &&has_inverse< codomain_type >::value));
BOOST_STATIC_CONSTANT(int, fineness = 0);
void swap(interval_base_map & object);+
swap the content of containers
+void clear();+
clear the map
+bool empty() const;+
is the map empty?
+size_type size() const;+
An interval map's size is it's cardinality
+std::size_t iterative_size() const;+
Size of the iteration over this container
+const_iterator find(const domain_type & key) const;+
Find the interval value pair, that contains key
const_iterator find(const interval_type & key) const;
codomain_type operator()(const domain_type & key) const;+
Total select function.
+SubType & add(const element_type & key_value_pair);+
Addition of a key value pair to the map
+SubType & add(const segment_type & interval_value_pair);+
Addition of an interval value pair to the map.
+iterator add(iterator prior_, const segment_type & interval_value_pair);+
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 & subtract(const element_type & key_value_pair);+
Subtraction of a key value pair from the map
+SubType & subtract(const segment_type & interval_value_pair);+
Subtraction of an interval value pair from the map.
+SubType & insert(const element_type & key_value_pair);+
Insertion of a key_value_pair into the map.
SubType & insert(const segment_type & interval_value_pair);+
Insertion of an interval_value_pair into the map.
iterator insert(iterator prior, const segment_type & interval_value_pair);+
Insertion of an interval_value_pair into the map. Iterator prior_. serves as a hint to insert after the element prior point to.
SubType & set(const element_type & key_value_pair);+
With key_value_pair = (k,v) set value v for key k
SubType & set(const segment_type & interval_value_pair);+
With interval_value_pair = (I,v) set value v for all keys in interval I in the map.
SubType & erase(const element_type & key_value_pair);+
Erase a key_value_pair from the map.
SubType & erase(const segment_type & interval_value_pair);+
Erase an interval_value_pair from the map.
SubType & erase(const domain_type & key);+
Erase a key value pair for key.
SubType & erase(const interval_type & inter_val);+
Erase all value pairs within the range of the interval inter_val from the map.
void erase(iterator position);+
Erase all value pairs within the range of the interval that iterator position points to.
void erase(iterator first, iterator past);+
Erase all value pairs for a range of iterators [first,past).
void add_intersection(SubType & section, + const segment_type & interval_value_pair) const;+
The intersection of interval_value_pair and *this map is added to section.
SubType & flip(const element_type & key_value_pair);+
If *this map contains key_value_pair it is erased, otherwise it is added.
SubType & flip(const segment_type & interval_value_pair);+
If *this map contains interval_value_pair it is erased, otherwise it is added.
iterator lower_bound(const key_type & interval);
iterator upper_bound(const key_type & interval);
const_iterator lower_bound(const key_type & interval) const;
const_iterator upper_bound(const key_type & interval) const;
std::pair< iterator, iterator > equal_range(const key_type & interval);
std::pair< const_iterator, const_iterator > +equal_range(const key_type & interval) const;
iterator begin();
iterator end();
const_iterator begin() const;
const_iterator end() const;
reverse_iterator rbegin();
reverse_iterator rend();
const_reverse_iterator rbegin() const;
const_reverse_iterator rend() const;
interval_base_map private member functionstemplate<typename Combiner> + iterator _add(const segment_type & interval_value_pair);
template<typename Combiner> + iterator _add(iterator prior_, const segment_type & interval_value_pair);
template<typename Combiner> + void _subtract(const segment_type & interval_value_pair);
iterator _insert(const segment_type & interval_value_pair);
iterator _insert(iterator prior_, const segment_type & interval_value_pair);
template<typename Combiner> + void add_segment(const interval_type & inter_val, const CodomainT & co_val, + iterator & it_);
template<typename Combiner> + void add_main(interval_type & inter_val, const CodomainT & co_val, + iterator & it_, const iterator & last_);
template<typename Combiner> + void add_rear(const interval_type & inter_val, const CodomainT & co_val, + iterator & it_);
void add_front(const interval_type & inter_val, iterator & first_);
void subtract_front(const interval_type & inter_val, iterator & first_);
template<typename Combiner> + void subtract_main(const CodomainT & co_val, iterator & it_, + const iterator & last_);
template<typename Combiner> + void subtract_rear(interval_type & inter_val, const CodomainT & co_val, + iterator & it_);
void insert_main(const interval_type &, const CodomainT &, iterator &, + const iterator &);
void erase_rest(interval_type &, const CodomainT &, iterator &, + const iterator &);
template<typename FragmentT> + void total_add_intersection(SubType & section, const FragmentT & fragment) const;
void partial_add_intersection(SubType & section, const segment_type & operand) const;
void partial_add_intersection(SubType & section, const element_type & operand) const;
interval_base_map protected member functionstemplate<typename Combiner> + iterator gap_insert(iterator prior_, const interval_type & inter_val, + const codomain_type & co_val);
template<typename Combiner> + std::pair< iterator, bool > + add_at(const iterator & prior_, const interval_type & inter_val, + const codomain_type & co_val);
std::pair< iterator, bool > +insert_at(const iterator & prior_, const interval_type & inter_val, + const codomain_type & co_val);
sub_type * that();
const sub_type * that() const;
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_codomain_model<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false> { + // types + typedef Type::interval_type interval_type; + typedef Type::codomain_type codomain_type; + typedef Type::segment_type segment_type; + typedef Type::codomain_combine codomain_combine; + + // public static functions + static void add(Type &, interval_type &, const codomain_type &, + const codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_codomain_model<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true> { + // types + typedef Type::interval_type interval_type; + typedef Type::codomain_type codomain_type; + typedef Type::segment_type segment_type; + typedef Type::codomain_combine codomain_combine; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void add(Type &, interval_type &, const codomain_type &, + const codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_codomain_model<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false> { + // types + typedef Type::interval_type interval_type; + typedef Type::codomain_type codomain_type; + typedef Type::segment_type segment_type; + typedef Type::codomain_combine codomain_combine; + + // public static functions + static void add(Type &, interval_type &, const codomain_type &, + const codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_codomain_model<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true> { + // types + typedef Type::interval_type interval_type; + typedef Type::codomain_type codomain_type; + typedef Type::segment_type segment_type; + typedef Type::codomain_combine codomain_combine; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void add(Type &, interval_type &, const codomain_type &, + const codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_codomain_model<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false> { + // types + typedef Type::interval_type interval_type; + typedef Type::codomain_type codomain_type; + typedef Type::segment_type segment_type; + typedef Type::codomain_combine codomain_combine; + + // public static functions + static void add(Type &, interval_type &, const codomain_type &, + const codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_codomain_model<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true> { + // types + typedef Type::interval_type interval_type; + typedef Type::codomain_type codomain_type; + typedef Type::segment_type segment_type; + typedef Type::codomain_combine codomain_combine; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void add(Type &, interval_type &, const codomain_type &, + const codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_codomain_model<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false> { + // types + typedef Type::interval_type interval_type; + typedef Type::codomain_type codomain_type; + typedef Type::segment_type segment_type; + typedef Type::codomain_combine codomain_combine; + + // public static functions + static void add(Type &, interval_type &, const codomain_type &, + const codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_codomain_model<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true> { + // types + typedef Type::interval_type interval_type; + typedef Type::codomain_type codomain_type; + typedef Type::segment_type segment_type; + typedef Type::codomain_combine codomain_combine; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void add(Type &, interval_type &, const codomain_type &, + const codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_codomain_model<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false> { + // types + typedef Type::interval_type interval_type; + typedef Type::codomain_type codomain_type; + typedef Type::segment_type segment_type; + typedef Type::codomain_combine codomain_combine; + + // public static functions + static void add(Type &, interval_type &, const codomain_type &, + const codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_codomain_model<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true> { + // types + typedef Type::interval_type interval_type; + typedef Type::codomain_type codomain_type; + typedef Type::segment_type segment_type; + typedef Type::codomain_combine codomain_combine; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void add(Type &, interval_type &, const codomain_type &, + const codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_codomain_model<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false> { + // types + typedef Type::interval_type interval_type; + typedef Type::codomain_type codomain_type; + typedef Type::segment_type segment_type; + typedef Type::codomain_combine codomain_combine; + + // public static functions + static void add(Type &, interval_type &, const codomain_type &, + const codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_codomain_model<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true> { + // types + typedef Type::interval_type interval_type; + typedef Type::codomain_type codomain_type; + typedef Type::segment_type segment_type; + typedef Type::codomain_combine codomain_combine; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void add(Type &, interval_type &, const codomain_type &, + const codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_definedness<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_definedness<Type, false> { + + // public static functions + static void add_intersection(Type &, const Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_definedness<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_definedness<Type, false> { + + // public static functions + static void add_intersection(Type &, const Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_definedness<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_definedness<Type, false> { + + // public static functions + static void add_intersection(Type &, const Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_definedness<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_definedness<Type, false> { + + // public static functions + static void add_intersection(Type &, const Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_definedness<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_definedness<Type, false> { + + // public static functions + static void add_intersection(Type &, const Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_definedness<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_definedness<Type, false> { + + // public static functions + static void add_intersection(Type &, const Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_definedness<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_definedness<Type, true> { + + // public static functions + static void add_intersection(Type &, const Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_definedness<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_definedness<Type, true> { + + // public static functions + static void add_intersection(Type &, const Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_definedness<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_definedness<Type, true> { + + // public static functions + static void add_intersection(Type &, const Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_definedness<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_definedness<Type, true> { + + // public static functions + static void add_intersection(Type &, const Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_definedness<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_definedness<Type, true> { + + // public static functions + static void add_intersection(Type &, const Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_definedness<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_definedness<Type, true> { + + // public static functions + static void add_intersection(Type &, const Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_invertible<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_invertible<Type, false> { + // types + typedef Type::segment_type segment_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_invertible<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_invertible<Type, false> { + // types + typedef Type::segment_type segment_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_invertible<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_invertible<Type, false> { + // types + typedef Type::segment_type segment_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_invertible<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_invertible<Type, false> { + // types + typedef Type::segment_type segment_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_invertible<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_invertible<Type, false> { + // types + typedef Type::segment_type segment_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_invertible<Type, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_invertible<Type, false> { + // types + typedef Type::segment_type segment_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_invertible<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_invertible<Type, true> { + // types + typedef Type::segment_type segment_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_invertible<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_invertible<Type, true> { + // types + typedef Type::segment_type segment_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_invertible<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_invertible<Type, true> { + // types + typedef Type::segment_type segment_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_invertible<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_invertible<Type, true> { + // types + typedef Type::segment_type segment_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_invertible<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_invertible<Type, true> { + // types + typedef Type::segment_type segment_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_invertible<Type, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_invertible<Type, true> { + // types + typedef Type::segment_type segment_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, false, absorbs_identities>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type, bool absorbs_identities> +struct on_total_absorbable<Type, false, absorbs_identities> { + // types + typedef Type::segment_type segment_type; + typedef Type::codomain_type codomain_type; + typedef Type::interval_type interval_type; + typedef Type::value_type value_type; + typedef Type::const_iterator const_iterator; + typedef Type::set_type set_type; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, true, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, false> { + // types + typedef Type::segment_type segment_type; + typedef Type::codomain_type codomain_type; + + // public static functions + static void flip(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, true, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, true> { + + // public static functions + static void flip(Type &, const typename Type::segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, false, absorbs_identities>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type, bool absorbs_identities> +struct on_total_absorbable<Type, false, absorbs_identities> { + // types + typedef Type::segment_type segment_type; + typedef Type::codomain_type codomain_type; + typedef Type::interval_type interval_type; + typedef Type::value_type value_type; + typedef Type::const_iterator const_iterator; + typedef Type::set_type set_type; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, true, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, false> { + // types + typedef Type::segment_type segment_type; + typedef Type::codomain_type codomain_type; + + // public static functions + static void flip(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, true, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, true> { + + // public static functions + static void flip(Type &, const typename Type::segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, false, absorbs_identities>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type, bool absorbs_identities> +struct on_total_absorbable<Type, false, absorbs_identities> { + // types + typedef Type::segment_type segment_type; + typedef Type::codomain_type codomain_type; + typedef Type::interval_type interval_type; + typedef Type::value_type value_type; + typedef Type::const_iterator const_iterator; + typedef Type::set_type set_type; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, true, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, false> { + // types + typedef Type::segment_type segment_type; + typedef Type::codomain_type codomain_type; + + // public static functions + static void flip(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, true, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, true> { + + // public static functions + static void flip(Type &, const typename Type::segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, false, absorbs_identities>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type, bool absorbs_identities> +struct on_total_absorbable<Type, false, absorbs_identities> { + // types + typedef Type::segment_type segment_type; + typedef Type::codomain_type codomain_type; + typedef Type::interval_type interval_type; + typedef Type::value_type value_type; + typedef Type::const_iterator const_iterator; + typedef Type::set_type set_type; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, true, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, false> { + // types + typedef Type::segment_type segment_type; + typedef Type::codomain_type codomain_type; + + // public static functions + static void flip(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, true, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, true> { + + // public static functions + static void flip(Type &, const typename Type::segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, false, absorbs_identities>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type, bool absorbs_identities> +struct on_total_absorbable<Type, false, absorbs_identities> { + // types + typedef Type::segment_type segment_type; + typedef Type::codomain_type codomain_type; + typedef Type::interval_type interval_type; + typedef Type::value_type value_type; + typedef Type::const_iterator const_iterator; + typedef Type::set_type set_type; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, true, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, false> { + // types + typedef Type::segment_type segment_type; + typedef Type::codomain_type codomain_type; + + // public static functions + static void flip(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, true, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, true> { + + // public static functions + static void flip(Type &, const typename Type::segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, false, absorbs_identities>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type, bool absorbs_identities> +struct on_total_absorbable<Type, false, absorbs_identities> { + // types + typedef Type::segment_type segment_type; + typedef Type::codomain_type codomain_type; + typedef Type::interval_type interval_type; + typedef Type::value_type value_type; + typedef Type::const_iterator const_iterator; + typedef Type::set_type set_type; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, true, false>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, false> { + // types + typedef Type::segment_type segment_type; + typedef Type::codomain_type codomain_type; + + // public static functions + static void flip(Type &, const segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_map::on_total_absorbable<Type, true, true>
+// In header: <boost/icl/interval_base_map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, true> { + + // public static functions + static void flip(Type &, const typename Type::segment_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_base_set — Implements a set as a set of intervals (base class).
+// In header: <boost/icl/interval_base_set.hpp> + +template<typename SubType, typename DomainT, + ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, DomainT), + ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), + ICL_ALLOC Alloc = std::allocator> +class interval_base_set { +public: + // types + typedef interval_base_set< SubType, DomainT, Compare, Interval, Alloc > type; + typedef SubType sub_type; // The designated derived or sub_type of this base class. + typedef type overloadable_type; // Auxilliary type for overloadresolution. + typedef DomainT domain_type; // The domain type of the set. + typedef DomainT codomain_type; // The codomaintype is the same as domain_type. + typedef DomainT element_type; // The element type of the set. + typedef interval_type segment_type; // The segment type of the set. + typedef difference_type_of< domain_type >::type difference_type; // The difference type of an interval which is sometimes different form the data_type. + typedef size_type_of< domain_type >::type size_type; // The size type of an interval which is mostly std::size_t. + typedef exclusive_less_than< interval_type > interval_compare; // Comparison functor for intervals. + typedef exclusive_less_than< interval_type > key_compare; // Comparison functor for keys. + typedef ICL_IMPL_SPACE::set< DomainT, domain_compare, Alloc< DomainT > > atomized_type; // The atomized type representing the corresponding container of elements. + typedef Alloc< interval_type > allocator_type; // The allocator type of the set. + typedef Alloc< DomainT > domain_allocator_type; // allocator type of the corresponding element set + typedef ICL_IMPL_SPACE::set< interval_type, key_compare, allocator_type > ImplSetT; // Container type for the implementation. + typedef ImplSetT::key_type key_type; // key type of the implementing container + typedef ImplSetT::key_type data_type; // data type of the implementing container + typedef ImplSetT::value_type value_type; // value type of the implementing container + typedef ImplSetT::pointer pointer; // pointer type + typedef ImplSetT::const_pointer const_pointer; // const pointer type + typedef ImplSetT::reference reference; // reference type + typedef ImplSetT::const_reference const_reference; // const reference type + typedef ImplSetT::iterator iterator; // iterator for iteration over intervals + typedef ImplSetT::const_iterator const_iterator; // const_iterator for iteration over intervals + typedef ImplSetT::reverse_iterator reverse_iterator; // iterator for reverse iteration over intervals + typedef ImplSetT::const_reverse_iterator const_reverse_iterator; // const_iterator for iteration over intervals + typedef boost::icl::element_iterator< iterator > element_iterator; // element iterator: Depreciated, see documentation. + typedef boost::icl::element_iterator< const_iterator > element_const_iterator; // element const iterator: Depreciated, see documentation. + typedef boost::icl::element_iterator< reverse_iterator > element_reverse_iterator; // element reverse iterator: Depreciated, see documentation. + typedef boost::icl::element_iterator< const_reverse_iterator > element_const_reverse_iterator; // element const reverse iterator: Depreciated, see documentation. + + // construct/copy/destruct + interval_base_set(); + interval_base_set(const interval_base_set &); + interval_base_set& operator=(const interval_base_set &); + + // public member functions + typedef ICL_INTERVAL_TYPE(Interval, DomainT, Compare); + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + typedef ICL_COMPARE_DOMAIN(Compare, segment_type); + BOOST_STATIC_CONSTANT(int, fineness = 0); + void swap(interval_base_set &); + void clear(); + bool empty() const; + size_type size() const; + std::size_t iterative_size() const; + const_iterator find(const element_type &) const; + const_iterator find(const segment_type &) const; + SubType & add(const element_type &); + SubType & add(const segment_type &); + iterator add(iterator, const segment_type &); + SubType & subtract(const element_type &); + SubType & subtract(const segment_type &); + SubType & insert(const element_type &); + SubType & insert(const segment_type &); + iterator insert(iterator, const segment_type &); + SubType & erase(const element_type &); + SubType & erase(const segment_type &); + void erase(iterator); + void erase(iterator, iterator); + SubType & flip(const element_type &); + SubType & flip(const segment_type &); + iterator begin(); + iterator end(); + const_iterator begin() const; + const_iterator end() const; + reverse_iterator rbegin(); + reverse_iterator rend(); + const_reverse_iterator rbegin() const; + const_reverse_iterator rend() const; + iterator lower_bound(const value_type &); + iterator upper_bound(const value_type &); + const_iterator lower_bound(const value_type &) const; + const_iterator upper_bound(const value_type &) const; + std::pair< iterator, iterator > equal_range(const key_type &); + std::pair< const_iterator, const_iterator > + equal_range(const key_type &) const; + + // private member functions + iterator _add(const segment_type &); + iterator _add(iterator, const segment_type &); + + // protected member functions + void add_front(const interval_type &, iterator &); + void add_main(interval_type &, iterator &, const iterator &); + void add_segment(const interval_type &, iterator &); + void add_rear(const interval_type &, iterator &); + sub_type * that(); + const sub_type * that() const; +};
interval_base_set
+ public
+ construct/copy/destructinterval_base_set();+
Default constructor for the empty object
+interval_base_set(const interval_base_set & src);+
Copy constructor
+interval_base_set& operator=(const interval_base_set & src);+
Assignment operator
+interval_base_set public member functionstypedef ICL_INTERVAL_TYPE(Interval, DomainT, Compare);The interval type of the set.
typedef ICL_COMPARE_DOMAIN(Compare, DomainT);Comparison functor for domain values.
typedef ICL_COMPARE_DOMAIN(Compare, segment_type);
BOOST_STATIC_CONSTANT(int, fineness = 0);
void swap(interval_base_set & operand);+
swap the content of containers
+void clear();+
sets the container empty
+bool empty() const;+
is the container empty?
+size_type size() const;+
An interval set's size is it's cardinality
+std::size_t iterative_size() const;+
Size of the iteration over this container
+const_iterator find(const element_type & key) const;+
Find the interval value pair, that contains element key
const_iterator find(const segment_type & segment) const;
SubType & add(const element_type & key);+
Add a single element key to the set
SubType & add(const segment_type & inter_val);+
Add an interval of elements inter_val to the set
iterator add(iterator prior_, const segment_type & inter_val);+
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 & subtract(const element_type & key);+
Subtract a single element key from the set
SubType & subtract(const segment_type & inter_val);+
Subtract an interval of elements inter_val from the set
SubType & insert(const element_type & key);+
Insert an element key into the set
SubType & insert(const segment_type & inter_val);+
Insert an interval of elements inter_val to the set
iterator insert(iterator prior_, const segment_type & inter_val);+
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 & erase(const element_type & key);+
Erase an element key from the set
SubType & erase(const segment_type & inter_val);+
Erase an interval of elements inter_val from the set
void erase(iterator position);+
Erase the interval that iterator position points to.
void erase(iterator first, iterator past);+
Erase all intervals in the range [first,past) of iterators.
SubType & flip(const element_type & key);+
If *this set contains key it is erased, otherwise it is added.
SubType & flip(const segment_type & inter_val);+
If *this set contains inter_val it is erased, otherwise it is added.
iterator begin();
iterator end();
const_iterator begin() const;
const_iterator end() const;
reverse_iterator rbegin();
reverse_iterator rend();
const_reverse_iterator rbegin() const;
const_reverse_iterator rend() const;
iterator lower_bound(const value_type & interval);
iterator upper_bound(const value_type & interval);
const_iterator lower_bound(const value_type & interval) const;
const_iterator upper_bound(const value_type & interval) const;
std::pair< iterator, iterator > equal_range(const key_type & interval);
std::pair< const_iterator, const_iterator > +equal_range(const key_type & interval) const;
interval_base_set protected member functionsvoid add_front(const interval_type & inter_val, iterator & first_);
void add_main(interval_type & inter_val, iterator & it_, + const iterator & last_);
void add_segment(const interval_type & inter_val, iterator & it_);
void add_rear(const interval_type & inter_val, iterator & it_);
sub_type * that();
const sub_type * that() const;
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<closed_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::static_closed); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<closed_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::static_closed); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<closed_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::static_closed); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<closed_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::static_closed); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<closed_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::static_closed); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<closed_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::static_closed); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<continuous_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::dynamic); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<continuous_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::dynamic); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<continuous_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::dynamic); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<continuous_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::dynamic); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<continuous_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::dynamic); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<continuous_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::dynamic); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<discrete_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::dynamic); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<discrete_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::dynamic); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<discrete_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::dynamic); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<discrete_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::dynamic); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<discrete_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::dynamic); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<discrete_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::dynamic); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<left_open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, + value = interval_bounds::static_left_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<left_open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, + value = interval_bounds::static_left_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<left_open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, + value = interval_bounds::static_left_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<left_open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, + value = interval_bounds::static_left_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<left_open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, + value = interval_bounds::static_left_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<left_open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, + value = interval_bounds::static_left_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::static_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::static_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::static_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::static_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::static_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::static_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<right_open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, + value = interval_bounds::static_right_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<right_open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, + value = interval_bounds::static_right_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<right_open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, + value = interval_bounds::static_right_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<right_open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, + value = interval_bounds::static_right_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<right_open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, + value = interval_bounds::static_right_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bound_type<right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_bound_type<right_open_interval< DomainT, Compare >> { + // types + typedef interval_bound_type type; + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, + value = interval_bounds::static_right_open); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_bounds
+// In header: <boost/icl/interval_bounds.hpp> + + +class interval_bounds { +public: + // construct/copy/destruct + interval_bounds(); + interval_bounds(bound_type); + + // public member functions + BOOST_STATIC_CONSTANT(bound_type, static_open = 0); + BOOST_STATIC_CONSTANT(bound_type, static_left_open = 1); + BOOST_STATIC_CONSTANT(bound_type, static_right_open = 2); + BOOST_STATIC_CONSTANT(bound_type, static_closed = 3); + BOOST_STATIC_CONSTANT(bound_type, dynamic = 4); + BOOST_STATIC_CONSTANT(bound_type, undefined = 5); + BOOST_STATIC_CONSTANT(bound_type, _open = 0); + BOOST_STATIC_CONSTANT(bound_type, _left_open = 1); + BOOST_STATIC_CONSTANT(bound_type, _right_open = 2); + BOOST_STATIC_CONSTANT(bound_type, _closed = 3); + BOOST_STATIC_CONSTANT(bound_type, _right = 1); + BOOST_STATIC_CONSTANT(bound_type, _left = 2); + BOOST_STATIC_CONSTANT(bound_type, _all = 3); + interval_bounds all() const; + interval_bounds left() const; + interval_bounds right() const; + interval_bounds reverse_left() const; + interval_bounds reverse_right() const; + bound_type bits() const; + + // public static functions + static interval_bounds open(); + static interval_bounds left_open(); + static interval_bounds right_open(); + static interval_bounds closed(); + bound_type _bits; +};
interval_bounds public member functionsBOOST_STATIC_CONSTANT(bound_type, static_open = 0);
BOOST_STATIC_CONSTANT(bound_type, static_left_open = 1);
BOOST_STATIC_CONSTANT(bound_type, static_right_open = 2);
BOOST_STATIC_CONSTANT(bound_type, static_closed = 3);
BOOST_STATIC_CONSTANT(bound_type, dynamic = 4);
BOOST_STATIC_CONSTANT(bound_type, undefined = 5);
BOOST_STATIC_CONSTANT(bound_type, _open = 0);
BOOST_STATIC_CONSTANT(bound_type, _left_open = 1);
BOOST_STATIC_CONSTANT(bound_type, _right_open = 2);
BOOST_STATIC_CONSTANT(bound_type, _closed = 3);
BOOST_STATIC_CONSTANT(bound_type, _right = 1);
BOOST_STATIC_CONSTANT(bound_type, _left = 2);
BOOST_STATIC_CONSTANT(bound_type, _all = 3);
interval_bounds all() const;
interval_bounds left() const;
interval_bounds right() const;
interval_bounds reverse_left() const;
interval_bounds reverse_right() const;
bound_type bits() const;
interval_bounds public static functionsstatic interval_bounds open();
static interval_bounds left_open();
static interval_bounds right_open();
static interval_bounds closed();
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_map — implements a map as a map of intervals - on insertion overlapping intervals are split and associated values are combined.
+// In header: <boost/icl/interval_map.hpp>
+
+template<typename DomainT, typename CodomainT,
+ typename Traits = icl::partial_absorber,
+ ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, DomainT),
+ ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT),
+ ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT),
+ ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare),
+ ICL_ALLOC Alloc = std::allocator>
+class interval_map : public boost::icl::interval_base_map< interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >
+{
+public:
+ // types
+ typedef Traits traits; // Traits of an itl map.
+ typedef interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > type;
+ typedef split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > split_type;
+ typedef type overloadable_type; // Auxilliary type for overloadresolution.
+ typedef type joint_type;
+ typedef interval_base_map< type, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > base_type;
+ typedef base_type::iterator iterator; // iterator for iteration over intervals
+ typedef base_type::value_type value_type; // value type of the implementing container
+ typedef base_type::element_type element_type; // Conceptual is a map a set of elements of type element_type.
+ typedef base_type::segment_type segment_type; // Type of an interval containers segment, that is spanned by an interval.
+ typedef base_type::domain_type domain_type; // Domain type (type of the keys) of the map.
+ typedef base_type::codomain_type codomain_type; // Domain type (type of the keys) of the map.
+ typedef base_type::domain_mapping_type domain_mapping_type; // Auxiliary type to help the compiler resolve ambiguities when using std::make_pair.
+ typedef base_type::interval_mapping_type interval_mapping_type; // Auxiliary type for overload resolution.
+ typedef base_type::ImplMapT ImplMapT; // Container type for the implementation.
+ typedef base_type::size_type size_type; // The size type of an interval which is mostly std::size_t.
+ typedef base_type::codomain_combine codomain_combine;
+ typedef interval_set< DomainT, Compare, Interval, Alloc > interval_set_type;
+ typedef interval_set_type set_type;
+ typedef set_type key_object_type;
+
+ enum @0 { fineness = 1 };
+
+ // construct/copy/destruct
+ interval_map();
+ interval_map(const interval_map &);
+ template<typename SubType>
+ interval_map(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &);
+ interval_map(domain_mapping_type &);
+ interval_map(const value_type &);
+ template<typename SubType>
+ interval_map&
+ operator=(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &);
+
+ // public member functions
+ typedef ICL_INTERVAL_TYPE(Interval, DomainT, Compare);
+ template<typename SubType>
+ void assign(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &);
+
+ // private member functions
+ iterator handle_inserted(iterator);
+ void handle_inserted(iterator, iterator);
+ template<typename Combiner> void handle_left_combined(iterator);
+ template<typename Combiner> void handle_combined(iterator);
+ template<typename Combiner>
+ void handle_preceeded_combined(iterator, iterator &);
+ template<typename Combiner>
+ void handle_succeeded_combined(iterator, iterator);
+ void handle_reinserted(iterator);
+ template<typename Combiner>
+ void gap_insert_at(iterator &, iterator, const interval_type &,
+ const codomain_type &);
+};interval_map
+ public
+ construct/copy/destructinterval_map();Default constructor for the empty object.
interval_map(const interval_map & src);Copy constructor.
template<typename SubType> + interval_map(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & src);Copy constructor for base_type.
interval_map(domain_mapping_type & base_pair);
interval_map(const value_type & value_pair);
template<typename SubType> + interval_map& + operator=(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & src);Assignment operator.
interval_map public member functionstypedef ICL_INTERVAL_TYPE(Interval, DomainT, Compare);The interval type of the map.
template<typename SubType> + void assign(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & src);Assignment from a base interval_map.
interval_map private member functionsiterator handle_inserted(iterator it_);
void handle_inserted(iterator prior_, iterator it_);
template<typename Combiner> void handle_left_combined(iterator it_);
template<typename Combiner> void handle_combined(iterator it_);
template<typename Combiner> + void handle_preceeded_combined(iterator prior_, iterator & it_);
template<typename Combiner> + void handle_succeeded_combined(iterator it_, iterator next_);
void handle_reinserted(iterator insertion_);
template<typename Combiner> + void gap_insert_at(iterator & it_, iterator prior_, + const interval_type & end_gap, + const codomain_type & co_val);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_set — Implements a set as a set of intervals - merging adjoining intervals.
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, + ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, DomainT), + ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), + ICL_ALLOC Alloc = std::allocator> +class interval_set : public boost::icl::interval_base_set< interval_set< DomainT, Compare, Interval, Alloc >, DomainT, Compare, Interval, Alloc > +{ +public: + // types + typedef interval_set< DomainT, Compare, Interval, Alloc > type; + typedef interval_base_set< type, DomainT, Compare, Interval, Alloc > base_type; // The base_type of this class. + typedef type overloadable_type; // Auxilliary type for overloadresolution. + typedef type joint_type; + typedef type key_object_type; + typedef DomainT domain_type; // The domain type of the set. + typedef DomainT codomain_type; // The codomaintype is the same as domain_type. + typedef DomainT element_type; // The element type of the set. + typedef interval_type segment_type; // The segment type of the set. + typedef exclusive_less_than< interval_type > interval_compare; // Comparison functor for intervals. + typedef exclusive_less_than< interval_type > key_compare; // Comparison functor for keys. + typedef Alloc< interval_type > allocator_type; // The allocator type of the set. + typedef Alloc< DomainT > domain_allocator_type; // allocator type of the corresponding element set + typedef base_type::atomized_type atomized_type; // The corresponding atomized type representing this interval container of elements. + typedef base_type::ImplSetT ImplSetT; // Container type for the implementation. + typedef ImplSetT::key_type key_type; // key type of the implementing container + typedef ImplSetT::value_type data_type; // data type of the implementing container + typedef ImplSetT::value_type value_type; // value type of the implementing container + typedef ImplSetT::iterator iterator; // iterator for iteration over intervals + typedef ImplSetT::const_iterator const_iterator; // const_iterator for iteration over intervals + + enum @1 { fineness = 1 }; + + // construct/copy/destruct + interval_set(); + interval_set(const interval_set &); + template<typename SubType> + interval_set(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &); + interval_set(const domain_type &); + interval_set(const interval_type &); + template<typename SubType> + interval_set& + operator=(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &); + + // public member functions + typedef ICL_INTERVAL_TYPE(Interval, DomainT, Compare); + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + template<typename SubType> + void assign(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &); + + // private member functions + iterator handle_inserted(iterator); + iterator add_over(const interval_type &, iterator); + iterator add_over(const interval_type &); +};
interval_set
+ public
+ construct/copy/destructinterval_set();Default constructor for the empty object.
interval_set(const interval_set & src);Copy constructor.
template<typename SubType> + interval_set(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > & src);Copy constructor for base_type.
interval_set(const domain_type & value);Constructor for a single element.
interval_set(const interval_type & itv);Constructor for a single interval.
template<typename SubType> + interval_set& + operator=(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > & src);Assignment operator.
interval_set public member functionstypedef ICL_INTERVAL_TYPE(Interval, DomainT, Compare);The interval type of the set.
typedef ICL_COMPARE_DOMAIN(Compare, DomainT);Comparison functor for domain values.
template<typename SubType> + void assign(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > & src);Assignment from a base interval_set.
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct interval_traits { + // types + typedef interval_traits type; + typedef domain_type_of< Type >::type domain_type; + + // public static functions + static Type construct(const domain_type &, const domain_type &); + static domain_type upper(const Type &); + static domain_type lower(const Type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::closed_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::closed_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::closed_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::closed_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::closed_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::closed_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::closed_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::closed_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::closed_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::closed_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::closed_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::closed_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::continuous_interval< DomainT, Compare >> { + // types + typedef interval_traits type; + typedef DomainT domain_type; + typedef icl::continuous_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::continuous_interval< DomainT, Compare >> { + // types + typedef interval_traits type; + typedef DomainT domain_type; + typedef icl::continuous_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::continuous_interval< DomainT, Compare >> { + // types + typedef interval_traits type; + typedef DomainT domain_type; + typedef icl::continuous_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::continuous_interval< DomainT, Compare >> { + // types + typedef interval_traits type; + typedef DomainT domain_type; + typedef icl::continuous_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::continuous_interval< DomainT, Compare >> { + // types + typedef interval_traits type; + typedef DomainT domain_type; + typedef icl::continuous_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::continuous_interval< DomainT, Compare >> { + // types + typedef interval_traits type; + typedef DomainT domain_type; + typedef icl::continuous_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::discrete_interval< DomainT, Compare >> { + // types + typedef interval_traits type; + typedef DomainT domain_type; + typedef icl::discrete_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::discrete_interval< DomainT, Compare >> { + // types + typedef interval_traits type; + typedef DomainT domain_type; + typedef icl::discrete_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::discrete_interval< DomainT, Compare >> { + // types + typedef interval_traits type; + typedef DomainT domain_type; + typedef icl::discrete_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::discrete_interval< DomainT, Compare >> { + // types + typedef interval_traits type; + typedef DomainT domain_type; + typedef icl::discrete_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::discrete_interval< DomainT, Compare >> { + // types + typedef interval_traits type; + typedef DomainT domain_type; + typedef icl::discrete_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::discrete_interval< DomainT, Compare >> { + // types + typedef interval_traits type; + typedef DomainT domain_type; + typedef icl::discrete_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::left_open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::left_open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::left_open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::left_open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::left_open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::left_open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::left_open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::left_open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::left_open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::left_open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::left_open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::left_open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::right_open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::right_open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::right_open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::right_open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::right_open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::right_open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::right_open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::right_open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::right_open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::right_open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::interval_traits<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct interval_traits<icl::right_open_interval< DomainT, Compare >> { + // types + typedef DomainT domain_type; + typedef icl::right_open_interval< DomainT, Compare > interval_type; + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + + // public static functions + static interval_type construct(const domain_type &, const domain_type &); + static domain_type lower(const interval_type &); + static domain_type upper(const interval_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_add< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_add< Type >> { + // types + typedef icl::inplace_bit_subtract< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_subtract< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_subtract< Type >> { + // types + typedef icl::inplace_bit_add< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_and< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_and< Type >> { + // types + typedef icl::inplace_bit_xor< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_xor< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_xor< Type >> { + // types + typedef icl::inplace_bit_and< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_add< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_add< Type >> { + // types + typedef icl::inplace_bit_subtract< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_subtract< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_subtract< Type >> { + // types + typedef icl::inplace_bit_add< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_and< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_and< Type >> { + // types + typedef icl::inplace_bit_xor< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_xor< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_xor< Type >> { + // types + typedef icl::inplace_bit_and< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_add< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_add< Type >> { + // types + typedef icl::inplace_bit_subtract< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_subtract< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_subtract< Type >> { + // types + typedef icl::inplace_bit_add< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_and< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_and< Type >> { + // types + typedef icl::inplace_bit_xor< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_xor< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_xor< Type >> { + // types + typedef icl::inplace_bit_and< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_add< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_add< Type >> { + // types + typedef icl::inplace_bit_subtract< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_subtract< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_subtract< Type >> { + // types + typedef icl::inplace_bit_add< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_and< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_and< Type >> { + // types + typedef icl::inplace_bit_xor< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_xor< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_xor< Type >> { + // types + typedef icl::inplace_bit_and< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_add< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_add< Type >> { + // types + typedef icl::inplace_bit_subtract< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_subtract< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_subtract< Type >> { + // types + typedef icl::inplace_bit_add< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_and< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_and< Type >> { + // types + typedef icl::inplace_bit_xor< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_xor< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_xor< Type >> { + // types + typedef icl::inplace_bit_and< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_add< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_add< Type >> { + // types + typedef icl::inplace_bit_subtract< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_subtract< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_subtract< Type >> { + // types + typedef icl::inplace_bit_add< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_and< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_and< Type >> { + // types + typedef icl::inplace_bit_xor< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_bit_xor< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_bit_xor< Type >> { + // types + typedef icl::inplace_bit_and< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_caret< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_caret< Type >> { + // types + typedef icl::inplace_et< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_caret< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_caret< Type >> { + // types + typedef icl::inplace_et< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_caret< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_caret< Type >> { + // types + typedef icl::inplace_et< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_caret< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_caret< Type >> { + // types + typedef icl::inplace_et< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_caret< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_caret< Type >> { + // types + typedef icl::inplace_et< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_caret< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_caret< Type >> { + // types + typedef icl::inplace_et< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_et< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_et< Type >> { + // types + typedef icl::inplace_caret< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_et< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_et< Type >> { + // types + typedef icl::inplace_caret< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_et< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_et< Type >> { + // types + typedef icl::inplace_caret< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_et< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_et< Type >> { + // types + typedef icl::inplace_caret< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_et< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_et< Type >> { + // types + typedef icl::inplace_caret< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_et< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_et< Type >> { + // types + typedef icl::inplace_caret< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_max< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_max< Type >> { + // types + typedef icl::inplace_min< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_max< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_max< Type >> { + // types + typedef icl::inplace_min< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_max< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_max< Type >> { + // types + typedef icl::inplace_min< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_max< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_max< Type >> { + // types + typedef icl::inplace_min< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_max< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_max< Type >> { + // types + typedef icl::inplace_min< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_max< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_max< Type >> { + // types + typedef icl::inplace_min< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_minus< Type >> { + // types + typedef icl::inplace_plus< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_min< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_min< Type >> { + // types + typedef icl::inplace_max< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_minus< Type >> { + // types + typedef icl::inplace_plus< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_min< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_min< Type >> { + // types + typedef icl::inplace_max< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_minus< Type >> { + // types + typedef icl::inplace_plus< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_min< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_min< Type >> { + // types + typedef icl::inplace_max< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_minus< Type >> { + // types + typedef icl::inplace_plus< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_minus< Type >> { + // types + typedef icl::inplace_plus< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_min< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_min< Type >> { + // types + typedef icl::inplace_max< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_min< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_min< Type >> { + // types + typedef icl::inplace_max< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_minus< Type >> { + // types + typedef icl::inplace_plus< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_min< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_min< Type >> { + // types + typedef icl::inplace_max< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_plus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_plus< Type >> { + // types + typedef icl::inplace_minus< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_plus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_plus< Type >> { + // types + typedef icl::inplace_minus< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_plus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_plus< Type >> { + // types + typedef icl::inplace_minus< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_plus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_plus< Type >> { + // types + typedef icl::inplace_minus< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_plus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_plus< Type >> { + // types + typedef icl::inplace_minus< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_plus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_plus< Type >> { + // types + typedef icl::inplace_minus< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_slash< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_slash< Type >> { + // types + typedef icl::inplace_star< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_slash< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_slash< Type >> { + // types + typedef icl::inplace_star< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_slash< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_slash< Type >> { + // types + typedef icl::inplace_star< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_slash< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_slash< Type >> { + // types + typedef icl::inplace_star< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_slash< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_slash< Type >> { + // types + typedef icl::inplace_star< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_slash< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_slash< Type >> { + // types + typedef icl::inplace_star< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_star< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_star< Type >> { + // types + typedef icl::inplace_slash< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_star< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_star< Type >> { + // types + typedef icl::inplace_slash< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_star< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_star< Type >> { + // types + typedef icl::inplace_slash< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_star< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_star< Type >> { + // types + typedef icl::inplace_slash< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_star< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_star< Type >> { + // types + typedef icl::inplace_slash< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inplace_star< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inplace_star< Type >> { + // types + typedef icl::inplace_slash< Type > type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inter_section< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inter_section< Type >> : public boost::icl::identity_based_inplace_combine< Type > { + // types + typedef boost::mpl::if_< has_set_semantics< Type >, icl::inplace_caret< Type >, icl::inplace_minus< Type > >::type type; + + // public member functions + void operator()(Type &, const Type &) const; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inter_section< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inter_section< Type >> : public boost::icl::identity_based_inplace_combine< Type > { + // types + typedef boost::mpl::if_< has_set_semantics< Type >, icl::inplace_caret< Type >, icl::inplace_minus< Type > >::type type; + + // public member functions + void operator()(Type &, const Type &) const; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inter_section< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inter_section< Type >> : public boost::icl::identity_based_inplace_combine< Type > { + // types + typedef boost::mpl::if_< has_set_semantics< Type >, icl::inplace_caret< Type >, icl::inplace_minus< Type > >::type type; + + // public member functions + void operator()(Type &, const Type &) const; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inter_section< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inter_section< Type >> : public boost::icl::identity_based_inplace_combine< Type > { + // types + typedef boost::mpl::if_< has_set_semantics< Type >, icl::inplace_caret< Type >, icl::inplace_minus< Type > >::type type; + + // public member functions + void operator()(Type &, const Type &) const; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inter_section< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inter_section< Type >> : public boost::icl::identity_based_inplace_combine< Type > { + // types + typedef boost::mpl::if_< has_set_semantics< Type >, icl::inplace_caret< Type >, icl::inplace_minus< Type > >::type type; + + // public member functions + void operator()(Type &, const Type &) const; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::inverse<icl::inter_section< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct inverse<icl::inter_section< Type >> : public boost::icl::identity_based_inplace_combine< Type > { + // types + typedef boost::mpl::if_< has_set_semantics< Type >, icl::inplace_caret< Type >, icl::inplace_minus< Type > >::type type; + + // public member functions + void operator()(Type &, const Type &) const; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_continuous<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_continuous<boost::rational< Integral >> { + // types + typedef is_continuous type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_continuous<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_continuous<boost::rational< Integral >> { + // types + typedef is_continuous type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_continuous<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_continuous<boost::rational< Integral >> { + // types + typedef is_continuous type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_continuous<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_continuous<boost::rational< Integral >> { + // types + typedef is_continuous type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_continuous<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_continuous<boost::rational< Integral >> { + // types + typedef is_continuous type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_continuous<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_continuous<boost::rational< Integral >> { + // types + typedef is_continuous type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_continuous_interval<continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct is_continuous_interval<continuous_interval< DomainT, Compare >> { + // types + typedef is_continuous_interval< continuous_interval< DomainT, Compare > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_continuous_interval<continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct is_continuous_interval<continuous_interval< DomainT, Compare >> { + // types + typedef is_continuous_interval< continuous_interval< DomainT, Compare > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_continuous_interval<continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct is_continuous_interval<continuous_interval< DomainT, Compare >> { + // types + typedef is_continuous_interval< continuous_interval< DomainT, Compare > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_continuous_interval<continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct is_continuous_interval<continuous_interval< DomainT, Compare >> { + // types + typedef is_continuous_interval< continuous_interval< DomainT, Compare > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_continuous_interval<continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct is_continuous_interval<continuous_interval< DomainT, Compare >> { + // types + typedef is_continuous_interval< continuous_interval< DomainT, Compare > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_continuous_interval<continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct is_continuous_interval<continuous_interval< DomainT, Compare >> { + // types + typedef is_continuous_interval< continuous_interval< DomainT, Compare > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct is_discrete<boost::gregorian::date> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct is_discrete<boost::gregorian::date_duration> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct is_discrete<boost::gregorian::date> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct is_discrete<boost::gregorian::date_duration> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct is_discrete<boost::gregorian::date> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct is_discrete<boost::gregorian::date_duration> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct is_discrete<boost::gregorian::date> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct is_discrete<boost::gregorian::date_duration> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct is_discrete<boost::gregorian::date> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct is_discrete<boost::gregorian::date> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct is_discrete<boost::gregorian::date_duration> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct is_discrete<boost::gregorian::date_duration> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct is_discrete<boost::posix_time::ptime> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct is_discrete<boost::posix_time::time_duration> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct is_discrete<boost::posix_time::ptime> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct is_discrete<boost::posix_time::time_duration> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct is_discrete<boost::posix_time::ptime> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct is_discrete<boost::posix_time::time_duration> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct is_discrete<boost::posix_time::ptime> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct is_discrete<boost::posix_time::time_duration> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct is_discrete<boost::posix_time::ptime> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct is_discrete<boost::posix_time::time_duration> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct is_discrete<boost::posix_time::ptime> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct is_discrete<boost::posix_time::time_duration> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_discrete<boost::rational< Integral >> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = false); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_discrete<boost::rational< Integral >> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = false); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_discrete<boost::rational< Integral >> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = false); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_discrete<boost::rational< Integral >> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = false); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_discrete<boost::rational< Integral >> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = false); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_discrete<boost::rational< Integral >> { + // types + typedef is_discrete type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = false); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete_interval<discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct is_discrete_interval<discrete_interval< DomainT, Compare >> { + // types + typedef is_discrete_interval< discrete_interval< DomainT, Compare > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = is_discrete< DomainT >::value); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete_interval<discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct is_discrete_interval<discrete_interval< DomainT, Compare >> { + // types + typedef is_discrete_interval< discrete_interval< DomainT, Compare > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = is_discrete< DomainT >::value); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete_interval<discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct is_discrete_interval<discrete_interval< DomainT, Compare >> { + // types + typedef is_discrete_interval< discrete_interval< DomainT, Compare > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = is_discrete< DomainT >::value); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete_interval<discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct is_discrete_interval<discrete_interval< DomainT, Compare >> { + // types + typedef is_discrete_interval< discrete_interval< DomainT, Compare > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = is_discrete< DomainT >::value); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete_interval<discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct is_discrete_interval<discrete_interval< DomainT, Compare >> { + // types + typedef is_discrete_interval< discrete_interval< DomainT, Compare > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = is_discrete< DomainT >::value); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_discrete_interval<discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct is_discrete_interval<discrete_interval< DomainT, Compare >> { + // types + typedef is_discrete_interval< discrete_interval< DomainT, Compare > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = is_discrete< DomainT >::value); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_base_set.hpp> + +template<typename SubType, typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_base_set.hpp> + +template<typename SubType, typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_base_set.hpp> + +template<typename SubType, typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_base_set.hpp> + +template<typename SubType, typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_base_set.hpp> + +template<typename SubType, typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_base_set.hpp> + +template<typename SubType, typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_container< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_container<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_container<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_container< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_joiner<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_joiner<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_joiner< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_joiner<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_joiner<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_joiner< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_joiner<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_joiner<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_joiner< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_joiner<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_joiner<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_joiner< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_joiner<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_joiner<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_joiner< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_joiner<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_joiner<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_joiner< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_separator<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_separator<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_separator< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_separator<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_separator<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_separator< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_separator<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_separator<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_separator< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_separator<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_separator<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_separator< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_separator<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_separator<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_separator< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_separator<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_separator<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_separator< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_splitter<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_splitter<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_splitter< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_splitter<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_splitter<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_splitter< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_splitter<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_splitter<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_splitter< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_splitter<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_splitter<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_splitter< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_splitter<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_splitter<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_splitter< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_splitter<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_splitter<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_splitter< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_splitter<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_splitter<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_splitter< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_splitter<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_splitter<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_splitter< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_splitter<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_splitter<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_splitter< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_splitter<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_splitter<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_splitter< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_splitter<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_splitter<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_interval_splitter< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_interval_splitter<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_interval_splitter<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_interval_splitter< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_map<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_map<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_map<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_map<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_map<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_map<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_map<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_map<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_map<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_map<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_map<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_map<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct is_map<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef is_map< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct is_map<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef is_map< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct is_map<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef is_map< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct is_map<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef is_map< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct is_map<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef is_map< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct is_map<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef is_map< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_map<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_map<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_map<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_map<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_map<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_map<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_map<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_map< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_negative
+// In header: <boost/icl/functors.hpp> + +template<typename Functor> +struct is_negative { + // types + typedef is_negative< Functor > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = false); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_negative<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct is_negative<icl::inplace_minus< Type >> { + // types + typedef is_negative type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_negative<icl::inplace_bit_subtract< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct is_negative<icl::inplace_bit_subtract< Type >> { + // types + typedef is_negative type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_negative<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct is_negative<icl::inplace_minus< Type >> { + // types + typedef is_negative type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_negative<icl::inplace_bit_subtract< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct is_negative<icl::inplace_bit_subtract< Type >> { + // types + typedef is_negative type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_negative<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct is_negative<icl::inplace_minus< Type >> { + // types + typedef is_negative type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_negative<icl::inplace_bit_subtract< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct is_negative<icl::inplace_bit_subtract< Type >> { + // types + typedef is_negative type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_negative<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct is_negative<icl::inplace_minus< Type >> { + // types + typedef is_negative type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_negative<icl::inplace_bit_subtract< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct is_negative<icl::inplace_bit_subtract< Type >> { + // types + typedef is_negative type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_negative<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct is_negative<icl::inplace_minus< Type >> { + // types + typedef is_negative type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_negative<icl::inplace_bit_subtract< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct is_negative<icl::inplace_bit_subtract< Type >> { + // types + typedef is_negative type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_negative<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct is_negative<icl::inplace_minus< Type >> { + // types + typedef is_negative type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_negative<icl::inplace_bit_subtract< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct is_negative<icl::inplace_bit_subtract< Type >> { + // types + typedef is_negative type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_numeric<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_numeric<boost::rational< Integral >> { + // types + typedef is_numeric type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_numeric<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_numeric<boost::rational< Integral >> { + // types + typedef is_numeric type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_numeric<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_numeric<boost::rational< Integral >> { + // types + typedef is_numeric type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_numeric<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_numeric<boost::rational< Integral >> { + // types + typedef is_numeric type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_numeric<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_numeric<boost::rational< Integral >> { + // types + typedef is_numeric type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_numeric<boost::rational< Integral >>
+// In header: <boost/icl/rational.hpp> + +template<typename Integral> +struct is_numeric<boost::rational< Integral >> { + // types + typedef is_numeric type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_base_set.hpp> + +template<typename SubType, typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_base_set.hpp> + +template<typename SubType, typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_base_set.hpp> + +template<typename SubType, typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_base_set.hpp> + +template<typename SubType, typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_base_set.hpp> + +template<typename SubType, typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_base_set.hpp> + +template<typename SubType, typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_set<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_set<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + // types + typedef is_set< icl::split_interval_set< DomainT, Compare, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = true); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_total<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_total<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_total<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_total<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_total<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename SubType, typename DomainT, typename CodomainT, + typename Traits, ICL_COMPARE Compare, ICL_COMBINE Combine, + ICL_SECTION Section, ICL_INTERVAL(ICL_COMPARE) Interval, + ICL_ALLOC Alloc> +struct is_total<icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_total<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_total<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_total<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_total<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_total<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_total<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct is_total<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef is_total type; + + // public member functions + BOOST_STATIC_CONSTANT(int, value = Traits::is_total); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct is_total<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef is_total type; + + // public member functions + BOOST_STATIC_CONSTANT(int, value = Traits::is_total); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct is_total<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef is_total type; + + // public member functions + BOOST_STATIC_CONSTANT(int, value = Traits::is_total); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct is_total<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef is_total type; + + // public member functions + BOOST_STATIC_CONSTANT(int, value = Traits::is_total); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct is_total<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef is_total type; + + // public member functions + BOOST_STATIC_CONSTANT(int, value = Traits::is_total); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct is_total<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + // types + typedef is_total type; + + // public member functions + BOOST_STATIC_CONSTANT(int, value = Traits::is_total); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_total<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_total<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_total<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_total<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_total<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::is_total<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct is_total<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + // types + typedef is_total< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > > type; + + // public member functions + BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total)); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::left_open_interval
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, + ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, DomainT)> +class left_open_interval { +public: + // types + typedef left_open_interval< DomainT, Compare > type; + typedef DomainT domain_type; + + // construct/copy/destruct + left_open_interval(); + left_open_interval(const DomainT &); + left_open_interval(const DomainT &, const DomainT &); + + // public member functions + DomainT lower() const; + DomainT upper() const; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map — Addable, subractable and intersectable maps.
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, + typename Traits = icl::partial_absorber, + ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, DomainT), + ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), + ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), + ICL_ALLOC Alloc = std::allocator> +class map { +public: + // types + typedef Alloc< typename std::pair< const DomainT, CodomainT > > allocator_type; + typedef icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > type; + typedef ICL_IMPL_SPACE::map< DomainT, CodomainT, ICL_COMPARE_DOMAIN(Compare, DomainT), allocator_type > base_type; + typedef Traits traits; + typedef DomainT domain_type; + typedef boost::call_traits< DomainT >::param_type domain_param; + typedef DomainT key_type; + typedef CodomainT codomain_type; + typedef CodomainT mapped_type; + typedef CodomainT data_type; + typedef std::pair< const DomainT, CodomainT > element_type; + typedef std::pair< const DomainT, CodomainT > value_type; + typedef domain_compare key_compare; + typedef inverse< codomain_combine >::type inverse_codomain_combine; + typedef mpl::if_< has_set_semantics< codomain_type >, ICL_SECTION_CODOMAIN(Section, CodomainT), codomain_combine >::type codomain_intersect; + typedef inverse< codomain_intersect >::type inverse_codomain_intersect; + typedef base_type::value_compare value_compare; + typedef ICL_IMPL_SPACE::set< DomainT, domain_compare, Alloc< DomainT > > set_type; + typedef set_type key_object_type; + typedef on_absorbtion< type, codomain_combine, Traits::absorbs_identities > on_identity_absorbtion; + typedef base_type::pointer pointer; + typedef base_type::const_pointer const_pointer; + typedef base_type::reference reference; + typedef base_type::const_reference const_reference; + typedef base_type::iterator iterator; + typedef base_type::const_iterator const_iterator; + typedef base_type::size_type size_type; + typedef base_type::difference_type difference_type; + typedef base_type::reverse_iterator reverse_iterator; + typedef base_type::const_reverse_iterator const_reverse_iterator; + + // member classes/structs/unions + template<typename Type> + struct on_codomain_model<Type, false, false> { + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); + }; + template<typename Type> + struct on_codomain_model<Type, false, true> { + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); + }; + template<typename Type> + struct on_codomain_model<Type, true, false> { + // types + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); + }; + template<typename Type> + struct on_codomain_model<Type, true, true> { + // types + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); + }; + template<typename Type> + struct on_definedness<Type, false> { + + // public static functions + static void add_intersection(Type &, const Type &, const element_type &); + }; + template<typename Type> + struct on_definedness<Type, true> { + + // public static functions + static void add_intersection(Type &, const Type &, const element_type &); + }; + template<typename Type> + struct on_invertible<Type, false> { + // types + typedef Type::element_type element_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const element_type &); + }; + template<typename Type> + struct on_invertible<Type, true> { + // types + typedef Type::element_type element_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const element_type &); + }; + template<typename Type> + struct on_total_absorbable<Type, false, false> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + typedef Type::iterator iterator; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const element_type &); + }; + template<typename Type> + struct on_total_absorbable<Type, false, true> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + typedef Type::iterator iterator; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const element_type &); + }; + template<typename Type> + struct on_total_absorbable<Type, true, false> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + + // public static functions + static void flip(Type &, const element_type &); + }; + template<typename Type> + struct on_total_absorbable<Type, true, true> { + // types + typedef Type::element_type element_type; + + // public static functions + static void flip(Type &, const typename Type::element_type &); + }; + + // construct/copy/destruct + map(); + map(const key_compare &); + template<typename InputIterator> map(InputIterator, InputIterator); + template<typename InputIterator> + map(InputIterator, InputIterator, const key_compare &); + map(const map &); + map(const element_type &); + map& operator=(const map &); + + // public member functions + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + typedef ICL_COMBINE_CODOMAIN(Combine, CodomainT); + typedef ICL_COMPARE_DOMAIN(Compare, element_type); + BOOST_STATIC_CONSTANT(bool, _total = (Traits::is_total)); + BOOST_STATIC_CONSTANT(bool, _absorbs = (Traits::absorbs_identities)); + BOOST_STATIC_CONSTANT(bool, + total_invertible = (mpl::and_< is_total< type >, has_inverse< codomain_type > >::value)); + BOOST_STATIC_CONSTANT(bool, + is_total_invertible = (Traits::is_total &&has_inverse< codomain_type >::value)); + BOOST_STATIC_CONSTANT(int, fineness = 4); + void swap(map &); + template<typename SubObject> bool contains(const SubObject &) const; + bool within(const map &) const; + std::size_t iterative_size() const; + codomain_type operator()(const domain_type &) const; + map & add(const value_type &); + iterator add(iterator, const value_type &); + map & subtract(const element_type &); + map & subtract(const domain_type &); + std::pair< iterator, bool > insert(const value_type &); + iterator insert(iterator, const value_type &); + map & set(const element_type &); + size_type erase(const element_type &); + void add_intersection(map &, const element_type &) const; + map & flip(const element_type &); + + // private member functions + template<typename Combiner> map & _add(const element_type &); + template<typename Combiner> iterator _add(iterator, const element_type &); + template<typename Combiner> map & _subtract(const element_type &); + template<typename FragmentT> + void total_add_intersection(type &, const FragmentT &) const; + void partial_add_intersection(type &, const element_type &) const; +};
map
+ public
+ construct/copy/destructmap();
map(const key_compare & comp);
template<typename InputIterator> map(InputIterator first, InputIterator past);
template<typename InputIterator> + map(InputIterator first, InputIterator past, const key_compare & comp);
map(const map & src);
map(const element_type & key_value_pair);
map& operator=(const map & src);
map public member functionstypedef ICL_COMPARE_DOMAIN(Compare, DomainT);
typedef ICL_COMBINE_CODOMAIN(Combine, CodomainT);
typedef ICL_COMPARE_DOMAIN(Compare, element_type);
BOOST_STATIC_CONSTANT(bool, _total = (Traits::is_total));
BOOST_STATIC_CONSTANT(bool, _absorbs = (Traits::absorbs_identities));
BOOST_STATIC_CONSTANT(bool, + total_invertible = (mpl::and_< is_total< type >, has_inverse< codomain_type > >::value));
BOOST_STATIC_CONSTANT(bool, + is_total_invertible = (Traits::is_total &&has_inverse< codomain_type >::value));
BOOST_STATIC_CONSTANT(int, fineness = 4);
void swap(map & src);
template<typename SubObject> bool contains(const SubObject & sub) const;
bool within(const map & super) const;
std::size_t iterative_size() const;+
iterative_size() yields the number of elements that is visited throu complete iteration. For interval sets iterative_size() is different from size().
codomain_type operator()(const domain_type & key) const;+
Total select function.
+map & add(const value_type & value_pair);+
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 add(iterator prior, const value_type & value_pair);+
add add value_pair into the map using prior as a hint to insert value_pair after the position prior is pointing to.
map & subtract(const element_type & value_pair);+
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 & subtract(const domain_type & key);
std::pair< iterator, bool > insert(const value_type & value_pair);
iterator insert(iterator prior, const value_type & value_pair);
map & set(const element_type & key_value_pair);+
With key_value_pair = (k,v) set value v for key k
size_type erase(const element_type & key_value_pair);+
erase key_value_pair from the map. Erase only if, the exact value content val is stored for the given key.
void add_intersection(map & section, const element_type & key_value_pair) const;+
The intersection of key_value_pair and *this map is added to section.
map & flip(const element_type & operand);
map private member functionstemplate<typename Combiner> map & _add(const element_type & value_pair);
template<typename Combiner> + iterator _add(iterator prior, const element_type & value_pair);
template<typename Combiner> map & _subtract(const element_type & value_pair);
template<typename FragmentT> + void total_add_intersection(type & section, const FragmentT & fragment) const;
void partial_add_intersection(type & section, const element_type & operand) const;
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, false, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false, false> { + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, false, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false, true> { + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, true, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true, false> { + // types + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, true, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true, true> { + // types + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, false, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false, false> { + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, false, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false, true> { + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, true, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true, false> { + // types + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, true, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true, true> { + // types + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, false, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false, false> { + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, false, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false, true> { + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, true, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true, false> { + // types + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, true, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true, true> { + // types + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, false, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false, false> { + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, false, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false, true> { + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, true, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true, false> { + // types + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, true, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true, true> { + // types + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, false, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false, false> { + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, false, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false, true> { + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, true, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true, false> { + // types + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, true, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true, true> { + // types + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, false, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false, false> { + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, false, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, false, true> { + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, true, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true, false> { + // types + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_codomain_model<Type, true, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_codomain_model<Type, true, true> { + // types + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void subtract(Type &, typename Type::iterator, + const typename Type::codomain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_definedness<Type, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_definedness<Type, false> { + + // public static functions + static void add_intersection(Type &, const Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_definedness<Type, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_definedness<Type, false> { + + // public static functions + static void add_intersection(Type &, const Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_definedness<Type, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_definedness<Type, false> { + + // public static functions + static void add_intersection(Type &, const Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_definedness<Type, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_definedness<Type, false> { + + // public static functions + static void add_intersection(Type &, const Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_definedness<Type, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_definedness<Type, false> { + + // public static functions + static void add_intersection(Type &, const Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_definedness<Type, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_definedness<Type, false> { + + // public static functions + static void add_intersection(Type &, const Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_definedness<Type, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_definedness<Type, true> { + + // public static functions + static void add_intersection(Type &, const Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_definedness<Type, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_definedness<Type, true> { + + // public static functions + static void add_intersection(Type &, const Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_definedness<Type, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_definedness<Type, true> { + + // public static functions + static void add_intersection(Type &, const Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_definedness<Type, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_definedness<Type, true> { + + // public static functions + static void add_intersection(Type &, const Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_definedness<Type, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_definedness<Type, true> { + + // public static functions + static void add_intersection(Type &, const Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_definedness<Type, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_definedness<Type, true> { + + // public static functions + static void add_intersection(Type &, const Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_invertible<Type, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_invertible<Type, false> { + // types + typedef Type::element_type element_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_invertible<Type, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_invertible<Type, false> { + // types + typedef Type::element_type element_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_invertible<Type, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_invertible<Type, false> { + // types + typedef Type::element_type element_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_invertible<Type, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_invertible<Type, false> { + // types + typedef Type::element_type element_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_invertible<Type, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_invertible<Type, false> { + // types + typedef Type::element_type element_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_invertible<Type, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_invertible<Type, false> { + // types + typedef Type::element_type element_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_invertible<Type, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_invertible<Type, true> { + // types + typedef Type::element_type element_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_invertible<Type, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_invertible<Type, true> { + // types + typedef Type::element_type element_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_invertible<Type, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_invertible<Type, true> { + // types + typedef Type::element_type element_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_invertible<Type, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_invertible<Type, true> { + // types + typedef Type::element_type element_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_invertible<Type, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_invertible<Type, true> { + // types + typedef Type::element_type element_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_invertible<Type, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_invertible<Type, true> { + // types + typedef Type::element_type element_type; + typedef Type::inverse_codomain_combine inverse_codomain_combine; + + // public static functions + static void subtract(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, false, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, false, false> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + typedef Type::iterator iterator; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, false, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, false, true> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + typedef Type::iterator iterator; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, true, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, false> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, true, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, true> { + // types + typedef Type::element_type element_type; + + // public static functions + static void flip(Type &, const typename Type::element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, false, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, false, false> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + typedef Type::iterator iterator; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, false, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, false, true> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + typedef Type::iterator iterator; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, true, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, false> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, true, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, true> { + // types + typedef Type::element_type element_type; + + // public static functions + static void flip(Type &, const typename Type::element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, false, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, false, false> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + typedef Type::iterator iterator; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, false, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, false, true> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + typedef Type::iterator iterator; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, true, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, false> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, true, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, true> { + // types + typedef Type::element_type element_type; + + // public static functions + static void flip(Type &, const typename Type::element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, false, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, false, false> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + typedef Type::iterator iterator; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, false, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, false, true> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + typedef Type::iterator iterator; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, true, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, false> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, false, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, false, false> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + typedef Type::iterator iterator; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, true, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, true> { + // types + typedef Type::element_type element_type; + + // public static functions + static void flip(Type &, const typename Type::element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, false, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, false, true> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + typedef Type::iterator iterator; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, true, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, false> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, true, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, true> { + // types + typedef Type::element_type element_type; + + // public static functions + static void flip(Type &, const typename Type::element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, false, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, false, false> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + typedef Type::iterator iterator; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, false, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, false, true> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + typedef Type::iterator iterator; + typedef Type::inverse_codomain_intersect inverse_codomain_intersect; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, true, false>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, false> { + // types + typedef Type::element_type element_type; + typedef Type::codomain_type codomain_type; + + // public static functions + static void flip(Type &, const element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::map::on_total_absorbable<Type, true, true>
+// In header: <boost/icl/map.hpp> + + +template<typename Type> +struct on_total_absorbable<Type, true, true> { + // types + typedef Type::element_type element_type; + + // public static functions + static void flip(Type &, const typename Type::element_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::mapping_pair
+// In header: <boost/icl/interval_base_map.hpp> + +template<typename DomainT, typename CodomainT> +struct mapping_pair { + // construct/copy/destruct + mapping_pair(); + mapping_pair(const DomainT &, const CodomainT &); + mapping_pair(const std::pair< DomainT, CodomainT > &); + DomainT key; + CodomainT data; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::open_interval
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, + ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, DomainT)> +class open_interval { +public: + // types + typedef open_interval< DomainT, Compare > type; + typedef DomainT domain_type; + + // construct/copy/destruct + open_interval(); + open_interval(const DomainT &); + open_interval(const DomainT &, const DomainT &); + + // public member functions + DomainT lower() const; + DomainT upper() const; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::partial_absorber
+// In header: <boost/icl/map.hpp> + + +struct partial_absorber { + + enum @2 { absorbs_identities = true }; + + enum @3 { is_total = false }; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::partial_enricher
+// In header: <boost/icl/map.hpp> + + +struct partial_enricher { + + enum @4 { absorbs_identities = false }; + + enum @5 { is_total = false }; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::right_open_interval
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, + ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, DomainT)> +class right_open_interval { +public: + // types + typedef right_open_interval< DomainT, Compare > type; + typedef DomainT domain_type; + + // construct/copy/destruct + right_open_interval(); + right_open_interval(const DomainT &); + right_open_interval(const DomainT &, const DomainT &); + + // public member functions + domain_type lower() const; + domain_type upper() const; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::separate_interval_set — Implements a set as a set of intervals - leaving adjoining intervals separate.
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, + ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, DomainT), + ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), + ICL_ALLOC Alloc = std::allocator> +class separate_interval_set : public boost::icl::interval_base_set< separate_interval_set< DomainT, Compare, Interval, Alloc >, DomainT, Compare, Interval, Alloc > +{ +public: + // types + typedef separate_interval_set< DomainT, Compare, Interval, Alloc > type; + typedef interval_base_set< type, DomainT, Compare, Interval, Alloc > base_type; + typedef type overloadable_type; // Auxilliary type for overloadresolution. + typedef type key_object_type; + typedef interval_set< DomainT, Compare, Interval, Alloc > joint_type; + typedef DomainT domain_type; // The domain type of the set. + typedef DomainT codomain_type; // The codomaintype is the same as domain_type. + typedef DomainT element_type; // The element type of the set. + typedef interval_type segment_type; // The segment type of the set. + typedef exclusive_less_than< interval_type > interval_compare; // Comparison functor for intervals. + typedef exclusive_less_than< interval_type > key_compare; // Comparison functor for keys. + typedef Alloc< interval_type > allocator_type; // The allocator type of the set. + typedef Alloc< DomainT > domain_allocator_type; // allocator type of the corresponding element set + typedef base_type::atomized_type atomized_type; // The corresponding atomized type representing this interval container of elements. + typedef base_type::ImplSetT ImplSetT; // Container type for the implementation. + typedef ImplSetT::key_type key_type; // key type of the implementing container + typedef ImplSetT::value_type data_type; // data type of the implementing container + typedef ImplSetT::value_type value_type; // value type of the implementing container + typedef ImplSetT::iterator iterator; // iterator for iteration over intervals + typedef ImplSetT::const_iterator const_iterator; // const_iterator for iteration over intervals + + enum @10 { fineness = 2 }; + + // construct/copy/destruct + separate_interval_set(); + separate_interval_set(const separate_interval_set &); + template<typename SubType> + separate_interval_set(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &); + separate_interval_set(const domain_type &); + separate_interval_set(const interval_type &); + template<typename SubType> + separate_interval_set& + operator=(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &); + + // public member functions + typedef ICL_INTERVAL_TYPE(Interval, DomainT, Compare); + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + template<typename SubType> + void assign(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &); + + // private member functions + iterator handle_inserted(iterator); + iterator add_over(const interval_type &, iterator); + iterator add_over(const interval_type &); +};
separate_interval_set
+ public
+ construct/copy/destructseparate_interval_set();Default constructor for the empty object.
separate_interval_set(const separate_interval_set & src);Copy constructor.
template<typename SubType> + separate_interval_set(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > & src);Copy constructor for base_type.
separate_interval_set(const domain_type & elem);Constructor for a single element.
separate_interval_set(const interval_type & itv);Constructor for a single interval.
template<typename SubType> + separate_interval_set& + operator=(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > & src);Assignment operator.
separate_interval_set public member functionstypedef ICL_INTERVAL_TYPE(Interval, DomainT, Compare);The interval type of the set.
typedef ICL_COMPARE_DOMAIN(Compare, DomainT);Comparison functor for domain values.
template<typename SubType> + void assign(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > & src);Assignment from a base interval_set.
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct size_type_of<boost::gregorian::date> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct size_type_of<boost::gregorian::date_duration> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct size_type_of<boost::gregorian::date> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct size_type_of<boost::gregorian::date_duration> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct size_type_of<boost::gregorian::date> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct size_type_of<boost::gregorian::date_duration> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct size_type_of<boost::gregorian::date> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct size_type_of<boost::gregorian::date> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct size_type_of<boost::gregorian::date_duration> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::gregorian::date>
+// In header: <boost/icl/gregorian.hpp> + + +struct size_type_of<boost::gregorian::date> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct size_type_of<boost::gregorian::date_duration> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::gregorian::date_duration>
+// In header: <boost/icl/gregorian.hpp> + + +struct size_type_of<boost::gregorian::date_duration> { + // types + typedef boost::gregorian::date_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct size_type_of<boost::posix_time::ptime> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct size_type_of<boost::posix_time::time_duration> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct size_type_of<boost::posix_time::ptime> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct size_type_of<boost::posix_time::time_duration> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct size_type_of<boost::posix_time::ptime> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct size_type_of<boost::posix_time::time_duration> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct size_type_of<boost::posix_time::ptime> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct size_type_of<boost::posix_time::time_duration> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct size_type_of<boost::posix_time::ptime> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct size_type_of<boost::posix_time::time_duration> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::posix_time::ptime>
+// In header: <boost/icl/ptime.hpp> + + +struct size_type_of<boost::posix_time::ptime> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<boost::posix_time::time_duration>
+// In header: <boost/icl/ptime.hpp> + + +struct size_type_of<boost::posix_time::time_duration> { + // types + typedef boost::posix_time::time_duration type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct size_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type domain_type; + typedef size_type_of< domain_type >::type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct size_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type domain_type; + typedef size_type_of< domain_type >::type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct size_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type domain_type; + typedef size_type_of< domain_type >::type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct size_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type domain_type; + typedef size_type_of< domain_type >::type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct size_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type domain_type; + typedef size_type_of< domain_type >::type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::size_type_of<interval_traits< Type >>
+// In header: <boost/icl/interval_traits.hpp> + +template<typename Type> +struct size_type_of<interval_traits< Type >> { + // types + typedef interval_traits< Type >::domain_type domain_type; + typedef size_type_of< domain_type >::type type; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::split_interval_map — implements a map as a map of intervals - on insertion overlapping intervals are split and associated values are combined.
+// In header: <boost/icl/split_interval_map.hpp>
+
+template<typename DomainT, typename CodomainT,
+ typename Traits = icl::partial_absorber,
+ ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, DomainT),
+ ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT),
+ ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT),
+ ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare),
+ ICL_ALLOC Alloc = std::allocator>
+class split_interval_map : public boost::icl::interval_base_map< split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >
+{
+public:
+ // types
+ typedef Traits traits; // Traits of an itl map.
+ typedef split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > type;
+ typedef interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > joint_type;
+ typedef type overloadable_type; // Auxilliary type for overloadresolution.
+ typedef interval_base_map< type, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > base_type;
+ typedef DomainT domain_type; // Domain type (type of the keys) of the map.
+ typedef CodomainT codomain_type; // Domain type (type of the keys) of the map.
+ typedef base_type::iterator iterator; // iterator for iteration over intervals
+ typedef base_type::value_type value_type; // value type of the implementing container
+ typedef base_type::element_type element_type; // Conceptual is a map a set of elements of type element_type.
+ typedef base_type::segment_type segment_type; // Type of an interval containers segment, that is spanned by an interval.
+ typedef base_type::domain_mapping_type domain_mapping_type; // Auxiliary type to help the compiler resolve ambiguities when using std::make_pair.
+ typedef base_type::interval_mapping_type interval_mapping_type; // Auxiliary type for overload resolution.
+ typedef base_type::ImplMapT ImplMapT; // Container type for the implementation.
+ typedef base_type::codomain_combine codomain_combine;
+ typedef interval_set< DomainT, Compare, Interval, Alloc > interval_set_type;
+ typedef interval_set_type set_type;
+ typedef set_type key_object_type;
+
+ enum @11 { fineness = 3 };
+
+ // construct/copy/destruct
+ split_interval_map();
+ split_interval_map(const split_interval_map &);
+ split_interval_map(domain_mapping_type &);
+ split_interval_map(const value_type &);
+ template<typename SubType>
+ split_interval_map&
+ operator=(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &);
+
+ // public member functions
+ typedef ICL_INTERVAL_TYPE(Interval, DomainT, Compare);
+ template<typename SubType>
+ void assign(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > &);
+
+ // private member functions
+ iterator handle_inserted(iterator) const;
+ void handle_inserted(iterator, iterator) const;
+ template<typename Combiner> void handle_left_combined(iterator);
+ template<typename Combiner> void handle_combined(iterator);
+ template<typename Combiner>
+ void handle_preceeded_combined(iterator, iterator &);
+ template<typename Combiner>
+ void handle_succeeded_combined(iterator, iterator);
+ void handle_reinserted(iterator);
+ template<typename Combiner>
+ void gap_insert_at(iterator &, iterator, const interval_type &,
+ const codomain_type &);
+};split_interval_map
+ public
+ construct/copy/destructsplit_interval_map();Default constructor for the empty object.
split_interval_map(const split_interval_map & src);Copy constructor.
split_interval_map(domain_mapping_type & base_pair);
split_interval_map(const value_type & value_pair);
template<typename SubType> + split_interval_map& + operator=(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & src);Assignment operator.
split_interval_map public member functionstypedef ICL_INTERVAL_TYPE(Interval, DomainT, Compare);The interval type of the map.
template<typename SubType> + void assign(const interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > & src);Assignment from a base interval_map.
split_interval_map private member functionsiterator handle_inserted(iterator it_) const;
void handle_inserted(iterator, iterator) const;
template<typename Combiner> void handle_left_combined(iterator it_);
template<typename Combiner> void handle_combined(iterator it_);
template<typename Combiner> + void handle_preceeded_combined(iterator prior_, iterator & it_);
template<typename Combiner> + void handle_succeeded_combined(iterator it_, iterator);
void handle_reinserted(iterator);
template<typename Combiner> + void gap_insert_at(iterator & it_, iterator prior_, + const interval_type & end_gap, + const codomain_type & co_val);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::split_interval_set — implements a set as a set of intervals - on insertion overlapping intervals are split
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, + ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, DomainT), + ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare), + ICL_ALLOC Alloc = std::allocator> +class split_interval_set : public boost::icl::interval_base_set< split_interval_set< DomainT, Compare, Interval, Alloc >, DomainT, Compare, Interval, Alloc > +{ +public: + // types + typedef split_interval_set< DomainT, Compare, Interval, Alloc > type; + typedef interval_base_set< type, DomainT, Compare, Interval, Alloc > base_type; + typedef interval_set< DomainT, Compare, Interval, Alloc > joint_type; + typedef type overloadable_type; // Auxilliary type for overloadresolution. + typedef type key_object_type; + typedef DomainT domain_type; // The domain type of the set. + typedef DomainT codomain_type; // The codomaintype is the same as domain_type. + typedef DomainT element_type; // The element type of the set. + typedef interval_type segment_type; // The segment type of the set. + typedef exclusive_less_than< interval_type > interval_compare; // Comparison functor for intervals. + typedef exclusive_less_than< interval_type > key_compare; // Comparison functor for keys. + typedef Alloc< interval_type > allocator_type; // The allocator type of the set. + typedef Alloc< DomainT > domain_allocator_type; // allocator type of the corresponding element set + typedef base_type::atomized_type atomized_type; // The corresponding atomized type representing this interval container of elements. + typedef base_type::ImplSetT ImplSetT; // Container type for the implementation. + typedef ImplSetT::key_type key_type; // key type of the implementing container + typedef ImplSetT::value_type data_type; // data type of the implementing container + typedef ImplSetT::value_type value_type; // value type of the implementing container + typedef ImplSetT::iterator iterator; // iterator for iteration over intervals + typedef ImplSetT::const_iterator const_iterator; // const_iterator for iteration over intervals + + enum @12 { fineness = 3 }; + + // construct/copy/destruct + split_interval_set(); + split_interval_set(const split_interval_set &); + template<typename SubType> + split_interval_set(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &); + split_interval_set(const interval_type &); + split_interval_set(const domain_type &); + template<typename SubType> + split_interval_set& + operator=(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &); + + // public member functions + typedef ICL_INTERVAL_TYPE(Interval, DomainT, Compare); + typedef ICL_COMPARE_DOMAIN(Compare, DomainT); + template<typename SubType> + void assign(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > &); + + // private member functions + iterator handle_inserted(iterator); + iterator add_over(const interval_type &, iterator); + iterator add_over(const interval_type &); +};
split_interval_set
+ public
+ construct/copy/destructsplit_interval_set();Default constructor for the empty object.
split_interval_set(const split_interval_set & src);Copy constructor.
template<typename SubType> + split_interval_set(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > & src);Copy constructor for base_type.
split_interval_set(const interval_type & elem);Constructor for a single element.
split_interval_set(const domain_type & itv);Constructor for a single interval.
template<typename SubType> + split_interval_set& + operator=(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > & src);Assignment operator.
split_interval_set public member functionstypedef ICL_INTERVAL_TYPE(Interval, DomainT, Compare);The interval type of the set.
typedef ICL_COMPARE_DOMAIN(Compare, DomainT);Comparison functor for domain values.
template<typename SubType> + void assign(const interval_base_set< SubType, DomainT, Compare, Interval, Alloc > & src);Assignment from a base interval_set.
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::static_interval<IntervalT, true, PretendedBounds, RepresentedBounds>
+// In header: <boost/icl/interval.hpp> + +template<typename IntervalT, bound_type PretendedBounds, + bound_type RepresentedBounds> +struct static_interval<IntervalT, true, PretendedBounds, RepresentedBounds> { + // types + typedef interval_traits< IntervalT >::domain_type domain_type; + + // public static functions + static IntervalT construct(const domain_type &, const domain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::static_interval<IntervalT, false, PretendedBounds, RepresentedBounds>
+// In header: <boost/icl/interval.hpp> + +template<typename IntervalT, bound_type PretendedBounds, + bound_type RepresentedBounds> +struct static_interval<IntervalT, false, PretendedBounds, RepresentedBounds> { + // types + typedef interval_traits< IntervalT >::domain_type domain_type; + + // public static functions + static IntervalT construct(const domain_type &, const domain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::static_interval<IntervalT, true, PretendedBounds, RepresentedBounds>
+// In header: <boost/icl/interval.hpp> + +template<typename IntervalT, bound_type PretendedBounds, + bound_type RepresentedBounds> +struct static_interval<IntervalT, true, PretendedBounds, RepresentedBounds> { + // types + typedef interval_traits< IntervalT >::domain_type domain_type; + + // public static functions + static IntervalT construct(const domain_type &, const domain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::static_interval<IntervalT, false, PretendedBounds, RepresentedBounds>
+// In header: <boost/icl/interval.hpp> + +template<typename IntervalT, bound_type PretendedBounds, + bound_type RepresentedBounds> +struct static_interval<IntervalT, false, PretendedBounds, RepresentedBounds> { + // types + typedef interval_traits< IntervalT >::domain_type domain_type; + + // public static functions + static IntervalT construct(const domain_type &, const domain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::static_interval<IntervalT, true, PretendedBounds, RepresentedBounds>
+// In header: <boost/icl/interval.hpp> + +template<typename IntervalT, bound_type PretendedBounds, + bound_type RepresentedBounds> +struct static_interval<IntervalT, true, PretendedBounds, RepresentedBounds> { + // types + typedef interval_traits< IntervalT >::domain_type domain_type; + + // public static functions + static IntervalT construct(const domain_type &, const domain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::static_interval<IntervalT, false, PretendedBounds, RepresentedBounds>
+// In header: <boost/icl/interval.hpp> + +template<typename IntervalT, bound_type PretendedBounds, + bound_type RepresentedBounds> +struct static_interval<IntervalT, false, PretendedBounds, RepresentedBounds> { + // types + typedef interval_traits< IntervalT >::domain_type domain_type; + + // public static functions + static IntervalT construct(const domain_type &, const domain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::static_interval<IntervalT, true, PretendedBounds, RepresentedBounds>
+// In header: <boost/icl/interval.hpp> + +template<typename IntervalT, bound_type PretendedBounds, + bound_type RepresentedBounds> +struct static_interval<IntervalT, true, PretendedBounds, RepresentedBounds> { + // types + typedef interval_traits< IntervalT >::domain_type domain_type; + + // public static functions + static IntervalT construct(const domain_type &, const domain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::static_interval<IntervalT, false, PretendedBounds, RepresentedBounds>
+// In header: <boost/icl/interval.hpp> + +template<typename IntervalT, bound_type PretendedBounds, + bound_type RepresentedBounds> +struct static_interval<IntervalT, false, PretendedBounds, RepresentedBounds> { + // types + typedef interval_traits< IntervalT >::domain_type domain_type; + + // public static functions + static IntervalT construct(const domain_type &, const domain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::static_interval<IntervalT, true, PretendedBounds, RepresentedBounds>
+// In header: <boost/icl/interval.hpp> + +template<typename IntervalT, bound_type PretendedBounds, + bound_type RepresentedBounds> +struct static_interval<IntervalT, true, PretendedBounds, RepresentedBounds> { + // types + typedef interval_traits< IntervalT >::domain_type domain_type; + + // public static functions + static IntervalT construct(const domain_type &, const domain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::static_interval<IntervalT, false, PretendedBounds, RepresentedBounds>
+// In header: <boost/icl/interval.hpp> + +template<typename IntervalT, bound_type PretendedBounds, + bound_type RepresentedBounds> +struct static_interval<IntervalT, false, PretendedBounds, RepresentedBounds> { + // types + typedef interval_traits< IntervalT >::domain_type domain_type; + + // public static functions + static IntervalT construct(const domain_type &, const domain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::static_interval<IntervalT, true, PretendedBounds, RepresentedBounds>
+// In header: <boost/icl/interval.hpp> + +template<typename IntervalT, bound_type PretendedBounds, + bound_type RepresentedBounds> +struct static_interval<IntervalT, true, PretendedBounds, RepresentedBounds> { + // types + typedef interval_traits< IntervalT >::domain_type domain_type; + + // public static functions + static IntervalT construct(const domain_type &, const domain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::static_interval<IntervalT, false, PretendedBounds, RepresentedBounds>
+// In header: <boost/icl/interval.hpp> + +template<typename IntervalT, bound_type PretendedBounds, + bound_type RepresentedBounds> +struct static_interval<IntervalT, false, PretendedBounds, RepresentedBounds> { + // types + typedef interval_traits< IntervalT >::domain_type domain_type; + + // public static functions + static IntervalT construct(const domain_type &, const domain_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::total_absorber
+// In header: <boost/icl/map.hpp> + + +struct total_absorber { + + enum @6 { absorbs_identities = true }; + + enum @7 { is_total = true }; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::total_enricher
+// In header: <boost/icl/map.hpp> + + +struct total_enricher { + + enum @8 { absorbs_identities = false }; + + enum @9 { is_total = true }; +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::closed_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::closed_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::closed_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::closed_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::closed_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::closed_interval< DomainT, Compare >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::closed_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::continuous_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::continuous_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::continuous_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::continuous_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::continuous_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::continuous_interval< DomainT, Compare >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::continuous_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::discrete_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::discrete_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::discrete_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::discrete_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::discrete_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::discrete_interval< DomainT, Compare >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::discrete_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::left_open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::left_open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::left_open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::left_open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::left_open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::left_open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct type_to_string<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct type_to_string<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct type_to_string<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct type_to_string<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct type_to_string<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >>
+// In header: <boost/icl/map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_ALLOC Alloc> +struct type_to_string<icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::right_open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::right_open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::right_open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::right_open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::right_open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct type_to_string<icl::right_open_interval< DomainT, Compare >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/separate_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >>
+// In header: <boost/icl/split_interval_map.hpp> + +template<typename DomainT, typename CodomainT, typename Traits, + ICL_COMPARE Compare, ICL_COMBINE Combine, ICL_SECTION Section, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::type_to_string<icl::split_interval_set< DomainT, Compare, Interval, Alloc >>
+// In header: <boost/icl/split_interval_set.hpp> + +template<typename DomainT, ICL_COMPARE Compare, + ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc> +struct type_to_string<icl::split_interval_set< DomainT, Compare, Interval, Alloc >> { + + // public static functions + static std::string apply(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::unit_element_based_inplace_combine
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct unit_element_based_inplace_combine { + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::unit_element_based_inplace_combine
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct unit_element_based_inplace_combine { + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::unit_element_based_inplace_combine
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct unit_element_based_inplace_combine { + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::unit_element_based_inplace_combine
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct unit_element_based_inplace_combine { + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::unit_element_based_inplace_combine
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct unit_element_based_inplace_combine { + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::unit_element_based_inplace_combine
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct unit_element_based_inplace_combine { + + // public static functions + static Type identity_element(); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::closed_interval< DomainT >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT> +struct value_size<icl::closed_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::closed_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::closed_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::closed_interval< DomainT >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT> +struct value_size<icl::closed_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::closed_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::closed_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::closed_interval< DomainT >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT> +struct value_size<icl::closed_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::closed_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::closed_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::closed_interval< DomainT >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT> +struct value_size<icl::closed_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::closed_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::closed_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::closed_interval< DomainT >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT> +struct value_size<icl::closed_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::closed_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::closed_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::closed_interval< DomainT >>
+// In header: <boost/icl/closed_interval.hpp> + +template<typename DomainT> +struct value_size<icl::closed_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::closed_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::closed_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::continuous_interval< DomainT >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT> +struct value_size<icl::continuous_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::continuous_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::continuous_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::continuous_interval< DomainT >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT> +struct value_size<icl::continuous_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::continuous_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::continuous_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::continuous_interval< DomainT >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT> +struct value_size<icl::continuous_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::continuous_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::continuous_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::continuous_interval< DomainT >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT> +struct value_size<icl::continuous_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::continuous_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::continuous_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::continuous_interval< DomainT >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT> +struct value_size<icl::continuous_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::continuous_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::continuous_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::continuous_interval< DomainT >>
+// In header: <boost/icl/continuous_interval.hpp> + +template<typename DomainT> +struct value_size<icl::continuous_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::continuous_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::continuous_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::discrete_interval< DomainT >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT> +struct value_size<icl::discrete_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::discrete_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::discrete_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::discrete_interval< DomainT >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT> +struct value_size<icl::discrete_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::discrete_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::discrete_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::discrete_interval< DomainT >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT> +struct value_size<icl::discrete_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::discrete_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::discrete_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::discrete_interval< DomainT >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT> +struct value_size<icl::discrete_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::discrete_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::discrete_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::discrete_interval< DomainT >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT> +struct value_size<icl::discrete_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::discrete_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::discrete_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::discrete_interval< DomainT >>
+// In header: <boost/icl/discrete_interval.hpp> + +template<typename DomainT> +struct value_size<icl::discrete_interval< DomainT >> { + + // public static functions + static std::size_t apply(const icl::discrete_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::discrete_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::left_open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::left_open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::left_open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::left_open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::left_open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::left_open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::left_open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::left_open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::left_open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::left_open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::left_open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::left_open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::left_open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::left_open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::left_open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::left_open_interval< DomainT, Compare >>
+// In header: <boost/icl/left_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::left_open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::left_open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::left_open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::open_interval< DomainT, Compare >>
+// In header: <boost/icl/open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::right_open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::right_open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::right_open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::right_open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::right_open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::right_open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::right_open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::right_open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::right_open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::right_open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::right_open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::right_open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::right_open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::right_open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::right_open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::value_size<icl::right_open_interval< DomainT, Compare >>
+// In header: <boost/icl/right_open_interval.hpp> + +template<typename DomainT, ICL_COMPARE Compare> +struct value_size<icl::right_open_interval< DomainT, Compare >> { + + // public static functions + static std::size_t apply(const icl::right_open_interval< DomainT > &); +};
value_size public static functionsstatic std::size_t apply(const icl::right_open_interval< DomainT > & value);
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version
+// In header: <boost/icl/functors.hpp> + +template<typename Combiner> +struct version : public boost::icl::conversion< Combiner > { + // types + typedef version< Combiner > type; + typedef conversion< Combiner > base_type; + typedef base_type::argument_type argument_type; + + // public member functions + argument_type operator()(const argument_type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< short >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< short >> { + + // public member functions + short operator()(short); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< int >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< int >> { + + // public member functions + int operator()(int); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long >> { + + // public member functions + long operator()(long); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long long >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long long >> { + + // public member functions + long long operator()(long long); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< float >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< float >> { + + // public member functions + float operator()(float); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< double >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< double >> { + + // public member functions + double operator()(double); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long double >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long double >> { + + // public member functions + long double operator()(long double); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct version<icl::inplace_minus< Type >> : public boost::icl::conversion< icl::inplace_minus< Type > > { + // types + typedef version< icl::inplace_minus< Type > > type; + typedef conversion< icl::inplace_minus< Type > > base_type; + typedef base_type::argument_type argument_type; + + // public member functions + Type operator()(const Type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< short >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< short >> { + + // public member functions + short operator()(short); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< int >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< int >> { + + // public member functions + int operator()(int); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long >> { + + // public member functions + long operator()(long); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long long >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long long >> { + + // public member functions + long long operator()(long long); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< float >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< float >> { + + // public member functions + float operator()(float); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< double >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< double >> { + + // public member functions + double operator()(double); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long double >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long double >> { + + // public member functions + long double operator()(long double); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct version<icl::inplace_minus< Type >> : public boost::icl::conversion< icl::inplace_minus< Type > > { + // types + typedef version< icl::inplace_minus< Type > > type; + typedef conversion< icl::inplace_minus< Type > > base_type; + typedef base_type::argument_type argument_type; + + // public member functions + Type operator()(const Type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< short >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< short >> { + + // public member functions + short operator()(short); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< int >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< int >> { + + // public member functions + int operator()(int); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long >> { + + // public member functions + long operator()(long); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long long >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long long >> { + + // public member functions + long long operator()(long long); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< float >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< float >> { + + // public member functions + float operator()(float); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< double >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< double >> { + + // public member functions + double operator()(double); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long double >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long double >> { + + // public member functions + long double operator()(long double); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct version<icl::inplace_minus< Type >> : public boost::icl::conversion< icl::inplace_minus< Type > > { + // types + typedef version< icl::inplace_minus< Type > > type; + typedef conversion< icl::inplace_minus< Type > > base_type; + typedef base_type::argument_type argument_type; + + // public member functions + Type operator()(const Type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< short >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< short >> { + + // public member functions + short operator()(short); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< int >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< int >> { + + // public member functions + int operator()(int); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long >> { + + // public member functions + long operator()(long); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long long >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long long >> { + + // public member functions + long long operator()(long long); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< float >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< float >> { + + // public member functions + float operator()(float); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< double >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< double >> { + + // public member functions + double operator()(double); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< short >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< short >> { + + // public member functions + short operator()(short); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long double >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long double >> { + + // public member functions + long double operator()(long double); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< int >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< int >> { + + // public member functions + int operator()(int); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct version<icl::inplace_minus< Type >> : public boost::icl::conversion< icl::inplace_minus< Type > > { + // types + typedef version< icl::inplace_minus< Type > > type; + typedef conversion< icl::inplace_minus< Type > > base_type; + typedef base_type::argument_type argument_type; + + // public member functions + Type operator()(const Type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long >> { + + // public member functions + long operator()(long); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long long >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long long >> { + + // public member functions + long long operator()(long long); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< float >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< float >> { + + // public member functions + float operator()(float); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< double >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< double >> { + + // public member functions + double operator()(double); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long double >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long double >> { + + // public member functions + long double operator()(long double); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct version<icl::inplace_minus< Type >> : public boost::icl::conversion< icl::inplace_minus< Type > > { + // types + typedef version< icl::inplace_minus< Type > > type; + typedef conversion< icl::inplace_minus< Type > > base_type; + typedef base_type::argument_type argument_type; + + // public member functions + Type operator()(const Type &); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< short >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< short >> { + + // public member functions + short operator()(short); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< int >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< int >> { + + // public member functions + int operator()(int); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long >> { + + // public member functions + long operator()(long); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long long >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long long >> { + + // public member functions + long long operator()(long long); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< float >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< float >> { + + // public member functions + float operator()(float); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< double >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< double >> { + + // public member functions + double operator()(double); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< long double >>
+// In header: <boost/icl/functors.hpp> + + +struct version<icl::inplace_minus< long double >> { + + // public member functions + long double operator()(long double); +};
| + | + |
![]() |
+Home | +Libraries | +People | +FAQ | +More | +
boost::icl::version<icl::inplace_minus< Type >>
+// In header: <boost/icl/functors.hpp> + +template<typename Type> +struct version<icl::inplace_minus< Type >> : public boost::icl::conversion< icl::inplace_minus< Type > > { + // types + typedef version< icl::inplace_minus< Type > > type; + typedef conversion< icl::inplace_minus< Type > > base_type; + typedef base_type::argument_type argument_type; + + // public member functions + Type operator()(const Type &); +};
| + | + |