boost::icl Namespace Reference

Namespaces
	detail
	interval_combine
	non_empty
	segmental

Classes
struct	absorbs_identities
struct	absorbs_identities< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
struct	absorbs_identities< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
struct	absorbs_identities< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > >
struct	absorbs_identities< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
class	add_iterator
	Performes an addition using a container's memberfunction add, when operator= is called. More...
struct	adds_inversely
struct	binary_template_to_string
class	bounded_value
class	closed_interval
struct	codomain_type_of
struct	combines_right_to_interval_container
struct	combines_right_to_interval_map
struct	combines_right_to_interval_set
class	content_is_identity_element
class	continuous_interval
struct	conversion
struct	difference
struct	difference_type_of
struct	difference_type_of< boost::gregorian::date >
struct	difference_type_of< boost::posix_time::ptime >
struct	difference_type_of< interval_traits< Type > >
class	discrete_interval
struct	distinct_equal
struct	domain_type_of
struct	domain_type_of< interval_traits< Type > >
struct	dynamic_interval_traits
struct	dynamic_interval_traits< boost::icl::continuous_interval< DomainT, Compare > >
struct	dynamic_interval_traits< boost::icl::discrete_interval< DomainT, Compare > >
struct	element_equal
struct	element_type_of
struct	get_codomain_type
struct	get_codomain_type< Type, false, false >
struct	get_codomain_type< Type, false, true >
struct	get_codomain_type< Type, true, is_std_set >
struct	get_difference_type
struct	get_difference_type< Type *, true, false >
struct	get_difference_type< Type, false, false >
struct	get_difference_type< Type, true, false >
struct	get_difference_type< Type, true, true >
struct	get_domain_type
struct	get_domain_type< Type, false >
struct	get_domain_type< Type, true >
struct	get_element_type
struct	get_element_type< Type, false >
struct	get_element_type< Type, true >
struct	get_infinity
struct	get_infinity< Type, false, false, false, false >
struct	get_infinity< Type, false, false, false, true >
struct	get_infinity< Type, false, false, true, has_diff >
struct	get_infinity< Type, false, true, has_size, has_diff >
struct	get_infinity< Type, true, has_repr_inf, has_size, has_diff >
struct	get_interval_type
struct	get_interval_type< Type, false >
struct	get_interval_type< Type, true >
struct	get_key_object_type
struct	get_key_object_type< Type, false, false >
struct	get_key_object_type< Type, false, true >
struct	get_key_object_type< Type, true, IsSet >
struct	get_key_type
struct	get_key_type< Type, false >
struct	get_key_type< Type, true >
struct	get_numeric_infinity
struct	get_numeric_infinity< Type, false, false >
struct	get_numeric_infinity< Type, false, true >
struct	get_numeric_infinity< Type, true, has_std_max >
struct	get_rep_type
struct	get_rep_type< Type, false >
struct	get_rep_type< Type, true >
struct	get_segment_type
struct	get_segment_type< Type, false >
struct	get_segment_type< Type, true >
struct	get_size_type
struct	get_size_type< Type, false, false, false >
struct	get_size_type< Type, false, false, true >
struct	get_size_type< Type, false, true, has_rep >
struct	get_size_type< Type, true, has_diff, has_rep >
struct	get_value_type
struct	get_value_type< Type, false >
struct	get_value_type< Type, true >
struct	has_asymmetric_bounds
struct	has_codomain_type
struct	has_difference
struct	has_difference< boost::gregorian::date >
struct	has_difference< boost::gregorian::date_duration >
struct	has_difference< boost::posix_time::ptime >
struct	has_difference< boost::posix_time::time_duration >
struct	has_difference_type
struct	has_domain_type
struct	has_dynamic_bounds
struct	has_element_type
struct	has_interval_type
struct	has_inverse
struct	has_inverse< boost::rational< Integral > >
struct	has_inverse< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
struct	has_inverse< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
struct	has_inverse< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > >
struct	has_inverse< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
struct	has_key_object_type
struct	has_key_type
struct	has_max_infinity
struct	has_rep_type
struct	has_same_concept
struct	has_segment_type
struct	has_set_semantics
struct	has_size_type
struct	has_static_bounds
struct	has_std_infinity
struct	has_symmetric_bounds
struct	has_value_type
struct	identity_based_inplace_combine
struct	identity_element
struct	identity_element< boost::gregorian::date_duration >
struct	infinity
struct	infinity< std::string >
struct	inplace_bit_add
struct	inplace_bit_and
struct	inplace_bit_subtract
struct	inplace_bit_xor
struct	inplace_caret
struct	inplace_erase
struct	inplace_erasure
struct	inplace_et
struct	inplace_identity
struct	inplace_insert
struct	inplace_max
struct	inplace_min
struct	inplace_minus
struct	inplace_plus
struct	inplace_slash
struct	inplace_star
class	insert_iterator
	Performes an insertion using a container's memberfunction add, when operator= is called. More...
struct	inter_section
struct	interval
class	interval_base_map
	Implements a map as a map of intervals (base class) More...
class	interval_base_set
	Implements a set as a set of intervals (base class) More...
struct	interval_bound_type
struct	interval_bound_type< closed_interval< DomainT, Compare > >
struct	interval_bound_type< continuous_interval< DomainT, Compare > >
struct	interval_bound_type< discrete_interval< DomainT, Compare > >
struct	interval_bound_type< left_open_interval< DomainT, Compare > >
struct	interval_bound_type< open_interval< DomainT, Compare > >
struct	interval_bound_type< right_open_interval< DomainT, Compare > >
class	interval_bounds
class	interval_map
	implements a map as a map of intervals - on insertion overlapping intervals are split and associated values are combined. More...
class	interval_set
	Implements a set as a set of intervals - merging adjoining intervals. More...
struct	interval_traits
struct	interval_traits< icl::closed_interval< DomainT, Compare > >
struct	interval_traits< icl::continuous_interval< DomainT, Compare > >
struct	interval_traits< icl::discrete_interval< DomainT, Compare > >
struct	interval_traits< icl::left_open_interval< DomainT, Compare > >
struct	interval_traits< icl::open_interval< DomainT, Compare > >
struct	interval_traits< icl::right_open_interval< DomainT, Compare > >
struct	interval_type_default
struct	interval_type_of
struct	inverse
struct	inverse< icl::inplace_bit_add< Type > >
struct	inverse< icl::inplace_bit_and< Type > >
struct	inverse< icl::inplace_bit_subtract< Type > >
struct	inverse< icl::inplace_bit_xor< Type > >
struct	inverse< icl::inplace_caret< Type > >
struct	inverse< icl::inplace_et< Type > >
struct	inverse< icl::inplace_identity< Type > >
struct	inverse< icl::inplace_max< Type > >
struct	inverse< icl::inplace_min< Type > >
struct	inverse< icl::inplace_minus< Type > >
struct	inverse< icl::inplace_plus< Type > >
struct	inverse< icl::inplace_slash< Type > >
struct	inverse< icl::inplace_star< Type > >
struct	inverse< icl::inter_section< Type > >
struct	is_associative_element_container
struct	is_asymmetric_interval
struct	is_binary_cross_combinable
struct	is_binary_inter_combinable
struct	is_binary_interval_map_combinable
struct	is_binary_interval_set_combinable
struct	is_binary_intra_combinable
struct	is_coarser_interval_map_companion
struct	is_coarser_interval_set_companion
struct	is_codomain_equal
struct	is_codomain_type_equal
struct	is_concept_combinable
struct	is_concept_compatible
struct	is_concept_equivalent
struct	is_container
struct	is_continuous
struct	is_continuous< boost::rational< Integral > >
struct	is_continuous_asymmetric
struct	is_continuous_interval
struct	is_continuous_interval< continuous_interval< DomainT, Compare > >
struct	is_continuous_left_open
struct	is_continuous_right_open
struct	is_continuous_static
struct	is_cross_combinable
struct	is_cross_derivative
struct	is_discrete
struct	is_discrete< boost::gregorian::date >
struct	is_discrete< boost::gregorian::date_duration >
struct	is_discrete< boost::posix_time::ptime >
struct	is_discrete< boost::posix_time::time_duration >
struct	is_discrete< boost::rational< Integral > >
struct	is_discrete_asymmetric
struct	is_discrete_interval
struct	is_discrete_interval< discrete_interval< DomainT, Compare > >
struct	is_discrete_static
struct	is_discrete_static_closed
struct	is_discrete_static_open
struct	is_element_container
struct	is_element_map
struct	is_element_set
struct	is_fixed_numeric
struct	is_fragment_of
struct	is_fragment_of< typename Type::element_type, Type >
struct	is_fragment_of< typename Type::segment_type, Type >
struct	is_icl_container
struct	is_increasing
struct	is_increasing< DomainT, std::greater< DomainT > >
struct	is_inter_combinable
struct	is_inter_derivative
struct	is_interval
struct	is_interval_container
struct	is_interval_container< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
struct	is_interval_container< icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc > >
struct	is_interval_container< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
struct	is_interval_container< icl::interval_set< DomainT, Compare, Interval, Alloc > >
struct	is_interval_container< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > >
struct	is_interval_container< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
struct	is_interval_container< icl::split_interval_set< DomainT, Compare, Interval, Alloc > >
struct	is_interval_joiner
struct	is_interval_joiner< icl::interval_set< DomainT, Compare, Interval, Alloc > >
struct	is_interval_map
struct	is_interval_map_companion
struct	is_interval_map_derivative
struct	is_interval_map_derivative< Type, typename Type::domain_mapping_type >
struct	is_interval_map_derivative< Type, typename Type::interval_mapping_type >
struct	is_interval_map_derivative< Type, typename Type::value_type >
struct	is_interval_map_right_cross_combinable
struct	is_interval_map_right_inter_combinable
struct	is_interval_map_right_intra_combinable
struct	is_interval_separator
struct	is_interval_separator< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > >
struct	is_interval_set
struct	is_interval_set_companion
struct	is_interval_set_derivative
struct	is_interval_set_derivative< Type, typename Type::domain_type >
struct	is_interval_set_derivative< Type, typename Type::interval_type >
struct	is_interval_set_right_combinable
struct	is_interval_splitter
struct	is_interval_splitter< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
struct	is_interval_splitter< icl::split_interval_set< DomainT, Compare, Interval, Alloc > >
struct	is_intra_combinable
struct	is_intra_derivative
struct	is_key_compare_equal
struct	is_key_container_of
struct	is_key_of
struct	is_key_of< typename Type::domain_type, Type >
struct	is_key_of< typename Type::interval_type, Type >
struct	is_map
struct	is_map< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
struct	is_map< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
struct	is_map< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > >
struct	is_map< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
struct	is_negative
struct	is_negative< icl::inplace_bit_subtract< Type > >
struct	is_negative< icl::inplace_minus< Type > >
struct	is_non_floating_point
struct	is_numeric
struct	is_numeric< boost::rational< Integral > >
struct	is_numeric< std::complex< Type > >
struct	is_overloadable
struct	is_right_inter_combinable
struct	is_right_intra_combinable
struct	is_set
struct	is_set< icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc > >
struct	is_set< icl::interval_set< DomainT, Compare, Interval, Alloc > >
struct	is_set< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > >
struct	is_set< icl::split_interval_set< DomainT, Compare, Interval, Alloc > >
struct	is_singelizable
struct	is_static_closed
struct	is_static_left_open
struct	is_static_open
struct	is_static_right_open
struct	is_std_integral
struct	is_std_numeric
struct	is_std_set
struct	is_strict_key_container_of
struct	is_subtraction_closed
struct	is_total
struct	is_total< icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
struct	is_total< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
struct	is_total< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > >
struct	is_total< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
struct	key_container_type_of
struct	key_type_of
struct	known_fineness
class	left_open_interval
class	map
	Addable, subractable and intersectable maps. More...
struct	mapping_pair
class	member_property
struct	no_type
struct	numeric_infinity
struct	numeric_minimum
struct	numeric_minimum< Type, std::greater< Type >, true >
struct	numeric_minimum< Type, std::less< Type >, true >
class	open_interval
struct	partial_absorber
struct	partial_enricher
struct	predecessor
class	property
class	relation
struct	rep_type_of
struct	represents
class	right_open_interval
struct	segment_type_of
struct	segmentational_fineness
class	separate_interval_set
	Implements a set as a set of intervals - leaving adjoining intervals separate. More...
struct	size
struct	size_type_of
struct	size_type_of< boost::gregorian::date >
struct	size_type_of< boost::gregorian::date_duration >
struct	size_type_of< boost::posix_time::ptime >
struct	size_type_of< boost::posix_time::time_duration >
struct	size_type_of< interval_traits< Type > >
class	split_interval_map
	implements a map as a map of intervals - on insertion overlapping intervals are split and associated values are combined. More...
class	split_interval_set
	implements a set as a set of intervals - on insertion overlapping intervals are split More...
struct	static_interval
struct	static_interval< IntervalT, false, PretendedBounds, RepresentedBounds >
struct	static_interval< IntervalT, true, PretendedBounds, RepresentedBounds >
struct	std_equal
struct	sub_super_set
	Functor class template contained_in implements the subset relation. More...
struct	successor
struct	super_sub_set
	Functor class template contains implements the superset relation. More...
struct	to_string
	Static class template for the string representation of values. More...
struct	total_absorber
struct	total_enricher
struct	type_to_string
struct	type_to_string< Binary< Type1, Type2 > >
struct	type_to_string< icl::closed_interval< DomainT, Compare > >
struct	type_to_string< icl::continuous_interval< DomainT, Compare > >
struct	type_to_string< icl::discrete_interval< DomainT, Compare > >
struct	type_to_string< icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
struct	type_to_string< icl::interval_set< DomainT, Compare, Interval, Alloc > >
struct	type_to_string< icl::left_open_interval< DomainT, Compare > >
struct	type_to_string< icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > >
struct	type_to_string< icl::open_interval< DomainT, Compare > >
struct	type_to_string< icl::right_open_interval< DomainT, Compare > >
struct	type_to_string< icl::separate_interval_set< DomainT, Compare, Interval, Alloc > >
struct	type_to_string< icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc > >
struct	type_to_string< icl::split_interval_set< DomainT, Compare, Interval, Alloc > >
struct	type_to_string< Unary< Type > >
struct	unary_template_to_string
struct	unit_element
struct	unit_element_based_inplace_combine
struct	unknown_fineness
struct	value_size
	static class template for the size of a type's value More...
struct	value_size< icl::closed_interval< DomainT > >
struct	value_size< icl::continuous_interval< DomainT > >
struct	value_size< icl::discrete_interval< DomainT > >
struct	value_size< icl::left_open_interval< DomainT, Compare > >
struct	value_size< icl::open_interval< DomainT, Compare > >
struct	value_size< icl::right_open_interval< DomainT, Compare > >
struct	value_type_of
struct	version
struct	version< icl::inplace_minus< double > >
struct	version< icl::inplace_minus< float > >
struct	version< icl::inplace_minus< int > >
struct	version< icl::inplace_minus< long > >
struct	version< icl::inplace_minus< long double > >
struct	version< icl::inplace_minus< long long > >
struct	version< icl::inplace_minus< short > >
struct	version< icl::inplace_minus< Type > >

Typedefs
typedef unsigned char	bound_type

Functions
template<class Type >
enable_if< is_icl_container < Type >, bool >::type	operator!= (const Type &left, const Type &right)
template<class Type >
enable_if< is_icl_container < Type >, bool >::type	operator> (const Type &left, const Type &right)
template<class Type >
enable_if< is_icl_container < Type >, bool >::type	operator<= (const Type &left, const Type &right)
	Partial ordering which is induced by Compare. More...
template<class Type >
enable_if< is_icl_container < Type >, bool >::type	operator>= (const Type &left, const Type &right)
template<class Type >
enable_if< is_container< Type > , bool >::type	is_empty (const Type &object)
	Tests if the container is empty. More...
template<class Type >
enable_if< is_container< Type > , void >::type	clear (Type &object)
	All content of the container is dropped. More...
template<class Type >
enable_if< mpl::and_ < is_container< Type > , mpl::not_< is_icl_container < Type > > >, std::size_t > ::type	iterative_size (const Type &object)
template<class Type >
enable_if< is_container< Type > , void >::type	swap (Type &left, Type &right)
template<class Type >
enable_if< is_container< Type > , typename Type::iterator > ::type	cyclic_prior (Type &object, typename Type::iterator it_)
template<class Type >
enable_if< is_container< Type > , typename Type::const_iterator >::type	cyclic_prior (const Type &object, typename Type::const_iterator it_)
template<class Type >
enable_if < is_element_container< Type > , std::size_t >::type	iterative_size (const Type &object)
template<class Type >
enable_if < is_associative_element_container < Type >, typename Type::size_type >::type	size (const Type &object)
template<class Type >
enable_if < is_associative_element_container < Type >, typename Type::size_type >::type	cardinality (const Type &object)
template<class Type >
enable_if < is_associative_element_container < Type >, bool >::type	within (const typename Type::key_type &key, const Type &super)
	Checks if a key is in the associative container. More...
template<class SubT , class SuperT >
enable_if< mpl::and_ < is_associative_element_container < SuperT > , is_key_container_of< SubT, SuperT > >, bool >::type	within (const SubT &sub, const SuperT &super)
template<class Type >
enable_if < is_associative_element_container < Type >, bool >::type	contains (const Type &super, const typename Type::key_type &key)
template<class SubT , class SuperT >
enable_if< mpl::and_ < is_associative_element_container < SuperT > , is_key_container_of< SubT, SuperT > >, bool >::type	contains (const SuperT &super, const SubT &sub)
template<class Type >
enable_if < is_associative_element_container < Type >, bool >::type	operator== (const Type &left, const Type &right)
	Standard equality, which is lexicographical equality of the sets as sequences, that are given by their Compare order. More...
template<class Type >
enable_if < is_associative_element_container < Type >, bool >::type	is_element_equal (const Type &left, const Type &right)
template<class Type >
enable_if < is_associative_element_container < Type >, bool >::type	operator< (const Type &left, const Type &right)
template<class LeftT , class RightT >
enable_if < is_concept_equivalent < is_element_container, LeftT, RightT >, int >::type	inclusion_compare (const LeftT &left, const RightT &right)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type &	operator+= (Type &object, const typename Type::value_type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type	operator+ (Type object, const typename Type::value_type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type	operator+ (const typename Type::value_type &operand, Type object)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type &	operator+= (Type &object, const Type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type	operator+ (Type object, const Type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type &	operator|= (Type &object, const typename Type::value_type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type	operator| (Type object, const typename Type::value_type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type	operator| (const typename Type::value_type &operand, Type object)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type &	operator|= (Type &object, const Type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type	operator| (Type object, const Type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, std::pair< typename Type::iterator, bool > >::type	insert (Type &object, const typename Type::value_type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, typename Type::iterator >::type	insert (Type &object, typename Type::iterator prior, const typename Type::value_type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type &	insert (Type &object, const Type &addend)
template<class Type >
enable_if < is_associative_element_container < Type >, typename Type::size_type >::type	erase (Type &object, const typename Type::key_type &key_value)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type &	erase (Type &object, const Type &erasure)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type &	operator-= (Type &object, const typename Type::value_type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type	operator- (Type object, const typename Type::value_type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type &	operator-= (Type &object, const Type &subtrahend)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type	operator- (Type object, const Type &subtrahend)
template<class Type >
enable_if < is_associative_element_container < Type >, void >::type	add_intersection (Type &section, const Type &object, const typename Type::key_type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, void >::type	add_intersection (Type &section, const Type &object, const typename key_container_type_of< Type >::type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type &	operator&= (Type &object, const typename Type::key_type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type	operator& (Type object, const typename Type::key_type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type	operator& (const typename Type::key_type &operand, Type object)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type &	operator&= (Type &object, const typename key_container_type_of< Type >::type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type	operator& (Type object, const Type &operand)
template<class Type , class CoType >
enable_if < is_associative_element_container < Type >, bool >::type	disjoint (const Type &left, const Type &right)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type	operator^ (Type object, const typename Type::value_type &operand)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type	operator^ (const typename Type::value_type &operand, Type object)
template<class Type >
enable_if < is_associative_element_container < Type >, Type >::type	operator^ (Type object, const Type &operand)
template<class Type , class Predicate >
enable_if < is_associative_element_container < Type >, Type >::type &	erase_if (const Predicate &pred, Type &object)
template<class Type , class Predicate >
enable_if < is_associative_element_container < Type >, Type >::type &	add_if (const Predicate &pred, Type &object, const Type &src)
template<class Type , class Predicate >
enable_if < is_associative_element_container < Type >, Type >::type &	assign_if (const Predicate &pred, Type &object, const Type &src)
template<class Type >
enable_if< is_element_map < Type >, bool >::type	within (const typename Type::element_type &value_pair, const Type &super)
	Checks if a key-value pair is in the map. More...
template<class Type >
enable_if< is_element_map < Type >, bool >::type	contains (const Type &super, const typename Type::element_type &value_pair)
template<class Type >
enable_if< is_element_map < Type >, bool >::type	is_distinct_equal (const Type &lhs, const Type &rhs)
	Protonic equality is equality on all elements that do not carry an identity element as content. More...
template<class Type >
enable_if< is_element_map < Type >, Type >::type &	add (Type &object, const typename Type::value_type &value_pair)
	add inserts value_pair into the map if it's key does not exist in the map. More...
template<class Type >
enable_if< is_element_map < Type >, typename Type::iterator >::type	add (Type &object, typename Type::iterator prior, const typename Type::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. More...
template<class Type >
enable_if< is_element_map < Type >, typename Type::size_type >::type	erase (Type &object, const typename Type::element_type &value_pair)
template<class Type >
enable_if< is_element_map < Type >, Type >::type &	erase (Type &object, const typename Type::set_type &erasure)
template<class Type >
enable_if< is_element_map < Type >, Type >::type &	subtract (Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< is_element_map < Type >, Type >::type &	subtract (Type &object, const typename Type::domain_type &key_value)
template<class Type >
enable_if< is_element_map < Type >, Type >::type &	operator-= (Type &object, const typename Type::set_type &operand)
template<class Type >
enable_if< is_element_map < Type >, Type >::type	operator- (Type object, const typename Type::set_type &subtrahend)
template<class Type >
enable_if< is_element_map < Type >, Type >::type &	set_at (Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< is_element_map < Type >, void >::type	add_intersection (Type &section, const Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< is_element_map < Type >, void >::type	add_intersection (Type &section, const Type &object, const Type &operand)
template<class Type >
enable_if< mpl::and_ < is_element_map< Type > , is_total< Type > >, Type > ::type &	operator&= (Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< mpl::and_ < is_element_map< Type > , mpl::not_< is_total< Type > > >, Type >::type &	operator&= (Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< is_element_map < Type >, Type >::type	operator& (Type object, const typename Type::element_type &operand)
template<class Type >
enable_if< is_element_map < Type >, Type >::type	operator& (const typename Type::element_type &operand, Type object)
template<class Type >
enable_if< mpl::and_ < is_element_map< Type > , is_total< Type > >, Type > ::type &	operator&= (Type &object, const Type &operand)
template<class Type >
enable_if< mpl::and_ < is_element_map< Type > , mpl::not_< is_total< Type > > >, Type >::type &	operator&= (Type &object, const Type &operand)
template<class Type >
enable_if< is_element_map < Type >, Type >::type	operator& (Type object, const typename Type::key_object_type &operand)
template<class Type >
enable_if< is_element_map < Type >, Type >::type	operator& (const typename Type::key_object_type &operand, Type object)
template<class Type , class CoType >
enable_if< mpl::and_ < is_element_map< Type > , is_total< Type > >, bool > ::type	intersects (const Type &, const CoType &)
template<class Type >
enable_if< mpl::and_ < is_element_map< Type > , mpl::not_< is_total< Type > > >, bool >::type	intersects (const Type &object, const typename Type::domain_type &operand)
template<class Type >
enable_if< mpl::and_ < is_element_map< Type > , mpl::not_< is_total< Type > > >, bool >::type	intersects (const Type &object, const typename Type::set_type &operand)
template<class Type >
enable_if< mpl::and_ < is_element_map< Type > , mpl::not_< is_total< Type > > >, bool >::type	intersects (const Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< mpl::and_ < is_element_map< Type > , mpl::not_< is_total< Type > > >, bool >::type	intersects (const Type &object, const Type &operand)
template<class Type >
enable_if< is_element_map < Type >, Type >::type &	flip (Type &object, const typename Type::element_type &operand)
template<class Type , class CoType >
enable_if< mpl::and_ < is_element_map< Type > , is_total< Type > , absorbs_identities< Type > >, Type >::type &	operator^= (Type &object, const CoType &)
template<class Type >
enable_if< mpl::and_ < is_element_map< Type > , is_total< Type >, mpl::not_ < absorbs_identities< Type > > >, Type >::type &	operator^= (Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< mpl::and_ < is_element_map< Type > , is_total< Type >, mpl::not_ < absorbs_identities< Type > > >, Type >::type &	operator^= (Type &object, const Type &operand)
template<class Type >
enable_if< mpl::and_ < is_element_map< Type > , mpl::not_< is_total< Type > > >, Type >::type &	operator^= (Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< mpl::and_ < is_element_map< Type > , mpl::not_< is_total< Type > > >, Type >::type &	operator^= (Type &object, const Type &operand)
template<class Type >
enable_if< is_element_map < Type >, typename Type::set_type >::type &	domain (typename Type::set_type &domain_set, const Type &object)
template<class Type >
enable_if< mpl::and_ < is_element_map< Type > , absorbs_identities< Type > >, Type >::type &	absorb_identities (Type &object)
template<class Type >
enable_if< mpl::and_ < is_element_map< Type > , mpl::not_ < absorbs_identities< Type > > >, Type >::type &	absorb_identities (Type &)
template<class CharType , class CharTraits , class Type >
enable_if< is_element_map < Type >, std::basic_ostream < CharType, CharTraits > >::type &	operator<< (std::basic_ostream< CharType, CharTraits > &stream, const Type &object)
template<class Type >
enable_if< is_element_set < Type >, Type >::type &	add (Type &object, const typename Type::value_type &operand)
	add inserts operand into the map if it's key does not exist in the map. More...
template<class Type >
enable_if< is_element_set < Type >, typename Type::iterator >::type	add (Type &object, typename Type::iterator prior, const typename Type::value_type &operand)
	add add operand into the map using prior as a hint to insert operand after the position prior is pointing to. More...
template<class Type >
enable_if< is_element_set < Type >, Type >::type &	subtract (Type &object, const typename Type::value_type &operand)
	If the operand's key value is in the map, it's data value is subtraced from the data value stored in the map. More...
template<class Type >
enable_if< is_element_set < Type >, bool >::type	intersects (const Type &object, const typename Type::key_type &operand)
template<class Type >
enable_if< is_element_set < Type >, bool >::type	intersects (const Type &object, const Type &operand)
template<class Type >
enable_if< is_element_set < Type >, Type >::type &	flip (Type &object, const typename Type::value_type &operand)
template<class Type >
enable_if< is_element_set < Type >, Type >::type &	operator^= (Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< is_element_set < Type >, Type >::type &	operator^= (Type &object, const Type &operand)
	Symmetric subtract map x2 and *this. More...
template<class CharType , class CharTraits , class Type >
enable_if< is_element_set < Type >, std::basic_ostream < CharType, CharTraits > >::type &	operator<< (std::basic_ostream< CharType, CharTraits > &stream, const Type &object)
template<class Type , class Iterator >
enable_if< is_element_set < Type >, const typename Type::key_type >::type &	co_value (Iterator it_)
template<class Type >
enable_if< is_interval< Type > , bool >::type	domain_less (const typename interval_traits< Type >::domain_type &left, const typename interval_traits< Type >::domain_type &right)
template<class Type >
enable_if< is_interval< Type > , bool >::type	domain_less_equal (const typename interval_traits< Type >::domain_type &left, const typename interval_traits< Type >::domain_type &right)
template<class Type >
enable_if< is_interval< Type > , bool >::type	domain_equal (const typename interval_traits< Type >::domain_type &left, const typename interval_traits< Type >::domain_type &right)
template<class Type >
enable_if< is_interval< Type > , typename interval_traits < Type >::domain_type >::type	domain_next (const typename interval_traits< Type >::domain_type value)
template<class Type >
enable_if< is_interval< Type > , typename interval_traits < Type >::domain_type >::type	domain_prior (const typename interval_traits< Type >::domain_type value)
template<class Type >
enable_if< mpl::and_ < is_static_right_open< Type > , is_discrete< typename interval_traits< Type > ::domain_type > >, Type > ::type	singleton (const typename interval_traits< Type >::domain_type &value)
template<class Type >
enable_if< mpl::and_ < is_static_left_open< Type > , is_discrete< typename interval_traits< Type > ::domain_type > >, Type > ::type	singleton (const typename interval_traits< Type >::domain_type &value)
template<class Type >
enable_if < is_discrete_static_open < Type >, Type >::type	singleton (const typename interval_traits< Type >::domain_type &value)
template<class Type >
enable_if < is_discrete_static_closed < Type >, Type >::type	singleton (const typename interval_traits< Type >::domain_type &value)
template<class Type >
enable_if< has_dynamic_bounds < Type >, Type >::type	singleton (const typename interval_traits< Type >::domain_type &value)
template<class Type >
enable_if< has_static_bounds < Type >, Type >::type	construct (const typename interval_traits< Type >::domain_type &low, const typename interval_traits< Type >::domain_type &up)
template<class Type >
enable_if< has_dynamic_bounds < Type >, Type >::type	construct (const typename interval_traits< Type >::domain_type &low, const typename interval_traits< Type >::domain_type &up, interval_bounds bounds=interval_bounds::right_open())
template<class Type >
enable_if< has_dynamic_bounds < Type >, Type >::type	construct (const typename Type::bounded_domain_type &low, const typename Type::bounded_domain_type &up)
template<class Type >
enable_if< is_interval< Type > , Type >::type	span (const typename interval_traits< Type >::domain_type &left, const typename interval_traits< Type >::domain_type &right)
template<class Type >
enable_if < is_static_right_open< Type > , Type >::type	hull (const typename interval_traits< Type >::domain_type &left, const typename interval_traits< Type >::domain_type &right)
template<class Type >
enable_if< is_static_left_open < Type >, Type >::type	hull (const typename interval_traits< Type >::domain_type &left, const typename interval_traits< Type >::domain_type &right)
template<class Type >
enable_if< is_static_closed < Type >, Type >::type	hull (const typename interval_traits< Type >::domain_type &left, const typename interval_traits< Type >::domain_type &right)
template<class Type >
enable_if< is_static_open < Type >, Type >::type	hull (const typename interval_traits< Type >::domain_type &left, const typename interval_traits< Type >::domain_type &right)
template<class Type >
enable_if< has_dynamic_bounds < Type >, Type >::type	hull (const typename interval_traits< Type >::domain_type &left, const typename interval_traits< Type >::domain_type &right)
template<class Type >
enable_if< is_interval< Type > , typename interval_traits < Type >::domain_type >::type	lower (const Type &object)
template<class Type >
enable_if< is_interval< Type > , typename interval_traits < Type >::domain_type >::type	upper (const Type &object)
template<class Type >
enable_if< mpl::or_ < is_static_right_open< Type > , is_static_closed< Type > >, typename interval_traits < Type >::domain_type >::type	first (const Type &object)
template<class Type >
enable_if< mpl::and_< mpl::or_ < is_static_left_open< Type > , is_static_open< Type > >, is_discrete< typename interval_traits< Type > ::domain_type > >, typename interval_traits< Type > ::domain_type >::type	first (const Type &object)
template<class Type >
enable_if < is_discrete_interval< Type > , typename interval_traits < Type >::domain_type >::type	first (const Type &object)
template<class Type >
enable_if< mpl::or_ < is_static_left_open< Type > , is_static_closed< Type > >, typename interval_traits < Type >::domain_type >::type	last (const Type &object)
template<class Type >
enable_if< mpl::and_< mpl::or_ < is_static_right_open< Type > , is_static_open< Type > >, is_discrete< typename interval_traits< Type > ::domain_type > >, typename interval_traits< Type > ::domain_type >::type	last (const Type &object)
template<class Type >
enable_if < is_discrete_interval< Type > , typename interval_traits < Type >::domain_type >::type	last (const Type &object)
template<class Type >
enable_if< mpl::and_< mpl::or_ < is_static_left_open< Type > , is_static_closed< Type > >, is_discrete< typename interval_traits< Type > ::domain_type > >, typename interval_traits< Type > ::domain_type >::type	last_next (const Type &object)
template<class Type >
enable_if< mpl::and_< mpl::or_ < is_static_right_open< Type > , is_static_open< Type > >, is_discrete< typename interval_traits< Type > ::domain_type > >, typename interval_traits< Type > ::domain_type >::type	last_next (const Type &object)
template<class Type >
enable_if < is_discrete_interval< Type > , typename interval_traits < Type >::domain_type >::type	last_next (const Type &object)
template<class Type >
enable_if< has_dynamic_bounds < Type >, typename Type::bounded_domain_type > ::type	bounded_lower (const Type &object)
template<class Type >
enable_if< has_dynamic_bounds < Type >, typename Type::bounded_domain_type > ::type	reverse_bounded_lower (const Type &object)
template<class Type >
enable_if< has_dynamic_bounds < Type >, typename Type::bounded_domain_type > ::type	bounded_upper (const Type &object)
template<class Type >
enable_if< has_dynamic_bounds < Type >, typename Type::bounded_domain_type > ::type	reverse_bounded_upper (const Type &object)
template<class Type >
enable_if< has_dynamic_bounds < Type >, interval_bounds > ::type	bounds (const Type &object)
template<class Type >
enable_if< has_static_bounds < Type >, interval_bounds > ::type	bounds (const Type &)
template<class Type >
boost::enable_if < is_asymmetric_interval< Type > , bool >::type	is_empty (const Type &object)
	Is the interval empty? More...
template<class Type >
boost::enable_if < is_static_closed< Type > , bool >::type	is_empty (const Type &object)
template<class Type >
boost::enable_if < is_static_open< Type >, bool > ::type	is_empty (const Type &object)
template<class Type >
boost::enable_if < is_discrete_interval< Type > , bool >::type	is_empty (const Type &object)
template<class Type >
boost::enable_if < is_continuous_interval< Type > , bool >::type	is_empty (const Type &object)
template<class Type >
boost::enable_if< is_interval < Type >, bool >::type	contains (const Type &super, const Type &sub)
template<class Type >
boost::enable_if < is_discrete_static< Type > , bool >::type	contains (const Type &super, const typename interval_traits< Type >::domain_type &element)
template<class Type >
boost::enable_if < is_continuous_left_open < Type >, bool >::type	contains (const Type &super, const typename interval_traits< Type >::domain_type &element)
template<class Type >
boost::enable_if < is_continuous_right_open < Type >, bool >::type	contains (const Type &super, const typename interval_traits< Type >::domain_type &element)
template<class Type >
boost::enable_if < has_dynamic_bounds< Type > , bool >::type	contains (const Type &super, const typename interval_traits< Type >::domain_type &element)
template<class Type >
boost::enable_if< is_interval < Type >, bool >::type	within (const Type &sub, const Type &super)
template<class Type >
boost::enable_if < is_asymmetric_interval< Type > , bool >::type	exclusive_less (const Type &left, const Type &right)
	Maximal element of left is less than the minimal element of right More...
template<class Type >
boost::enable_if < is_discrete_interval< Type > , bool >::type	exclusive_less (const Type &left, const Type &right)
template<class Type >
boost::enable_if < has_symmetric_bounds< Type > , bool >::type	exclusive_less (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_continuous_interval< Type > , bool >::type	exclusive_less (const Type &left, const Type &right)
template<class Type >
boost::enable_if < has_static_bounds< Type > , bool >::type	lower_less (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_discrete_interval< Type > , bool >::type	lower_less (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_continuous_interval< Type > , bool >::type	lower_less (const Type &left, const Type &right)
template<class Type >
boost::enable_if < has_static_bounds< Type > , bool >::type	upper_less (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_discrete_interval< Type > , bool >::type	upper_less (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_continuous_interval< Type > , bool >::type	upper_less (const Type &left, const Type &right)
template<class Type >
boost::enable_if < has_dynamic_bounds< Type > , typename Type::bounded_domain_type > ::type	lower_min (const Type &left, const Type &right)
template<class Type >
boost::enable_if < has_dynamic_bounds< Type > , typename Type::bounded_domain_type > ::type	lower_max (const Type &left, const Type &right)
template<class Type >
boost::enable_if < has_dynamic_bounds< Type > , typename Type::bounded_domain_type > ::type	upper_max (const Type &left, const Type &right)
template<class Type >
boost::enable_if < has_dynamic_bounds< Type > , typename Type::bounded_domain_type > ::type	upper_min (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_asymmetric_interval< Type > , bool >::type	lower_equal (const Type &left, const Type &right)
template<class Type >
boost::enable_if < has_symmetric_bounds< Type > , bool >::type	lower_equal (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_discrete_interval< Type > , bool >::type	lower_equal (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_continuous_interval< Type > , bool >::type	lower_equal (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_asymmetric_interval< Type > , bool >::type	upper_equal (const Type &left, const Type &right)
template<class Type >
boost::enable_if < has_symmetric_bounds< Type > , bool >::type	upper_equal (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_discrete_interval< Type > , bool >::type	upper_equal (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_continuous_interval< Type > , bool >::type	upper_equal (const Type &left, const Type &right)
template<class Type >
boost::enable_if< is_interval < Type >, bool >::type	lower_less_equal (const Type &left, const Type &right)
template<class Type >
boost::enable_if< is_interval < Type >, bool >::type	upper_less_equal (const Type &left, const Type &right)
template<class Type >
boost::enable_if< is_interval < Type >, bool >::type	operator== (const Type &left, const Type &right)
template<class Type >
boost::enable_if< is_interval < Type >, bool >::type	operator!= (const Type &left, const Type &right)
template<class Type >
boost::enable_if< is_interval < Type >, bool >::type	operator< (const Type &left, const Type &right)
template<class Type >
boost::enable_if< is_interval < Type >, bool >::type	operator> (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_asymmetric_interval< Type > , bool >::type	touches (const Type &left, const Type &right)
template<class Type >
boost::enable_if < has_symmetric_bounds< Type > , bool >::type	touches (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_discrete_interval< Type > , bool >::type	touches (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_continuous_interval< Type > , bool >::type	touches (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_continuous_interval< Type > , typename size_type_of < interval_traits< Type > >::type >::type	cardinality (const Type &object)
template<class Type >
boost::enable_if < is_discrete_interval< Type > , typename size_type_of < interval_traits< Type > >::type >::type	cardinality (const Type &object)
template<class Type >
boost::enable_if < is_continuous_asymmetric < Type >, typename size_type_of< interval_traits < Type > >::type >::type	cardinality (const Type &object)
template<class Type >
boost::enable_if < is_discrete_asymmetric< Type > , typename size_type_of < interval_traits< Type > >::type >::type	cardinality (const Type &object)
template<class Type >
boost::enable_if < has_symmetric_bounds< Type > , typename size_type_of < interval_traits< Type > >::type >::type	cardinality (const Type &object)
template<class Type >
enable_if< is_interval< Type > , typename size_type_of < interval_traits< Type > >::type >::type	size (const Type &object)
template<class Type >
boost::enable_if < is_continuous_interval< Type > , typename difference_type_of < interval_traits< Type > >::type >::type	length (const Type &object)
template<class Type >
boost::enable_if < is_discrete_interval< Type > , typename difference_type_of < interval_traits< Type > >::type >::type	length (const Type &object)
template<class Type >
boost::enable_if < is_continuous_asymmetric < Type >, typename difference_type_of < interval_traits< Type > >::type >::type	length (const Type &object)
template<class Type >
boost::enable_if < is_discrete_static< Type > , typename difference_type_of < interval_traits< Type > >::type >::type	length (const Type &object)
template<class Type >
enable_if< is_interval< Type > , typename size_type_of < interval_traits< Type > >::type >::type	iterative_size (const Type &)
template<class Type >
boost::enable_if < has_static_bounds< Type > , Type >::type	hull (Type left, const Type &right)
	hull returns the smallest interval containing left and right. More...
template<class Type >
boost::enable_if < has_dynamic_bounds< Type > , Type >::type	hull (Type left, const Type &right)
template<class Type >
boost::enable_if < is_asymmetric_interval< Type > , Type >::type	left_subtract (Type right, const Type &left_minuend)
	subtract left_minuend from the right interval on it's left side. More...
template<class Type >
boost::enable_if < is_static_closed< Type > , Type >::type	left_subtract (Type right, const Type &left_minuend)
template<class Type >
boost::enable_if < is_static_open< Type >, Type > ::type	left_subtract (Type right, const Type &left_minuend)
template<class Type >
boost::enable_if < has_dynamic_bounds< Type > , Type >::type	left_subtract (Type right, const Type &left_minuend)
template<class Type >
boost::enable_if < is_asymmetric_interval< Type > , Type >::type	right_subtract (Type left, const Type &right_minuend)
	subtract right_minuend from the left interval on it's right side. More...
template<class Type >
boost::enable_if < is_static_closed< Type > , Type >::type	right_subtract (Type left, const Type &right_minuend)
template<class Type >
boost::enable_if < is_static_open< Type >, Type > ::type	right_subtract (Type left, const Type &right_minuend)
template<class Type >
boost::enable_if < has_dynamic_bounds< Type > , Type >::type	right_subtract (Type left, const Type &right_minuend)
template<class Type >
boost::enable_if < is_asymmetric_interval< Type > , Type >::type	operator& (Type left, const Type &right)
	Returns the intersection of left and right interval. More...
template<class Type >
boost::enable_if < has_symmetric_bounds< Type > , Type >::type	operator& (Type left, const Type &right)
template<class Type >
boost::enable_if < has_dynamic_bounds< Type > , Type >::type	operator& (Type left, const Type &right)
template<class Type >
boost::enable_if< is_interval < Type >, bool >::type	intersects (const Type &left, const Type &right)
template<class Type >
boost::enable_if< is_interval < Type >, bool >::type	disjoint (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_asymmetric_interval< Type > , Type >::type	inner_complement (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_discrete_static_closed < Type >, Type >::type	inner_complement (const Type &left, const Type &right)
template<class Type >
boost::enable_if < is_discrete_static_open < Type >, Type >::type	inner_complement (const Type &left, const Type &right)
template<class Type >
boost::enable_if < has_dynamic_bounds< Type > , Type >::type	inner_complement (const Type &left, const Type &right)
template<class Type >
boost::enable_if< is_interval < Type >, Type >::type	between (const Type &left, const Type &right)
template<class Type >
boost::enable_if< mpl::and_ < is_interval< Type > , has_difference< typename interval_traits< Type > ::domain_type >, is_discrete < typename interval_traits < Type >::domain_type > >, typename difference_type_of < interval_traits< Type > >::type >::type	distance (const Type &x1, const Type &x2)
template<class Type >
boost::enable_if< mpl::and_ < is_interval< Type > , has_difference< typename interval_traits< Type > ::domain_type >, is_continuous < typename interval_traits < Type >::domain_type > >, typename difference_type_of < interval_traits< Type > >::type >::type	distance (const Type &x1, const Type &x2)
template<class Type >
boost::enable_if< mpl::or_ < is_static_left_open< Type > , is_static_open< Type > >, std::string >::type	left_bracket (const Type &)
template<class Type >
boost::enable_if< mpl::or_ < is_static_right_open< Type > , is_static_closed< Type > >, std::string >::type	left_bracket (const Type &)
template<class Type >
boost::enable_if < has_dynamic_bounds< Type > , std::string >::type	left_bracket (const Type &object)
template<class Type >
boost::enable_if< mpl::or_ < is_static_right_open< Type > , is_static_open< Type > >, std::string >::type	right_bracket (const Type &)
template<class Type >
boost::enable_if< mpl::or_ < is_static_left_open< Type > , is_static_closed< Type > >, std::string >::type	right_bracket (const Type &)
template<class Type >
boost::enable_if < has_dynamic_bounds< Type > , std::string >::type	right_bracket (const Type &object)
template<class CharType , class CharTraits , class Type >
boost::enable_if< is_interval < Type >, std::basic_ostream < CharType, CharTraits > >::type &	operator<< (std::basic_ostream< CharType, CharTraits > &stream, Type const &object)
template<class SubT , class SuperT >
enable_if < is_interval_container < SuperT >, bool >::type	within (const SubT &sub, const SuperT &super)
template<class Type >
enable_if < is_interval_container< Type > , bool >::type	operator== (const Type &left, const Type &right)
template<class Type >
enable_if < is_interval_container< Type > , bool >::type	operator< (const Type &left, const Type &right)
template<class LeftT , class RightT >
enable_if< is_intra_combinable < LeftT, RightT >, bool > ::type	is_element_equal (const LeftT &left, const RightT &right)
	Returns true, if left and right contain the same elements. More...
template<class LeftT , class RightT >
enable_if< is_intra_combinable < LeftT, RightT >, bool > ::type	is_element_less (const LeftT &left, const RightT &right)
	Returns true, if left is lexicographically less than right. More...
template<class LeftT , class RightT >
enable_if< is_intra_combinable < LeftT, RightT >, bool > ::type	is_element_greater (const LeftT &left, const RightT &right)
	Returns true, if left is lexicographically greater than right. More...
template<class LeftT , class RightT >
enable_if< is_inter_combinable < LeftT, RightT >, int >::type	inclusion_compare (const LeftT &left, const RightT &right)
template<class LeftT , class RightT >
enable_if < is_concept_compatible < is_interval_map, LeftT, RightT >, bool >::type	is_distinct_equal (const LeftT &left, const RightT &right)
template<class Type >
enable_if < is_interval_container< Type > , std::size_t >::type	iterative_size (const Type &object)
template<class Type >
enable_if< mpl::and_ < is_interval_container< Type > , is_discrete< typename Type::domain_type > >, typename Type::size_type > ::type	cardinality (const Type &object)
template<class Type >
enable_if< mpl::and_ < is_interval_container< Type > , mpl::not_< is_discrete < typename Type::domain_type > > >, typename Type::size_type > ::type	cardinality (const Type &object)
template<class Type >
enable_if < is_interval_container< Type > , typename Type::size_type > ::type	size (const Type &object)
template<class Type >
enable_if < is_interval_container< Type > , typename Type::difference_type >::type	length (const Type &object)
template<class Type >
enable_if < is_interval_container< Type > , std::size_t >::type	interval_count (const Type &object)
template<class Type >
enable_if < is_interval_container< Type > , typename Type::difference_type >::type	distance (const Type &object)
template<class Type >
enable_if < is_interval_container< Type > , typename Type::interval_type > ::type	hull (const Type &object)
template<class Type >
enable_if < is_interval_container< Type > , typename domain_type_of < Type >::type >::type	lower (const Type &object)
template<class Type >
enable_if < is_interval_container< Type > , typename domain_type_of < Type >::type >::type	upper (const Type &object)
template<class Type >
enable_if< mpl::and_ < is_interval_container< Type > , is_discrete< typename domain_type_of< Type >::type > >, typename domain_type_of < Type >::type >::type	first (const Type &object)
template<class Type >
enable_if< mpl::and_ < is_interval_container< Type > , is_discrete< typename domain_type_of< Type >::type > >, typename domain_type_of < Type >::type >::type	last (const Type &object)
template<class Type , class OperandT >
enable_if< is_intra_derivative < Type, OperandT >, Type > ::type &	operator+= (Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if< is_intra_combinable < Type, OperandT >, Type > ::type &	operator+= (Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if < is_binary_intra_combinable < Type, OperandT >, Type > ::type	operator+ (const Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if < is_binary_intra_combinable < Type, OperandT >, Type > ::type	operator+ (Type &&object, const OperandT &operand)
template<class Type , class OperandT >
enable_if < is_binary_intra_combinable < Type, OperandT >, Type > ::type	operator+ (const OperandT &operand, const Type &object)
template<class Type , class OperandT >
enable_if < is_binary_intra_combinable < Type, OperandT >, Type > ::type	operator+ (const OperandT &operand, Type &&object)
template<class Type >
enable_if < is_interval_container< Type > , Type >::type	operator+ (const Type &object, const Type &operand)
template<class Type >
enable_if < is_interval_container< Type > , Type >::type	operator+ (Type &&object, const Type &operand)
template<class Type >
enable_if < is_interval_container< Type > , Type >::type	operator+ (const Type &operand, Type &&object)
template<class Type >
enable_if < is_interval_container< Type > , Type >::type	operator+ (Type &&object, Type &&operand)
template<class Type , class OperandT >
enable_if < is_right_intra_combinable < Type, OperandT >, Type > ::type &	operator|= (Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if < is_binary_intra_combinable < Type, OperandT >, Type > ::type	operator| (const Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if < is_binary_intra_combinable < Type, OperandT >, Type > ::type	operator| (Type &&object, const OperandT &operand)
template<class Type , class OperandT >
enable_if < is_binary_intra_combinable < Type, OperandT >, Type > ::type	operator| (const OperandT &operand, const Type &object)
template<class Type , class OperandT >
enable_if < is_binary_intra_combinable < Type, OperandT >, Type > ::type	operator| (const OperandT &operand, Type &&object)
template<class Type >
enable_if < is_interval_container< Type > , Type >::type	operator| (const Type &object, const Type &operand)
template<class Type >
enable_if < is_interval_container< Type > , Type >::type	operator| (Type &&object, const Type &operand)
template<class Type >
enable_if < is_interval_container< Type > , Type >::type	operator| (const Type &operand, Type &&object)
template<class Type >
enable_if < is_interval_container< Type > , Type >::type	operator| (Type &&object, Type &&operand)
template<class Type , class OperandT >
enable_if< is_intra_combinable < Type, OperandT >, Type > ::type &	insert (Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if < combines_right_to_interval_container < Type, OperandT >, Type > ::type &	erase (Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if < is_concept_compatible < is_interval_map, Type, OperandT >, Type >::type &	operator-= (Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if< is_intra_derivative < Type, OperandT >, Type > ::type &	operator-= (Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if< is_cross_derivative < Type, OperandT >, Type > ::type &	operator-= (Type &object, const OperandT &operand)
template<class Type , class IntervalSetT >
enable_if < combines_right_to_interval_set < Type, IntervalSetT >, Type > ::type &	operator-= (Type &object, const IntervalSetT &operand)
template<class Type , class OperandT >
enable_if < is_right_inter_combinable < Type, OperandT >, Type > ::type	operator- (const Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if < is_right_inter_combinable < Type, OperandT >, Type > ::type	operator- (Type &&object, const OperandT &operand)
template<class Type , class OperandT >
enable_if< mpl::and_ < is_interval_set< Type > , combines_right_to_interval_set < Type, OperandT > >, void > ::type	add_intersection (Type &section, const Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if < is_right_inter_combinable < Type, OperandT >, Type > ::type &	operator&= (Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if < is_binary_inter_combinable < Type, OperandT >, Type > ::type	operator& (const Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if < is_binary_inter_combinable < Type, OperandT >, Type > ::type	operator& (Type &&object, const OperandT &operand)
template<class Type , class OperandT >
enable_if < is_binary_inter_combinable < Type, OperandT >, Type > ::type	operator& (const OperandT &operand, const Type &object)
template<class Type , class OperandT >
enable_if < is_binary_inter_combinable < Type, OperandT >, Type > ::type	operator& (const OperandT &operand, Type &&object)
template<class Type >
enable_if < is_interval_container< Type > , Type >::type	operator& (const Type &object, const Type &operand)
template<class Type >
enable_if < is_interval_container< Type > , Type >::type	operator& (Type &&object, const Type &operand)
template<class Type >
enable_if < is_interval_container< Type > , Type >::type	operator& (const Type &operand, Type &&object)
template<class Type >
enable_if < is_interval_container< Type > , Type >::type	operator& (Type &&object, Type &&operand)
template<class Type , class CoType >
enable_if< mpl::and_ < is_interval_container< Type > , boost::is_same< CoType, typename domain_type_of< Type > ::type > >, bool >::type	intersects (const Type &left, const CoType &right)
template<class Type , class CoType >
enable_if< mpl::and_ < is_interval_container< Type > , boost::is_same< CoType, typename interval_type_of < Type >::type > >, bool > ::type	intersects (const Type &left, const CoType &right)
template<class LeftT , class RightT >
enable_if< mpl::and_ < is_intra_combinable< LeftT, RightT >, mpl::or_< is_total < LeftT >, is_total< RightT > > >, bool >::type	intersects (const LeftT &, const RightT &)
template<class LeftT , class RightT >
enable_if< mpl::and_ < is_intra_combinable< LeftT, RightT >, mpl::not_< mpl::or_ < is_total< LeftT >, is_total < RightT > > > >, bool >::type	intersects (const LeftT &left, const RightT &right)
template<class LeftT , class RightT >
enable_if< is_cross_combinable < LeftT, RightT >, bool > ::type	intersects (const LeftT &left, const RightT &right)
template<class LeftT , class RightT >
enable_if< is_inter_combinable < LeftT, RightT >, bool > ::type	disjoint (const LeftT &left, const RightT &right)
	Returns true, if left and right have no common elements. More...
template<class Type , class AssociateT >
enable_if< is_inter_derivative < Type, AssociateT >, bool > ::type	disjoint (const Type &left, const AssociateT &right)
	Returns true, if left and right have no common elements. More...
template<class Type , class OperandT >
enable_if< is_intra_combinable < Type, OperandT >, Type > ::type &	operator^= (Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if< is_intra_derivative < Type, OperandT >, Type > ::type &	operator^= (Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if < is_binary_intra_combinable < Type, OperandT >, Type > ::type	operator^ (const Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if < is_binary_intra_combinable < Type, OperandT >, Type > ::type	operator^ (Type &&object, const OperandT &operand)
template<class Type , class OperandT >
enable_if < is_binary_intra_combinable < Type, OperandT >, Type > ::type	operator^ (const OperandT &operand, const Type &object)
template<class Type , class OperandT >
enable_if < is_binary_intra_combinable < Type, OperandT >, Type > ::type	operator^ (const OperandT &operand, Type &&object)
template<class Type >
enable_if < is_interval_container< Type > , Type >::type	operator^ (const Type &object, const Type &operand)
template<class Type >
enable_if < is_interval_container< Type > , Type >::type	operator^ (Type &&object, const Type &operand)
template<class Type >
enable_if < is_interval_container< Type > , Type >::type	operator^ (const Type &operand, Type &&object)
template<class Type >
enable_if < is_interval_container< Type > , Type >::type	operator^ (Type &&object, Type &&operand)
template<class Type >
enable_if< mpl::and_ < is_interval_container< Type > , mpl::not_ < is_continuous_interval < typename Type::interval_type > > >, typename Type::element_iterator >::type	elements_begin (Type &object)
template<class Type >
enable_if< mpl::and_ < is_interval_container< Type > , mpl::not_ < is_continuous_interval < typename Type::interval_type > > >, typename Type::element_iterator >::type	elements_end (Type &object)
template<class Type >
enable_if< mpl::and_ < is_interval_container< Type > , mpl::not_ < is_continuous_interval < typename Type::interval_type > > >, typename Type::element_const_iterator > ::type	elements_begin (const Type &object)
template<class Type >
enable_if< mpl::and_ < is_interval_container< Type > , mpl::not_ < is_continuous_interval < typename Type::interval_type > > >, typename Type::element_const_iterator > ::type	elements_end (const Type &object)
template<class Type >
enable_if< mpl::and_ < is_interval_container< Type > , mpl::not_ < is_continuous_interval < typename Type::interval_type > > >, typename Type::element_reverse_iterator > ::type	elements_rbegin (Type &object)
template<class Type >
enable_if< mpl::and_ < is_interval_container< Type > , mpl::not_ < is_continuous_interval < typename Type::interval_type > > >, typename Type::element_reverse_iterator > ::type	elements_rend (Type &object)
template<class Type >
enable_if< mpl::and_ < is_interval_container< Type > , mpl::not_ < is_continuous_interval < typename Type::interval_type > > >, typename Type::element_const_reverse_iterator > ::type	elements_rbegin (const Type &object)
template<class Type >
enable_if< mpl::and_ < is_interval_container< Type > , mpl::not_ < is_continuous_interval < typename Type::interval_type > > >, typename Type::element_const_reverse_iterator > ::type	elements_rend (const Type &object)
template<class Type >
enable_if< mpl::and_ < is_interval_container< Type > , is_discrete< typename domain_type_of< Type >::type > >, typename Type::const_iterator >::type	find (const Type &object, const typename domain_type_of< Type >::type &key_val)
template<class Type >
enable_if< mpl::and_ < is_interval_container< Type > , is_continuous< typename domain_type_of< Type >::type > , has_dynamic_bounds< typename interval_type_of< Type >::type > >, typename Type::const_iterator >::type	find (const Type &object, const typename domain_type_of< Type >::type &key_val)
template<class Type >
enable_if< mpl::and_ < is_interval_container< Type > , is_continuous< typename domain_type_of< Type >::type > , is_static_right_open < typename interval_type_of < Type >::type > , boost::detail::is_incrementable < typename domain_type_of < Type >::type > >, typename Type::const_iterator >::type	find (const Type &object, const typename domain_type_of< Type >::type &key_val)
template<class Type >
enable_if< mpl::and_ < is_interval_container< Type > , is_continuous< typename domain_type_of< Type >::type > , is_static_left_open < typename interval_type_of < Type >::type > , boost::detail::is_incrementable < typename domain_type_of < Type >::type > >, typename Type::const_iterator >::type	find (const Type &object, const typename domain_type_of< Type >::type &key_val)
template<class Type >
enable_if < is_interval_container< Type > , typename Type::const_iterator >::type	find (const Type &object, const typename interval_type_of< Type >::type &inter_val)
template<class Type >
enable_if < is_interval_container< Type > , Type >::type &	join (Type &object)
interval_bounds	left (interval_bounds x1)
interval_bounds	right (interval_bounds x1)
interval_bounds	all (interval_bounds x1)
bool	operator== (const interval_bounds x1, const interval_bounds x2)
bool	operator!= (const interval_bounds x1, const interval_bounds x2)
interval_bounds	operator& (interval_bounds x1, interval_bounds x2)
interval_bounds	operator| (interval_bounds x1, interval_bounds x2)
interval_bounds	operator<< (interval_bounds bounds, unsigned int shift)
interval_bounds	operator>> (interval_bounds bounds, unsigned int shift)
interval_bounds	operator~ (interval_bounds x1)
interval_bounds	outer_bounds (interval_bounds x1, interval_bounds x2)
interval_bounds	inner_bounds (interval_bounds x1, interval_bounds x2)
interval_bounds	left_bounds (interval_bounds x1, interval_bounds x2)
interval_bounds	right_bounds (interval_bounds x1, interval_bounds x2)
interval_bounds	left_subtract_bounds (interval_bounds x1, interval_bounds x2)
interval_bounds	right_subtract_bounds (interval_bounds x1, interval_bounds x2)
bool	is_complementary (interval_bounds x1)
bool	is_left_closed (interval_bounds bounds)
bool	is_right_closed (interval_bounds bounds)
std::string	left_bracket (interval_bounds bounds)
std::string	right_bracket (interval_bounds bounds)
template<class Type >
enable_if< is_discrete< Type > , Type >::type	shift_lower (interval_bounds decl, interval_bounds repr, const Type &low)
template<class Type >
enable_if< is_discrete< Type > , Type >::type	shift_upper (interval_bounds decl, interval_bounds repr, const Type &up)
template<class CharType , class CharTraits >
std::basic_ostream< CharType, CharTraits > &	operator<< (std::basic_ostream< CharType, CharTraits > &stream, interval_bounds const &object)
template<class IntervalT >
boost::enable_if < has_dynamic_bounds < IntervalT >, interval_bounds > ::type	outer_bounds (const IntervalT &x1, const IntervalT &x2)
template<class IntervalT >
boost::enable_if < has_dynamic_bounds < IntervalT >, interval_bounds > ::type	inner_bounds (const IntervalT &x1, const IntervalT &x2)
template<class IntervalT >
boost::enable_if < has_dynamic_bounds < IntervalT >, interval_bounds > ::type	left_bounds (const IntervalT &x1, const IntervalT &x2)
template<class IntervalT >
boost::enable_if < has_dynamic_bounds < IntervalT >, interval_bounds > ::type	right_bounds (const IntervalT &x1, const IntervalT &x2)
template<class IntervalT >
boost::enable_if < has_dynamic_bounds < IntervalT >, interval_bounds > ::type	left_subtract_bounds (const IntervalT &x1, const IntervalT &x2)
template<class IntervalT >
boost::enable_if < has_dynamic_bounds < IntervalT >, interval_bounds > ::type	right_subtract_bounds (const IntervalT &x1, const IntervalT &x2)
template<class Type >
enable_if< is_interval_map < Type >, typename Type::segment_type >::type	make_segment (const typename Type::element_type &element)
template<class Type >
enable_if< is_interval_map < Type >, bool >::type	contains (const Type &super, const typename Type::element_type &key_value_pair)
template<class Type >
enable_if< is_interval_map < Type >, bool >::type	contains (const Type &super, const typename Type::segment_type &sub_segment)
template<class Type , class CoType >
enable_if < is_concept_compatible < is_interval_map, Type, CoType >, bool >::type	contains (const Type &super, const CoType &sub)
template<class Type , class CoType >
enable_if< mpl::and_ < is_interval_map< Type > , is_total< Type > , is_cross_derivative< Type, CoType > >, bool >::type	contains (const Type &, const CoType &)
template<class Type >
enable_if< mpl::and_ < is_interval_map< Type > , mpl::not_< is_total< Type > > >, bool >::type	contains (const Type &super, const typename Type::domain_type &key)
template<class Type >
enable_if< mpl::and_ < is_interval_map< Type > , mpl::not_< is_total< Type > > >, bool >::type	contains (const Type &super, const typename Type::interval_type &sub_interval)
template<class Type , class KeyT >
enable_if< mpl::and_ < is_concept_combinable < is_interval_map, is_interval_set, Type, KeyT > , mpl::not_< is_total< Type > > >, bool >::type	contains (const Type &super, const KeyT &sub)
template<class Type >
enable_if< is_interval_map < Type >, Type >::type &	add (Type &object, const typename Type::segment_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, Type >::type &	add (Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, typename Type::iterator >::type	add (Type &object, typename Type::iterator prior_, const typename Type::segment_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, Type >::type &	insert (Type &object, const typename Type::segment_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, Type >::type &	insert (Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, typename Type::iterator >::type	insert (Type &object, typename Type::iterator prior, const typename Type::segment_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, Type >::type &	erase (Type &object, const typename Type::interval_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, Type >::type &	erase (Type &object, const typename Type::domain_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, Type >::type &	erase (Type &object, const typename Type::segment_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, Type >::type &	erase (Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, Type >::type &	subtract (Type &object, const typename Type::segment_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, Type >::type &	subtract (Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, Type >::type &	subtract (Type &object, const typename Type::domain_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, Type >::type &	subtract (Type &object, const typename Type::interval_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, Type >::type &	set_at (Type &object, const typename Type::segment_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, Type >::type &	set_at (Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, void >::type	add_intersection (Type &section, const Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, void >::type	add_intersection (Type &section, const Type &object, const typename Type::segment_type &operand)
template<class Type , class MapT >
enable_if< mpl::and_< is_total < Type > , is_concept_compatible < is_interval_map, Type, MapT > >, void >::type	add_intersection (Type &section, const Type &object, const MapT &operand)
template<class Type , class MapT >
enable_if< mpl::and_ < mpl::not_< is_total< Type > >, is_concept_compatible < is_interval_map, Type, MapT > >, void >::type	add_intersection (Type &section, const Type &object, const MapT &operand)
template<class Type >
enable_if< is_interval_map < Type >, void >::type	add_intersection (Type &section, const Type &object, const typename Type::domain_type &key_value)
template<class Type >
enable_if< is_interval_map < Type >, void >::type	add_intersection (Type &section, const Type &object, const typename Type::interval_type &inter_val)
template<class Type , class KeySetT >
enable_if < is_concept_combinable < is_interval_map, is_interval_set, Type, KeySetT > , void >::type	add_intersection (Type &section, const Type &object, const KeySetT &key_set)
template<class Type , class OperandT >
enable_if< mpl::and_ < is_interval_map< Type > , is_total< Type > , boost::is_same< OperandT, typename segment_type_of< Type > ::type > >, bool >::type	intersects (const Type &, const OperandT &)
template<class Type , class OperandT >
enable_if< mpl::and_ < is_interval_map< Type > , mpl::not_< is_total< Type > >, boost::is_same< OperandT, typename segment_type_of< Type > ::type > >, bool >::type	intersects (const Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if< mpl::and_ < is_interval_map< Type > , boost::is_same< OperandT, typename element_type_of< Type > ::type > >, bool >::type	intersects (const Type &object, const OperandT &operand)
template<class Type >
enable_if< is_interval_map < Type >, Type >::type &	flip (Type &object, const typename Type::segment_type &operand)
template<class Type >
enable_if< is_interval_map < Type >, Type >::type &	flip (Type &object, const typename Type::element_type &operand)
template<class Type , class OperandT >
enable_if< mpl::and_< is_total < Type >, absorbs_identities < Type > , is_concept_compatible < is_interval_map, Type, OperandT > >, Type >::type &	flip (Type &object, const OperandT &)
template<class Type , class OperandT >
enable_if< mpl::and_< is_total < Type >, mpl::not_ < absorbs_identities< Type > >, is_concept_compatible < is_interval_map, Type, OperandT > >, Type >::type &	flip (Type &object, const OperandT &operand)
template<class Type , class OperandT >
enable_if< mpl::and_ < mpl::not_< is_total< Type > >, is_concept_compatible < is_interval_map, Type, OperandT > >, Type >::type &	flip (Type &object, const OperandT &operand)
template<class Type , class SetT >
enable_if < is_concept_combinable < is_interval_set, is_interval_map, SetT, Type > , SetT >::type &	domain (SetT &result, const Type &object)
template<class Type , class SetT >
enable_if < is_concept_combinable < is_interval_set, is_interval_map, SetT, Type > , SetT >::type &	between (SetT &in_between, const Type &object)
template<class MapT , class Predicate >
enable_if< is_interval_map < MapT >, MapT >::type &	erase_if (const Predicate &pred, MapT &object)
template<class MapT , class Predicate >
enable_if< is_interval_map < MapT >, MapT >::type &	add_if (const Predicate &pred, MapT &object, const MapT &src)
template<class MapT , class Predicate >
enable_if< is_interval_map < MapT >, MapT >::type &	assign_if (const Predicate &pred, MapT &object, const MapT &src)
template<class Type >
enable_if< mpl::and_ < is_interval_map< Type > , absorbs_identities< Type > >, Type >::type &	absorb_identities (Type &object)
template<class Type >
enable_if< mpl::and_ < is_interval_map< Type > , mpl::not_ < absorbs_identities< Type > > >, Type >::type &	absorb_identities (Type &object)
template<class CharType , class CharTraits , class Type >
enable_if< is_interval_map < Type >, std::basic_ostream < CharType, CharTraits > >::type &	operator<< (std::basic_ostream< CharType, CharTraits > &stream, const Type &object)
template<class Type >
enable_if< is_interval_set < Type >, bool >::type	contains (const Type &super, const typename Type::element_type &element)
template<class Type >
enable_if< is_interval_set < Type >, bool >::type	contains (const Type &super, const typename Type::segment_type &inter_val)
template<class Type , class OperandT >
enable_if< has_same_concept < is_interval_set, Type, OperandT >, bool >::type	contains (const Type &super, const OperandT &sub)
template<class Type >
enable_if< is_interval_set < Type >, Type >::type &	add (Type &object, const typename Type::segment_type &operand)
template<class Type >
enable_if< is_interval_set < Type >, Type >::type &	add (Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< is_interval_set < Type >, typename Type::iterator >::type	add (Type &object, typename Type::iterator prior, const typename Type::segment_type &operand)
template<class Type >
enable_if< is_interval_set < Type >, Type >::type &	insert (Type &object, const typename Type::segment_type &operand)
template<class Type >
enable_if< is_interval_set < Type >, Type >::type &	insert (Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< is_interval_set < Type >, typename Type::iterator >::type	insert (Type &object, typename Type::iterator prior, const typename Type::segment_type &operand)
template<class Type >
enable_if< is_interval_set < Type >, Type >::type &	subtract (Type &object, const typename Type::segment_type &operand)
template<class Type >
enable_if< is_interval_set < Type >, Type >::type &	subtract (Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< is_interval_set < Type >, Type >::type &	erase (Type &object, const typename Type::segment_type &minuend)
template<class Type >
enable_if< is_interval_set < Type >, Type >::type &	erase (Type &object, const typename Type::element_type &minuend)
template<class Type >
enable_if< is_interval_set < Type >, void >::type	add_intersection (Type &section, const Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< is_interval_set < Type >, void >::type	add_intersection (Type &section, const Type &object, const typename Type::segment_type &segment)
template<class Type >
enable_if< is_interval_set < Type >, Type >::type &	flip (Type &object, const typename Type::element_type &operand)
template<class Type >
enable_if< is_interval_set < Type >, Type >::type &	flip (Type &object, const typename Type::segment_type &segment)
template<class Type , class OperandT >
enable_if < is_concept_compatible < is_interval_set, Type, OperandT >, Type >::type &	flip (Type &object, const OperandT &operand)
template<class Type >
enable_if< is_interval_set < Type >, Type >::type &	domain (Type &dom, const Type &object)
template<class Type >
enable_if< is_interval_set < Type >, Type >::type &	between (Type &in_between, const Type &object)
template<class CharType , class CharTraits , class Type >
enable_if< is_interval_set < Type >, std::basic_ostream < CharType, CharTraits > >::type &	operator<< (std::basic_ostream< CharType, CharTraits > &stream, const Type &object)
template<class Type , class Iterator >
enable_if< is_interval_set < Type >, typename Type::codomain_type >::type	co_value (Iterator value_)
template<class Type , class Iterator >
enable_if< is_map< Type > , const typename Type::key_type >::type &	key_value (Iterator it_)
template<class Type , class Iterator >
enable_if< is_map< Type > , const typename Type::codomain_type >::type &	co_value (Iterator it_)
template<class Type >
enable_if< is_map< Type > , typename Type::value_type > ::type	make_value (const typename Type::key_type &key_val, const typename Type::codomain_type &co_val)
template<class Type , class Iterator >
enable_if< is_set< Type > , const typename Type::key_type >::type &	key_value (Iterator it_)
template<class Type >
enable_if< is_set< Type > , typename Type::value_type > ::type	make_value (const typename Type::key_type &key_val, const typename codomain_type_of< Type >::type &)
boost::gregorian::date	operator++ (boost::gregorian::date &x)
boost::gregorian::date	operator-- (boost::gregorian::date &x)
boost::gregorian::date_duration	operator++ (boost::gregorian::date_duration &x)
boost::gregorian::date_duration	operator-- (boost::gregorian::date_duration &x)
template<class ContainerT , typename IteratorT >
add_iterator< ContainerT >	adder (ContainerT &cont, IteratorT iter_)
	Function adder creates and initializes an add_iterator. More...
template<class ContainerT , typename IteratorT >
insert_iterator< ContainerT >	inserter (ContainerT &cont, IteratorT iter_)
	Function inserter creates and initializes an insert_iterator. More...
boost::posix_time::ptime	operator++ (boost::posix_time::ptime &x)
boost::posix_time::ptime	operator-- (boost::posix_time::ptime &x)
boost::posix_time::time_duration	operator++ (boost::posix_time::time_duration &x)
boost::posix_time::time_duration	operator-- (boost::posix_time::time_duration &x)
template<typename Type >
Type	abs (Type val)

Typedef Documentation

typedef unsigned char boost::icl::bound_type

Function Documentation

template<typename Type >

Type boost::icl::abs

(

Type

val

)

References boost::phoenix::val().

Referenced by boost::icl::value_size< Type >::apply().

template<class Type >

enable_if<mpl::and_< is_element_map<Type> , absorbs_identities<Type> >, Type>::type& boost::icl::absorb_identities ( Type &  object )

inline

References erase_if().

template<class Type >

enable_if<mpl::and_< is_element_map<Type> , mpl::not_<absorbs_identities<Type> > > , Type>::type& boost::icl::absorb_identities ( Type &  )

inline

template<class Type >

enable_if<mpl::and_< is_interval_map<Type> , absorbs_identities<Type> >, Type>::type& boost::icl::absorb_identities

(

Type &

object

)

template<class Type >

enable_if<mpl::and_< is_interval_map<Type> , mpl::not_<absorbs_identities<Type> > >, Type>::type& boost::icl::absorb_identities

(

Type &

object

)

References erase_if().

template<class Type >

enable_if<is_element_set<Type>, Type>::type& boost::icl::add	(	Type &	object,
		const typename Type::value_type &	operand
	)

add inserts operand into the map if it's key does not exist in the map.

If operands's key value exists in the map, it's data value is added to the data value already found in the map.

template<class Type >

enable_if<is_element_set<Type>, typename Type::iterator>::type boost::icl::add	(	Type &	object,
		typename Type::iterator	prior,
		const typename Type::value_type &	operand
	)

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

template<class Type >

enable_if<is_interval_set<Type>, Type>::type& boost::icl::add	(	Type &	object,
		const typename Type::segment_type &	operand
	)

template<class Type >

enable_if<is_interval_set<Type>, Type>::type& boost::icl::add ( Type &  object, const typename Type::element_type &  operand  )

inline

References add().

template<class Type >

enable_if<is_element_map<Type>, Type>::type& boost::icl::add	(	Type &	object,
		const typename Type::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.

Referenced by boost::spirit::qi::tst< Char, T >::add(), boost::spirit::x3::tst< Char, T >::add(), boost::spirit::x3::tst_map< Char, T >::add(), boost::spirit::qi::tst_map< Char, T >::add(), add(), boost::icl::interval_base_set< split_interval_set< DomainT, Compare, Interval, Alloc >, DomainT, Compare, Interval, Alloc >::add(), boost::icl::interval_base_map< interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::add(), add_if(), add_intersection(), boost::icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::assign(), boost::icl::interval_set< DomainT, Compare, Interval, Alloc >::assign(), boost::wave::util::time_conversion::time_conversion_grammar::definition< ScannerT >::definition(), boost::random::linear_congruential_engine< IntType, a, c, m >::discard(), flip(), insert(), boost::icl::interval_base_set< split_interval_set< DomainT, Compare, Interval, Alloc >, DomainT, Compare, Interval, Alloc >::insert(), boost::icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::interval_map(), boost::icl::interval_set< DomainT, Compare, Interval, Alloc >::interval_set(), boost::circular_buffer< Sample >::linearize(), boost::heap::skew_heap< T, A0, A1, A2, A3, A4, A5, A6 >::merge(), boost::heap::pairing_heap< T, A0, A1, A2, A3, A4 >::merge(), boost::heap::fibonacci_heap< T, A0, A1, A2, A3, A4 >::merge(), operator+=(), boost::icl::add_iterator< ContainerT >::operator=(), boost::circular_buffer< Sample >::operator[](), operator|=(), boost::icl::separate_interval_set< DomainT, Compare, Interval, Alloc >::separate_interval_set(), boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::split_interval_map(), and boost::icl::split_interval_set< DomainT, Compare, Interval, Alloc >::split_interval_set().

template<class Type >

enable_if<is_interval_set<Type>, typename Type::iterator>::type boost::icl::add ( Type &  object, typename Type::iterator  prior, const typename Type::segment_type &  operand  )

inline

template<class Type >

enable_if<is_element_map<Type>, typename Type::iterator>::type boost::icl::add	(	Type &	object,
		typename Type::iterator	prior,
		const typename Type::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.

template<class Type >

enable_if<is_interval_map<Type>, Type>::type& boost::icl::add	(	Type &	object,
		const typename Type::segment_type &	operand
	)

template<class Type >

enable_if<is_interval_map<Type>, Type>::type& boost::icl::add	(	Type &	object,
		const typename Type::element_type &	operand
	)

References add().

template<class Type >

enable_if<is_interval_map<Type>, typename Type::iterator >::type boost::icl::add	(	Type &	object,
		typename Type::iterator	prior_,
		const typename Type::segment_type &	operand
	)

template<class Type , class Predicate >

enable_if<is_associative_element_container<Type>, Type>::type& boost::icl::add_if ( const Predicate &  pred, Type &  object, const Type &  src  )

inline

References add().

Referenced by assign_if().

template<class MapT , class Predicate >

enable_if<is_interval_map<MapT>, MapT>::type& boost::icl::add_if ( const Predicate &  pred, MapT &  object, const MapT &  src  )

inline

References add().

template<class Type >

enable_if<is_interval_set<Type>, void>::type boost::icl::add_intersection	(	Type &	section,
		const Type &	object,
		const typename Type::element_type &	operand
	)

References add(), boost::end, and find().

template<class Type >

enable_if<is_interval_set<Type>, void>::type boost::icl::add_intersection	(	Type &	section,
		const Type &	object,
		const typename Type::segment_type &	segment
	)

References is_empty().

template<class Type >

enable_if<is_element_map<Type>, void>::type boost::icl::add_intersection ( Type &  section, const Type &  object, const typename Type::element_type &  operand  )

inline

template<class Type >

enable_if<is_element_map<Type>, void>::type boost::icl::add_intersection ( Type &  section, const Type &  object, const Type &  operand  )

inline

References add_intersection().

template<class Type >

enable_if<is_interval_map<Type>, void>::type boost::icl::add_intersection	(	Type &	section,
		const Type &	object,
		const typename Type::element_type &	operand
	)

template<class Type >

enable_if<is_interval_map<Type>, void>::type boost::icl::add_intersection	(	Type &	section,
		const Type &	object,
		const typename Type::segment_type &	operand
	)

template<class Type , class MapT >

enable_if< mpl::and_< is_total<Type> , is_concept_compatible<is_interval_map, Type, MapT> > , void>::type boost::icl::add_intersection	(	Type &	section,
		const Type &	object,
		const MapT &	operand
	)

template<class Type , class MapT >

enable_if< mpl::and_< mpl::not_<is_total<Type> > , is_concept_compatible<is_interval_map, Type, MapT> > , void>::type boost::icl::add_intersection	(	Type &	section,
		const Type &	object,
		const MapT &	operand
	)

References add_intersection().

template<class Type >

enable_if<is_associative_element_container<Type>, void>::type boost::icl::add_intersection ( Type &  section, const Type &  object, const typename Type::key_type &  operand  )

inline

References add(), and boost::end.

Referenced by boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::add_intersection(), add_intersection(), boost::icl::interval_base_map< interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::add_intersection(), intersects(), and operator&=().

template<class Type >

enable_if<is_interval_map<Type>, void>::type boost::icl::add_intersection	(	Type &	section,
		const Type &	object,
		const typename Type::domain_type &	key_value
	)

References add(), boost::end, and find().

template<class Type >

enable_if<is_associative_element_container<Type>, void>::type boost::icl::add_intersection ( Type &  section, const Type &  object, const typename key_container_type_of< Type >::type &  operand  )

inline

References add_intersection().

template<class Type >

enable_if<is_interval_map<Type>, void>::type boost::icl::add_intersection	(	Type &	section,
		const Type &	object,
		const typename Type::interval_type &	inter_val
	)

References add(), and is_empty().

template<class Type , class KeySetT >

enable_if<is_concept_combinable<is_interval_map, is_interval_set, Type, KeySetT>, void>::type boost::icl::add_intersection	(	Type &	section,
		const Type &	object,
		const KeySetT &	key_set
	)

References add_intersection(), and is_empty().

template<class Type , class OperandT >

enable_if<mpl::and_<is_interval_set<Type>, combines_right_to_interval_set<Type, OperandT> >, void>::type boost::icl::add_intersection	(	Type &	section,
		const Type &	object,
		const OperandT &	operand
	)

References add_intersection().

template<class ContainerT , typename IteratorT >

add_iterator<ContainerT> boost::icl::adder ( ContainerT &  cont, IteratorT  iter_  )

inline

Function adder creates and initializes an add_iterator.

interval_bounds boost::icl::all ( interval_bounds  x1 )

inline

References boost::icl::interval_bounds::_bits.

Referenced by operator~().

template<class Type , class Predicate >

enable_if<is_associative_element_container<Type>, Type>::type& boost::icl::assign_if ( const Predicate &  pred, Type &  object, const Type &  src  )

inline

References add_if(), and clear().

template<class MapT , class Predicate >

enable_if<is_interval_map<MapT>, MapT>::type& boost::icl::assign_if ( const Predicate &  pred, MapT &  object, const MapT &  src  )

inline

References add_if(), and clear().

template<class Type >

enable_if<is_interval_set<Type>, Type>::type& boost::icl::between	(	Type &	in_between,
		const Type &	object
	)

References between(), boost::end, and insert().

template<class Type , class SetT >

enable_if<is_concept_combinable<is_interval_set, is_interval_map, SetT, Type>, SetT>::type& boost::icl::between	(	SetT &	in_between,
		const Type &	object
	)

References between(), boost::end, first(), and insert().

template<class Type >

boost::enable_if<is_interval<Type>, Type>::type boost::icl::between ( const Type &  left, const Type &  right  )

inline

References inner_complement().

Referenced by between().

template<class Type >

enable_if<has_dynamic_bounds<Type>, typename Type::bounded_domain_type>::type boost::icl::bounded_lower

(

const Type &

object

)

References bounds(), left(), and lower().

Referenced by lower_max(), lower_min(), and right_subtract().

template<class Type >

enable_if<has_dynamic_bounds<Type>, typename Type::bounded_domain_type>::type boost::icl::bounded_upper

(

const Type &

object

)

References bounds(), right(), and upper().

Referenced by left_subtract(), upper_max(), and upper_min().

template<class Type >

enable_if<has_dynamic_bounds<Type>, interval_bounds>::type boost::icl::bounds ( const Type &  object )

inline

Referenced by bounded_lower(), bounded_upper(), cardinality(), boost::icl::dynamic_interval_traits< boost::icl::continuous_interval< DomainT, Compare > >::construct(), construct(), first(), is_empty(), last(), last_next(), left_bracket(), reverse_bounded_lower(), reverse_bounded_upper(), and right_bracket().

template<class Type >

enable_if<has_static_bounds<Type>, interval_bounds>::type boost::icl::bounds ( const Type &  )

inline

template<class Type >

enable_if<is_associative_element_container<Type>, typename Type::size_type>::type boost::icl::cardinality

(

const Type &

object

)

References iterative_size().

Referenced by cardinality(), boost::icl::interval_base_set< split_interval_set< DomainT, Compare, Interval, Alloc >, DomainT, Compare, Interval, Alloc >::size(), boost::icl::interval_base_map< interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::size(), and size().

template<class Type >

enable_if< mpl::and_< is_interval_container<Type> , is_discrete<typename Type::domain_type> >, typename Type::size_type>::type boost::icl::cardinality

(

const Type &

object

)

References cardinality(), boost::it, size(), and boost::icl::identity_element< Type >::value().

template<class Type >

enable_if< mpl::and_< is_interval_container<Type> , mpl::not_<is_discrete<typename Type::domain_type> > >, typename Type::size_type>::type boost::icl::cardinality

(

const Type &

object

)

References cardinality(), boost::it, size(), and boost::icl::identity_element< Type >::value().

template<class Type >

boost::enable_if<is_continuous_interval<Type>, typename size_type_of<interval_traits<Type> >::type>::type boost::icl::cardinality

(

const Type &

object

)

References bounds(), boost::icl::interval_bounds::closed(), is_empty(), lower(), upper(), boost::icl::identity_element< Type >::value(), boost::icl::unit_element< Type >::value(), and boost::icl::infinity< Type >::value().

template<class Type >

boost::enable_if<is_discrete_interval<Type>, typename size_type_of<interval_traits<Type> >::type>::type boost::icl::cardinality

(

const Type &

object

)

References first(), is_empty(), last_next(), and boost::icl::identity_element< Type >::value().

template<class Type >

boost::enable_if<is_continuous_asymmetric<Type>, typename size_type_of<interval_traits<Type> >::type>::type boost::icl::cardinality

(

const Type &

object

)

References is_empty(), boost::icl::identity_element< Type >::value(), and boost::icl::infinity< Type >::value().

template<class Type >

boost::enable_if<is_discrete_asymmetric<Type>, typename size_type_of<interval_traits<Type> >::type>::type boost::icl::cardinality

(

const Type &

object

)

References first(), is_empty(), last_next(), and boost::icl::identity_element< Type >::value().

template<class Type >

boost::enable_if<has_symmetric_bounds<Type>, typename size_type_of<interval_traits<Type> >::type>::type boost::icl::cardinality

(

const Type &

object

)

References first(), is_empty(), last_next(), and boost::icl::identity_element< Type >::value().

template<class Type >

enable_if<is_container<Type>, void>::type boost::icl::clear

(

Type &

object

)

All content of the container is dropped.

Complexity: linear.

References boost::spirit::traits::begin(), and boost::end.

Referenced by boost::icl::split_interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::assign(), boost::icl::interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::assign(), boost::icl::split_interval_set< DomainT, Compare, Interval, Alloc >::assign(), boost::icl::separate_interval_set< DomainT, Compare, Interval, Alloc >::assign(), boost::icl::interval_set< DomainT, Compare, Interval, Alloc >::assign(), assign_if(), boost::icl::interval_base_set< split_interval_set< DomainT, Compare, Interval, Alloc >, DomainT, Compare, Interval, Alloc >::clear(), boost::icl::interval_base_map< interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::clear(), and operator^=().

template<class Type , class Iterator >

enable_if<is_element_set<Type>, const typename Type::key_type>::type& boost::icl::co_value ( Iterator  it_ )

inline

template<class Type , class Iterator >

enable_if<is_interval_set<Type>, typename Type::codomain_type>::type boost::icl::co_value ( Iterator  value_ )

inline

References is_empty().

template<class Type , class Iterator >

enable_if<is_map<Type>, const typename Type::codomain_type>::type& boost::icl::co_value ( Iterator  it_ )

inline

template<class Type >

enable_if<has_static_bounds<Type>, Type>::type boost::icl::construct	(	const typename interval_traits< Type >::domain_type &	low,
		const typename interval_traits< Type >::domain_type &	up
	)

References boost::icl::interval_traits< Type >::construct().

Referenced by boost::allocate_shared(), boost::sinks::basic_event_log_backend< CharT >::basic_event_log_backend(), BOOST_PHOENIX_DEFINE_EXPRESSION_VARARG(), boost::python::objects::make_instance_impl< T, Holder, make_ptr_instance< T, Holder > >::execute(), boost::python::implicitly_convertible(), phoenix::operator<<(), phoenix::operator>>(), and boost::statechart::state_machine< MostDerived, InitialState, Allocator, ExceptionTranslator >::store_deep_history().

template<class Type >

enable_if<has_dynamic_bounds<Type>, Type>::type boost::icl::construct	(	const typename interval_traits< Type >::domain_type &	low,
		const typename interval_traits< Type >::domain_type &	up,
		interval_bounds	bounds = interval_bounds::right_open()
	)

References bounds(), and boost::icl::dynamic_interval_traits< Type >::construct().

template<class Type >

enable_if<has_dynamic_bounds<Type>, Type>::type boost::icl::construct	(	const typename Type::bounded_domain_type &	low,
		const typename Type::bounded_domain_type &	up
	)

References boost::icl::dynamic_interval_traits< Type >::construct_bounded().

template<class Type >

enable_if<is_interval_set<Type>, bool>::type boost::icl::contains	(	const Type &	super,
		const typename Type::element_type &	element
	)

References find().

template<class Type >

enable_if<is_interval_set<Type>, bool>::type boost::icl::contains	(	const Type &	super,
		const typename Type::segment_type &	inter_val
	)

References contains(), cyclic_prior(), hull(), is_empty(), and boost::icl::segmental::is_joinable().

template<class Type >

enable_if<is_interval_map<Type>, bool>::type boost::icl::contains	(	const Type &	super,
		const typename Type::element_type &	key_value_pair
	)

References find().

template<class Type >

enable_if<is_interval_map<Type>, bool>::type boost::icl::contains	(	const Type &	super,
		const typename Type::segment_type &	sub_segment
	)

References contains(), hull(), is_empty(), boost::icl::segmental::is_joinable(), and boost::prior().

template<class Type >

enable_if<is_element_map<Type>, bool>::type boost::icl::contains	(	const Type &	super,
		const typename Type::element_type &	value_pair
	)

References within().

template<class Type , class OperandT >

enable_if<has_same_concept<is_interval_set, Type, OperandT>, bool>::type boost::icl::contains	(	const Type &	super,
		const OperandT &	sub
	)

template<class Type , class CoType >

enable_if<is_concept_compatible<is_interval_map, Type, CoType>, bool>::type boost::icl::contains	(	const Type &	super,
		const CoType &	sub
	)

References boost::geometry::within().

template<class Type , class CoType >

enable_if< mpl::and_< is_interval_map<Type> , is_total<Type> , is_cross_derivative<Type, CoType> > , bool>::type boost::icl::contains	(	const Type &	,
		const CoType &
	)

template<class Type >

enable_if<is_associative_element_container<Type>, bool>::type boost::icl::contains	(	const Type &	super,
		const typename Type::key_type &	key
	)

References within().

Referenced by contains(), boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::contains(), find(), flip(), intersects(), boost::icl::sub_super_set< Type >::operator()(), boost::icl::super_sub_set< Type >::operator()(), boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::within(), and within().

template<class Type >

enable_if< mpl::and_< is_interval_map<Type> , mpl::not_<is_total<Type> > > , bool>::type boost::icl::contains	(	const Type &	super,
		const typename Type::domain_type &	key
	)

References find().

template<class SubT , class SuperT >

enable_if<mpl::and_< is_associative_element_container<SuperT> , is_key_container_of<SubT, SuperT> >, bool>::type boost::icl::contains	(	const SuperT &	super,
		const SubT &	sub
	)

References within().

template<class Type >

enable_if< mpl::and_< is_interval_map<Type> , mpl::not_<is_total<Type> > > , bool>::type boost::icl::contains	(	const Type &	super,
		const typename Type::interval_type &	sub_interval
	)

References contains(), hull(), is_empty(), boost::icl::segmental::is_joinable(), and boost::prior().

template<class Type , class KeyT >

enable_if< mpl::and_< is_concept_combinable<is_interval_map, is_interval_set, Type, KeyT> , mpl::not_<is_total<Type> > > , bool>::type boost::icl::contains	(	const Type &	super,
		const KeyT &	sub
	)

References boost::geometry::within().

template<class Type >

boost::enable_if<is_interval<Type>, bool>::type boost::icl::contains ( const Type &  super, const Type &  sub  )

inline

References boost::icl::non_empty::contains(), and is_empty().

template<class Type >

boost::enable_if<is_discrete_static<Type>, bool>::type boost::icl::contains	(	const Type &	super,
		const typename interval_traits< Type >::domain_type &	element
	)

References first(), and last().

template<class Type >

boost::enable_if<is_continuous_left_open<Type>, bool>::type boost::icl::contains	(	const Type &	super,
		const typename interval_traits< Type >::domain_type &	element
	)

References lower(), and upper().

template<class Type >

boost::enable_if<is_continuous_right_open<Type>, bool>::type boost::icl::contains	(	const Type &	super,
		const typename interval_traits< Type >::domain_type &	element
	)

References lower(), and upper().

template<class Type >

boost::enable_if<has_dynamic_bounds<Type>, bool>::type boost::icl::contains	(	const Type &	super,
		const typename interval_traits< Type >::domain_type &	element
	)

References is_left_closed(), is_right_closed(), lower(), and upper().

template<class Type >

enable_if<is_container<Type>, typename Type::iterator>::type boost::icl::cyclic_prior	(	Type &	object,
		typename Type::iterator	it_
	)

Referenced by boost::icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::add_front(), boost::icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::add_rear(), contains(), and boost::icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase().

template<class Type >

enable_if<is_container<Type>, typename Type::const_iterator>::type boost::icl::cyclic_prior	(	const Type &	object,
		typename Type::const_iterator	it_
	)

template<class Type , class CoType >

enable_if<is_associative_element_container<Type>, bool>::type boost::icl::disjoint ( const Type &  left, const Type &  right  )

inline

References intersects().

template<class LeftT , class RightT >

enable_if<is_inter_combinable<LeftT, RightT>, bool>::type boost::icl::disjoint	(	const LeftT &	left,
		const RightT &	right
	)

Returns true, if left and right have no common elements.

Intervals are interpreted as sequence of elements. Complexity: loglinear, if left and right are interval containers.

References intersects().

template<class Type , class AssociateT >

enable_if<is_inter_derivative<Type, AssociateT>, bool>::type boost::icl::disjoint	(	const Type &	left,
		const AssociateT &	right
	)

Returns true, if left and right have no common elements.

Intervals are interpreted as sequence of elements. Complexity: logarithmic, if AssociateT is an element type Type::element_type. linear, if AssociateT is a segment type Type::segment_type.

References intersects().

template<class Type >

boost::enable_if<is_interval<Type>, bool>::type boost::icl::disjoint	(	const Type &	left,
		const Type &	right
	)

References exclusive_less(), and is_empty().

template<class Type >

enable_if< is_interval_container<Type> , typename Type::difference_type >::type boost::icl::distance

(

const Type &

object

)

References distance(), boost::end, and boost::icl::identity_element< Type >::value().

template<class Type >

boost:: enable_if< mpl::and_< is_interval<Type> , has_difference<typename interval_traits<Type>::domain_type> , is_discrete<typename interval_traits<Type>::domain_type> > , typename difference_type_of<interval_traits<Type> >::type>::type boost::icl::distance	(	const Type &	x1,
		const Type &	x2
	)

References first(), is_empty(), last(), and boost::icl::identity_element< Type >::value().

Referenced by distance().

template<class Type >

boost:: enable_if< mpl::and_< is_interval<Type> , has_difference<typename interval_traits<Type>::domain_type> , is_continuous<typename interval_traits<Type>::domain_type> > , typename difference_type_of<interval_traits<Type> >::type>::type boost::icl::distance	(	const Type &	x1,
		const Type &	x2
	)

References is_empty(), lower(), upper(), and boost::icl::identity_element< Type >::value().

template<class Type >

enable_if<is_interval_set<Type>, Type>::type& boost::icl::domain	(	Type &	dom,
		const Type &	object
	)

References boost::end, and insert().

template<class Type >

enable_if<is_element_map<Type>, typename Type::set_type>::type& boost::icl::domain ( typename Type::set_type &  domain_set, const Type &  object  )

inline

References boost::end, and first().

template<class Type , class SetT >

enable_if<is_concept_combinable<is_interval_set, is_interval_map, SetT, Type>, SetT>::type& boost::icl::domain	(	SetT &	result,
		const Type &	object
	)

References insert().

template<class Type >

enable_if<is_interval<Type>, bool>::type boost::icl::domain_equal ( const typename interval_traits< Type >::domain_type &  left, const typename interval_traits< Type >::domain_type &  right  )

inline

References left(), and right().

template<class Type >

enable_if<is_interval<Type>, bool>::type boost::icl::domain_less ( const typename interval_traits< Type >::domain_type &  left, const typename interval_traits< Type >::domain_type &  right  )

inline

References left(), and right().

template<class Type >

enable_if<is_interval<Type>, bool>::type boost::icl::domain_less_equal ( const typename interval_traits< Type >::domain_type &  left, const typename interval_traits< Type >::domain_type &  right  )

inline

References left(), and right().

template<class Type >

enable_if< is_interval<Type> , typename interval_traits<Type>::domain_type>::type boost::icl::domain_next ( const typename interval_traits< Type >::domain_type  value )

inline

References boost::icl::successor< DomainT, Compare >::apply().

template<class Type >

enable_if< is_interval<Type> , typename interval_traits<Type>::domain_type>::type boost::icl::domain_prior ( const typename interval_traits< Type >::domain_type  value )

inline

References boost::icl::predecessor< DomainT, Compare >::apply().

template<class Type >

enable_if<mpl::and_< is_interval_container<Type> , mpl::not_<is_continuous_interval<typename Type::interval_type> > >,typename Type::element_iterator>::type boost::icl::elements_begin

(

Type &

object

)

References boost::asio::begin.

template<class Type >

enable_if<mpl::and_< is_interval_container<Type> , mpl::not_<is_continuous_interval<typename Type::interval_type> > >,typename Type::element_const_iterator>::type boost::icl::elements_begin

(

const Type &

object

)

References boost::asio::begin.

template<class Type >

enable_if<mpl::and_< is_interval_container<Type> , mpl::not_<is_continuous_interval<typename Type::interval_type> > >,typename Type::element_iterator>::type boost::icl::elements_end

(

Type &

object

)

References boost::end.

template<class Type >

enable_if<mpl::and_< is_interval_container<Type> , mpl::not_<is_continuous_interval<typename Type::interval_type> > >,typename Type::element_const_iterator>::type boost::icl::elements_end

(

const Type &

object

)

References boost::end.

template<class Type >

enable_if<mpl::and_< is_interval_container<Type> , mpl::not_<is_continuous_interval<typename Type::interval_type> > >,typename Type::element_reverse_iterator>::type boost::icl::elements_rbegin

(

Type &

object

)

References boost::rbegin().

template<class Type >

enable_if<mpl::and_< is_interval_container<Type> , mpl::not_<is_continuous_interval<typename Type::interval_type> > >,typename Type::element_const_reverse_iterator>::type boost::icl::elements_rbegin

(

const Type &

object

)

References boost::rbegin().

template<class Type >

enable_if<mpl::and_< is_interval_container<Type> , mpl::not_<is_continuous_interval<typename Type::interval_type> > >,typename Type::element_reverse_iterator>::type boost::icl::elements_rend

(

Type &

object

)

References boost::rend().

template<class Type >

enable_if<mpl::and_< is_interval_container<Type> , mpl::not_<is_continuous_interval<typename Type::interval_type> > >,typename Type::element_const_reverse_iterator>::type boost::icl::elements_rend

(

const Type &

object

)

References boost::rend().

template<class Type >

enable_if<is_element_map<Type>, typename Type::size_type>::type boost::icl::erase	(	Type &	object,
		const typename Type::element_type &	value_pair
	)

References boost::end, boost::icl::unit_element< Type >::value(), and boost::icl::identity_element< Type >::value().

template<class Type >

enable_if<is_element_map<Type>, Type>::type& boost::icl::erase	(	Type &	object,
		const typename Type::set_type &	erasure
	)

References erase().

template<class Type >

enable_if<is_interval_set<Type>, Type>::type& boost::icl::erase	(	Type &	object,
		const typename Type::segment_type &	minuend
	)

References subtract().

template<class Type >

enable_if<is_interval_set<Type>, Type>::type& boost::icl::erase	(	Type &	object,
		const typename Type::element_type &	minuend
	)

References subtract().

template<class Type >

enable_if<is_interval_map<Type>, Type>::type& boost::icl::erase	(	Type &	object,
		const typename Type::interval_type &	operand
	)

template<class Type >

enable_if<is_interval_map<Type>, Type>::type& boost::icl::erase	(	Type &	object,
		const typename Type::domain_type &	operand
	)

References erase().

template<class Type >

enable_if<is_interval_map<Type>, Type>::type& boost::icl::erase	(	Type &	object,
		const typename Type::segment_type &	operand
	)

template<class Type >

enable_if<is_interval_map<Type>, Type>::type& boost::icl::erase ( Type &  object, const typename Type::element_type &  operand  )

inline

References erase().

template<class Type >

enable_if<is_associative_element_container<Type>, typename Type::size_type>::type boost::icl::erase	(	Type &	object,
		const typename Type::key_type &	key_value
	)

References boost::end, boost::icl::identity_element< Type >::value(), and boost::icl::unit_element< Type >::value().

Referenced by boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::_add(), boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::_subtract(), erase(), boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::erase(), boost::icl::interval_base_map< interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase(), erase_if(), boost::icl::inplace_erase< Type >::operator()(), operator-=(), set_at(), subtract(), and boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::subtract().

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type& boost::icl::erase	(	Type &	object,
		const Type &	erasure
	)

References erase().

template<class Type , class OperandT >

enable_if<combines_right_to_interval_container<Type, OperandT>, Type>::type& boost::icl::erase	(	Type &	object,
		const OperandT &	operand
	)

References erase(), and is_empty().

template<class Type , class Predicate >

enable_if< is_associative_element_container< Type >, Type >::type & boost::icl::erase_if	(	const Predicate &	pred,
		Type &	object
	)

References boost::end, and erase().

Referenced by absorb_identities().

template<class MapT , class Predicate >

enable_if<is_interval_map<MapT>, MapT>::type& boost::icl::erase_if	(	const Predicate &	pred,
		MapT &	object
	)

References boost::end.

template<class Type >

boost::enable_if<is_asymmetric_interval<Type>, bool>::type boost::icl::exclusive_less ( const Type &  left, const Type &  right  )

inline

Maximal element of left is less than the minimal element of right

References is_empty(), lower(), and upper().

Referenced by disjoint(), inner_complement(), intersects(), left_subtract(), and right_subtract().

template<class Type >

boost::enable_if<is_discrete_interval<Type>, bool>::type boost::icl::exclusive_less ( const Type &  left, const Type &  right  )

inline

References first(), is_empty(), and last().

template<class Type >

boost:: enable_if<has_symmetric_bounds<Type>, bool>::type boost::icl::exclusive_less ( const Type &  left, const Type &  right  )

inline

References first(), is_empty(), and last().

template<class Type >

boost::enable_if<is_continuous_interval<Type>, bool>::type boost::icl::exclusive_less ( const Type &  left, const Type &  right  )

inline

References inner_bounds(), is_empty(), lower(), boost::icl::interval_bounds::open(), and upper().

template<class Type >

enable_if<mpl::and_< is_interval_container<Type> , is_discrete<typename domain_type_of<Type>::type> > , typename Type::const_iterator>::type boost::icl::find ( const Type &  object, const typename domain_type_of< Type >::type &  key_val  )

inline

Referenced by boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::_subtract(), add_intersection(), contains(), boost::icl::interval_base_set< split_interval_set< DomainT, Compare, Interval, Alloc >, DomainT, Compare, Interval, Alloc >::find(), boost::icl::interval_base_map< interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::find(), intersects(), boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::operator()(), and boost::icl::interval_base_map< interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::operator()().

template<class Type >

enable_if<mpl::and_< is_interval_container<Type> , is_continuous<typename domain_type_of<Type>::type> , has_dynamic_bounds<typename interval_type_of<Type>::type> > , typename Type::const_iterator>::type boost::icl::find ( const Type &  object, const typename domain_type_of< Type >::type &  key_val  )

inline

template<class Type >

enable_if<mpl::and_< is_interval_container<Type> , is_continuous<typename domain_type_of<Type>::type> , is_static_right_open<typename interval_type_of<Type>::type> , boost::detail::is_incrementable<typename domain_type_of<Type>::type> > , typename Type::const_iterator>::type boost::icl::find ( const Type &  object, const typename domain_type_of< Type >::type &  key_val  )

inline

References contains(), and boost::end.

template<class Type >

enable_if<mpl::and_< is_interval_container<Type> , is_continuous<typename domain_type_of<Type>::type> , is_static_left_open<typename interval_type_of<Type>::type> , boost::detail::is_incrementable<typename domain_type_of<Type>::type> > , typename Type::const_iterator>::type boost::icl::find ( const Type &  object, const typename domain_type_of< Type >::type &  key_val  )

inline

References boost::asio::begin, contains(), and boost::end.

template<class Type >

enable_if< is_interval_container<Type> , typename Type::const_iterator>::type boost::icl::find ( const Type &  object, const typename interval_type_of< Type >::type &  inter_val  )

inline

template<class Type >

enable_if< mpl::and_< is_interval_container<Type> , is_discrete<typename domain_type_of<Type>::type> > , typename domain_type_of<Type>::type>::type boost::icl::first

(

const Type &

object

)

References boost::asio::begin, first(), is_empty(), and boost::icl::unit_element< Type >::value().

template<class Type >

enable_if< mpl::or_<is_static_right_open<Type>, is_static_closed<Type> > , typename interval_traits<Type>::domain_type>::type boost::icl::first ( const Type &  object )

inline

References lower().

Referenced by between(), cardinality(), contains(), distance(), domain(), boost::icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase(), boost::icl::non_empty::exclusive_less(), exclusive_less(), first(), inner_complement(), boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::insert(), length(), lower_equal(), lower_less(), and touches().

template<class Type >

enable_if< mpl::and_< mpl::or_<is_static_left_open<Type>, is_static_open<Type> > , is_discrete<typename interval_traits<Type>::domain_type> > , typename interval_traits<Type>::domain_type>::type boost::icl::first ( const Type &  object )

inline

References lower().

template<class Type >

enable_if<is_discrete_interval<Type>, typename interval_traits<Type>::domain_type>::type boost::icl::first ( const Type &  object )

inline

References bounds(), is_left_closed(), and lower().

template<class Type >

enable_if<is_element_set<Type>, Type>::type& boost::icl::flip ( Type &  object, const typename Type::value_type &  operand  )

inline

template<class Type >

enable_if<is_interval_set<Type>, Type>::type& boost::icl::flip	(	Type &	object,
		const typename Type::element_type &	operand
	)

References contains().

template<class Type >

enable_if<is_interval_set<Type>, Type>::type& boost::icl::flip	(	Type &	object,
		const typename Type::segment_type &	segment
	)

References add(), boost::msm::front::euml::end_, left_subtract(), right_subtract(), span(), and subtract().

template<class Type , class OperandT >

enable_if<is_concept_compatible<is_interval_set, Type, OperandT>, Type>::type& boost::icl::flip	(	Type &	object,
		const OperandT &	operand
	)

References add(), and flip().

template<class Type >

enable_if<is_element_map<Type>, Type>::type& boost::icl::flip ( Type &  object, const typename Type::element_type &  operand  )

inline

Referenced by boost::icl::interval_base_set< split_interval_set< DomainT, Compare, Interval, Alloc >, DomainT, Compare, Interval, Alloc >::flip(), boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::flip(), boost::icl::interval_base_map< interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::flip(), flip(), operator^(), and operator^=().

template<class Type >

enable_if<is_interval_map<Type>, Type>::type& boost::icl::flip	(	Type &	object,
		const typename Type::segment_type &	operand
	)

template<class Type >

enable_if<is_interval_map<Type>, Type>::type& boost::icl::flip ( Type &  object, const typename Type::element_type &  operand  )

inline

References flip().

template<class Type , class OperandT >

enable_if< mpl::and_< is_total<Type> , absorbs_identities<Type> , is_concept_compatible<is_interval_map, Type, OperandT > > , Type>::type& boost::icl::flip	(	Type &	object,
		const OperandT &
	)

template<class Type , class OperandT >

enable_if< mpl::and_< is_total<Type> , mpl::not_<absorbs_identities<Type> > , is_concept_compatible<is_interval_map, Type, OperandT > > , Type>::type& boost::icl::flip	(	Type &	object,
		const OperandT &	operand
	)

References join(), boost::icl::identity_element< Type >::value(), and boost::program_options::value().

template<class Type , class OperandT >

enable_if< mpl::and_< mpl::not_<is_total<Type> > , is_concept_compatible<is_interval_map, Type, OperandT > > , Type>::type& boost::icl::flip	(	Type &	object,
		const OperandT &	operand
	)

References add(), and flip().

template<class Type >

enable_if<is_interval_container<Type>, typename Type::interval_type>::type boost::icl::hull

(

const Type &

object

)

References boost::asio::begin, hull(), is_empty(), boost::rbegin(), and boost::icl::identity_element< Type >::value().

template<class Type >

enable_if<is_static_right_open<Type>, Type>::type boost::icl::hull	(	const typename interval_traits< Type >::domain_type &	left,
		const typename interval_traits< Type >::domain_type &	right
	)

References left(), and right().

Referenced by contains(), hull(), inner_complement(), and join().

template<class Type >

enable_if<is_static_left_open<Type>, Type>::type boost::icl::hull	(	const typename interval_traits< Type >::domain_type &	left,
		const typename interval_traits< Type >::domain_type &	right
	)

References BOOST_ASSERT, boost::serialization::is_less_than(), left(), and right().

template<class Type >

enable_if<is_static_closed<Type>, Type>::type boost::icl::hull	(	const typename interval_traits< Type >::domain_type &	left,
		const typename interval_traits< Type >::domain_type &	right
	)

References left(), and right().

template<class Type >

enable_if<is_static_open<Type>, Type>::type boost::icl::hull	(	const typename interval_traits< Type >::domain_type &	left,
		const typename interval_traits< Type >::domain_type &	right
	)

References BOOST_ASSERT, boost::serialization::is_less_than(), left(), and right().

template<class Type >

enable_if<has_dynamic_bounds<Type>, Type>::type boost::icl::hull	(	const typename interval_traits< Type >::domain_type &	left,
		const typename interval_traits< Type >::domain_type &	right
	)

References boost::icl::interval_bounds::closed(), left(), and right().

template<class Type >

boost::enable_if<has_static_bounds<Type>, Type>::type boost::icl::hull	(	Type	left,
		const Type &	right
	)

hull returns the smallest interval containing left and right.

References is_empty(), left(), lower(), boost::accumulators::extract::max, boost::accumulators::extract::min, right(), and upper().

template<class Type >

boost::enable_if<has_dynamic_bounds<Type>, Type>::type boost::icl::hull	(	Type	left,
		const Type &	right
	)

References boost::icl::dynamic_interval_traits< Type >::construct_bounded(), is_empty(), left(), lower_min(), right(), and upper_max().

template<class LeftT , class RightT >

enable_if<is_inter_combinable<LeftT, RightT>, int>::type boost::icl::inclusion_compare	(	const LeftT &	left,
		const RightT &	right
	)

template<class LeftT , class RightT >

enable_if<is_concept_equivalent<is_element_container,LeftT, RightT>, int>::type boost::icl::inclusion_compare	(	const LeftT &	left,
		const RightT &	right
	)

interval_bounds boost::icl::inner_bounds ( interval_bounds  x1, interval_bounds  x2  )

inline

References boost::icl::interval_bounds::reverse_left(), and boost::icl::interval_bounds::reverse_right().

Referenced by boost::icl::non_empty::exclusive_less(), exclusive_less(), inner_bounds(), and touches().

template<class IntervalT >

boost::enable_if<has_dynamic_bounds<IntervalT>, interval_bounds>::type boost::icl::inner_bounds ( const IntervalT &  x1, const IntervalT &  x2  )

inline

References inner_bounds().

template<class Type >

boost::enable_if<is_asymmetric_interval<Type>, Type>::type boost::icl::inner_complement	(	const Type &	left,
		const Type &	right
	)

References exclusive_less(), is_empty(), lower(), upper(), and boost::icl::identity_element< Type >::value().

Referenced by between().

template<class Type >

boost::enable_if<is_discrete_static_closed<Type>, Type>::type boost::icl::inner_complement	(	const Type &	left,
		const Type &	right
	)

References exclusive_less(), is_empty(), lower(), upper(), and boost::icl::identity_element< Type >::value().

template<class Type >

boost::enable_if<is_discrete_static_open<Type>, Type>::type boost::icl::inner_complement	(	const Type &	left,
		const Type &	right
	)

References exclusive_less(), first(), is_empty(), last(), and boost::icl::identity_element< Type >::value().

template<class Type >

boost::enable_if<has_dynamic_bounds<Type>, Type>::type boost::icl::inner_complement	(	const Type &	left,
		const Type &	right
	)

References exclusive_less(), hull(), is_empty(), left_subtract(), right_subtract(), and boost::icl::identity_element< Type >::value().

template<class Type >

enable_if<is_interval_set<Type>, Type>::type& boost::icl::insert ( Type &  object, const typename Type::segment_type &  operand  )

inline

References add().

template<class Type >

enable_if<is_interval_set<Type>, Type>::type& boost::icl::insert ( Type &  object, const typename Type::element_type &  operand  )

inline

References add().

template<class Type >

enable_if<is_interval_set<Type>, typename Type::iterator>::type boost::icl::insert ( Type &  object, typename Type::iterator  prior, const typename Type::segment_type &  operand  )

inline

References add().

template<class Type >

enable_if<is_interval_map<Type>, Type>::type& boost::icl::insert	(	Type &	object,
		const typename Type::segment_type &	operand
	)

template<class Type >

enable_if<is_interval_map<Type>, Type>::type& boost::icl::insert ( Type &  object, const typename Type::element_type &  operand  )

inline

References insert().

template<class Type >

enable_if<is_interval_map<Type>, typename Type::iterator>::type boost::icl::insert	(	Type &	object,
		typename Type::iterator	prior,
		const typename Type::segment_type &	operand
	)

template<class Type >

enable_if<is_associative_element_container<Type>, std::pair<typename Type::iterator,bool> >::type boost::icl::insert	(	Type &	object,
		const typename Type::value_type &	operand
	)

Referenced by between(), domain(), insert(), boost::icl::interval_base_map< interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::insert(), boost::icl::inplace_insert< Type >::operator()(), and set_at().

template<class Type >

enable_if<is_associative_element_container<Type>, typename Type::iterator>::type boost::icl::insert	(	Type &	object,
		typename Type::iterator	prior,
		const typename Type::value_type &	operand
	)

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type& boost::icl::insert	(	Type &	object,
		const Type &	addend
	)

References insert().

template<class Type , class OperandT >

enable_if<is_intra_combinable<Type, OperandT>, Type>::type& boost::icl::insert	(	Type &	object,
		const OperandT &	operand
	)

References insert().

template<class ContainerT , typename IteratorT >

insert_iterator<ContainerT> boost::icl::inserter ( ContainerT &  cont, IteratorT  iter_  )

inline

Function inserter creates and initializes an insert_iterator.

template<class Type >

enable_if<is_element_set<Type>, bool>::type boost::icl::intersects ( const Type &  object, const typename Type::key_type &  operand  )

inline

template<class Type >

enable_if<is_element_set<Type>, bool>::type boost::icl::intersects ( const Type &  object, const Type &  operand  )

inline

References iterative_size().

template<class Type , class CoType >

enable_if< mpl::and_< is_element_map<Type> , is_total<Type> > , bool>::type boost::icl::intersects ( const Type &  , const CoType &    )

inline

Referenced by disjoint(), and intersects().

template<class Type >

enable_if< mpl::and_< is_element_map<Type> , mpl::not_<is_total<Type> > > , bool>::type boost::icl::intersects ( const Type &  object, const typename Type::domain_type &  operand  )

inline

References contains().

template<class Type >

enable_if< mpl::and_< is_element_map<Type> , mpl::not_<is_total<Type> > > , bool>::type boost::icl::intersects ( const Type &  object, const typename Type::set_type &  operand  )

inline

References intersects(), and iterative_size().

template<class Type >

enable_if< mpl::and_< is_element_map<Type> , mpl::not_<is_total<Type> > > , bool>::type boost::icl::intersects ( const Type &  object, const typename Type::element_type &  operand  )

inline

References add_intersection().

template<class Type >

enable_if< mpl::and_< is_element_map<Type> , mpl::not_<is_total<Type> > > , bool>::type boost::icl::intersects ( const Type &  object, const Type &  operand  )

inline

References iterative_size().

Referenced by intersects().

template<class Type , class OperandT >

enable_if<mpl::and_< is_interval_map<Type> , is_total<Type> , boost::is_same< OperandT , typename segment_type_of<Type>::type> >, bool>::type boost::icl::intersects	(	const Type &	,
		const OperandT &
	)

template<class Type , class OperandT >

enable_if<mpl::and_< is_interval_map<Type> , mpl::not_<is_total<Type> > , boost::is_same<OperandT, typename segment_type_of<Type>::type> >, bool>::type boost::icl::intersects	(	const Type &	object,
		const OperandT &	operand
	)

References add_intersection(), and is_empty().

template<class Type , class OperandT >

enable_if<mpl::and_< is_interval_map<Type> , boost::is_same<OperandT, typename element_type_of<Type>::type> >, bool>::type boost::icl::intersects	(	const Type &	object,
		const OperandT &	operand
	)

References intersects().

template<class Type , class CoType >

enable_if<mpl::and_< is_interval_container<Type> , boost::is_same<CoType, typename domain_type_of<Type>::type> >, bool>::type boost::icl::intersects	(	const Type &	left,
		const CoType &	right
	)

References contains().

template<class Type , class CoType >

enable_if<mpl::and_< is_interval_container<Type> , boost::is_same<CoType, typename interval_type_of<Type>::type> >, bool>::type boost::icl::intersects	(	const Type &	left,
		const CoType &	right
	)

References find().

template<class LeftT , class RightT >

enable_if< mpl::and_< is_intra_combinable<LeftT, RightT> , mpl::or_<is_total<LeftT>, is_total<RightT> > > , bool>::type boost::icl::intersects	(	const LeftT &	,
		const RightT &
	)

template<class LeftT , class RightT >

enable_if< mpl::and_< is_intra_combinable<LeftT, RightT> , mpl::not_<mpl::or_< is_total<LeftT> , is_total<RightT> > > > , bool>::type boost::icl::intersects	(	const LeftT &	left,
		const RightT &	right
	)

References add_intersection(), and is_empty().

template<class LeftT , class RightT >

enable_if<is_cross_combinable<LeftT, RightT>, bool>::type boost::icl::intersects	(	const LeftT &	left,
		const RightT &	right
	)

References add_intersection(), and is_empty().

template<class Type >

boost::enable_if<is_interval<Type>, bool>::type boost::icl::intersects	(	const Type &	left,
		const Type &	right
	)

References exclusive_less(), and is_empty().

template<class Type >

enable_if<is_interval_container<Type>, std::size_t>::type boost::icl::interval_count

(

const Type &

object

)

References iterative_size().

bool boost::icl::is_complementary ( interval_bounds  x1 )

inline

References boost::icl::interval_bounds::left_open(), and boost::icl::interval_bounds::right_open().

Referenced by touches().

template<class Type >

enable_if<is_element_map<Type>, bool>::type boost::icl::is_distinct_equal ( const Type &  lhs, const Type &  rhs  )

inline

Protonic equality is equality on all elements that do not carry an identity element as content.

Referenced by boost::icl::distinct_equal< Type >::operator()().

template<class LeftT , class RightT >

enable_if< is_concept_compatible<is_interval_map, LeftT, RightT>, bool >::type boost::icl::is_distinct_equal	(	const LeftT &	left,
		const RightT &	right
	)

template<class LeftT , class RightT >

enable_if<is_intra_combinable<LeftT, RightT>, bool>::type boost::icl::is_element_equal	(	const LeftT &	left,
		const RightT &	right
	)

Returns true, if left and right contain the same elements.

Complexity: linear.

template<class Type >

enable_if<is_associative_element_container<Type>, bool>::type boost::icl::is_element_equal ( const Type &  left, const Type &  right  )

inline

References right().

Referenced by boost::icl::element_equal< Type >::operator()().

template<class LeftT , class RightT >

enable_if<is_intra_combinable<LeftT, RightT>, bool>::type boost::icl::is_element_greater	(	const LeftT &	left,
		const RightT &	right
	)

Returns true, if left is lexicographically greater than right.

Intervals are interpreted as sequence of elements. Complexity: linear.

template<class LeftT , class RightT >

enable_if<is_intra_combinable<LeftT, RightT>, bool>::type boost::icl::is_element_less	(	const LeftT &	left,
		const RightT &	right
	)

Returns true, if left is lexicographically less than right.

Intervals are interpreted as sequence of elements. Complexity: linear.

template<class Type >

enable_if<is_container<Type>, bool>::type boost::icl::is_empty

(

const Type &

object

)

Tests if the container is empty.

Complexity: constant.

Referenced by boost::icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::add_front(), add_intersection(), boost::icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::add_rear(), boost::icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::add_segment(), cardinality(), co_value(), contains(), disjoint(), distance(), boost::icl::interval_base_set< split_interval_set< DomainT, Compare, Interval, Alloc >, DomainT, Compare, Interval, Alloc >::empty(), boost::icl::interval_base_map< interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::empty(), boost::icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase(), erase(), boost::icl::non_empty::exclusive_less(), exclusive_less(), first(), hull(), inner_complement(), intersects(), last(), length(), lower(), operator&(), operator<(), operator<<(), operator==(), boost::icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::subtract(), upper(), and within().

template<class Type >

boost::enable_if<is_asymmetric_interval<Type>, bool>::type boost::icl::is_empty

(

const Type &

object

)

Is the interval empty?

References lower(), and upper().

template<class Type >

boost::enable_if<is_static_closed<Type>, bool>::type boost::icl::is_empty

(

const Type &

object

)

References lower(), and upper().

template<class Type >

boost::enable_if<is_static_open<Type>, bool>::type boost::icl::is_empty

(

const Type &

object

)

References lower(), and upper().

template<class Type >

boost::enable_if<is_discrete_interval<Type>, bool>::type boost::icl::is_empty

(

const Type &

object

)

References bounds(), boost::icl::interval_bounds::closed(), lower(), boost::icl::interval_bounds::open(), and upper().

template<class Type >

boost::enable_if<is_continuous_interval<Type>, bool>::type boost::icl::is_empty

(

const Type &

object

)

References boost::icl::interval_bounds::closed(), lower(), and upper().

Referenced by boost::numeric::interval< T, Policies >::interval(), boost::numeric::interval< T, Policies >::operator!=(), boost::numeric::interval< T, Policies >::operator<(), boost::numeric::interval< T, Policies >::operator<=(), boost::numeric::interval< T, Policies >::operator=(), boost::numeric::interval< T, Policies >::operator==(), boost::numeric::interval< T, Policies >::operator>(), and boost::numeric::interval< T, Policies >::operator>=().

bool boost::icl::is_left_closed ( interval_bounds  bounds )

inline

References boost::icl::interval_bounds::bits(), and boost::icl::interval_bounds::left().

Referenced by contains(), first(), left_bracket(), and shift_lower().

bool boost::icl::is_right_closed ( interval_bounds  bounds )

inline

References boost::icl::interval_bounds::bits(), and boost::icl::interval_bounds::right().

Referenced by contains(), last(), last_next(), right_bracket(), and shift_upper().

template<class Type >

enable_if<is_element_container<Type>, std::size_t>::type boost::icl::iterative_size

(

const Type &

object

)

template<class Type >

enable_if<mpl::and_< is_container<Type> , mpl::not_<is_icl_container<Type> > > , std::size_t>::type boost::icl::iterative_size

(

const Type &

object

)

Referenced by boost::icl::value_size< Type >::apply(), cardinality(), intersects(), interval_count(), and size().

template<class Type >

enable_if<is_interval_container<Type>, std::size_t>::type boost::icl::iterative_size

(

const Type &

object

)

template<class Type >

enable_if<is_interval<Type>, typename size_type_of<interval_traits<Type> >::type>::type boost::icl::iterative_size ( const Type &  )

inline

template<class Type >

enable_if<is_interval_container<Type>, Type>::type& boost::icl::join

(

Type &

object

)

References boost::end, and hull().

Referenced by flip().

template<class Type , class Iterator >

enable_if<is_set<Type>, const typename Type::key_type>::type& boost::icl::key_value ( Iterator  it_ )

inline

template<class Type , class Iterator >

enable_if<is_map<Type>, const typename Type::key_type>::type& boost::icl::key_value ( Iterator  it_ )

inline

Referenced by boost::spirit::insert_key_action::act(), and boost::spirit::insert_at_action::act().

template<class Type >

enable_if< mpl::and_< is_interval_container<Type> , is_discrete<typename domain_type_of<Type>::type> >, typename domain_type_of<Type>::type>::type boost::icl::last

(

const Type &

object

)

References is_empty(), last(), boost::rbegin(), and boost::icl::identity_element< Type >::value().

template<class Type >

enable_if< mpl::or_<is_static_left_open<Type>, is_static_closed<Type> > , typename interval_traits<Type>::domain_type>::type boost::icl::last ( const Type &  object )

inline

References upper().

Referenced by contains(), distance(), boost::icl::non_empty::exclusive_less(), exclusive_less(), inner_complement(), last(), touches(), upper_equal(), and upper_less().

template<class Type >

enable_if< mpl::and_< mpl::or_<is_static_right_open<Type>, is_static_open<Type> > , is_discrete<typename interval_traits<Type>::domain_type> > , typename interval_traits<Type>::domain_type>::type boost::icl::last ( const Type &  object )

inline

References BOOST_ASSERT, boost::serialization::is_less_than(), and upper().

template<class Type >

enable_if<is_discrete_interval<Type>, typename interval_traits<Type>::domain_type>::type boost::icl::last ( const Type &  object )

inline

References BOOST_ASSERT, bounds(), is_right_closed(), and upper().

template<class Type >

enable_if< mpl::and_< mpl::or_<is_static_left_open<Type>, is_static_closed<Type> > , is_discrete<typename interval_traits<Type>::domain_type> > , typename interval_traits<Type>::domain_type>::type boost::icl::last_next ( const Type &  object )

inline

References upper().

Referenced by cardinality(), length(), and touches().

template<class Type >

enable_if< mpl::and_< mpl::or_<is_static_right_open<Type>, is_static_open<Type> > , is_discrete<typename interval_traits<Type>::domain_type> > , typename interval_traits<Type>::domain_type>::type boost::icl::last_next ( const Type &  object )

inline

References upper().

template<class Type >

enable_if<is_discrete_interval<Type>, typename interval_traits<Type>::domain_type>::type boost::icl::last_next ( const Type &  object )

inline

References bounds(), is_right_closed(), and upper().

interval_bounds boost::icl::left ( interval_bounds  x1 )

inline

References boost::icl::interval_bounds::_bits.

Referenced by bounded_lower(), domain_equal(), domain_less(), domain_less_equal(), hull(), left_bounds(), operator>(), outer_bounds(), right_subtract(), right_subtract_bounds(), and span().

interval_bounds boost::icl::left_bounds ( interval_bounds  x1, interval_bounds  x2  )

inline

References left().

Referenced by left_bounds(), and lower_less().

template<class IntervalT >

boost::enable_if<has_dynamic_bounds<IntervalT>, interval_bounds>::type boost::icl::left_bounds ( const IntervalT &  x1, const IntervalT &  x2  )

inline

References left_bounds().

std::string boost::icl::left_bracket ( interval_bounds  bounds )

inline

References is_left_closed().

template<class Type >

boost:: enable_if< mpl::or_< is_static_left_open<Type> , is_static_open<Type> >, std::string>::type boost::icl::left_bracket

(

const Type &

)

Referenced by left_bracket(), and operator<<().

template<class Type >

boost:: enable_if< mpl::or_< is_static_right_open<Type> , is_static_closed<Type> >, std::string>::type boost::icl::left_bracket

(

const Type &

)

template<class Type >

boost::enable_if<has_dynamic_bounds<Type>, std::string>::type boost::icl::left_bracket

(

const Type &

object

)

References bounds(), and left_bracket().

template<class Type >

boost::enable_if<is_asymmetric_interval<Type>, Type>::type boost::icl::left_subtract	(	Type	right,
		const Type &	left_minuend
	)

subtract left_minuend from the right interval on it's left side.

Return the difference: The part of right right of left_minuend.

right_over = right - left_minuend; //on the left.
...      d) : right
... c)      : left_minuend
     [c  d) : right_over

References exclusive_less(), right(), and upper().

Referenced by boost::icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::add_front(), boost::icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::add_main(), boost::icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::add_rear(), boost::icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase(), flip(), inner_complement(), and boost::icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::subtract().

template<class Type >

boost::enable_if<is_static_closed<Type>, Type>::type boost::icl::left_subtract	(	Type	right,
		const Type &	left_minuend
	)

References exclusive_less(), right(), and upper().

template<class Type >

boost::enable_if<is_static_open<Type>, Type>::type boost::icl::left_subtract	(	Type	right,
		const Type &	left_minuend
	)

References exclusive_less(), right(), and upper().

template<class Type >

boost::enable_if<has_dynamic_bounds<Type>, Type>::type boost::icl::left_subtract	(	Type	right,
		const Type &	left_minuend
	)

References bounded_upper(), boost::icl::dynamic_interval_traits< Type >::construct_bounded(), exclusive_less(), reverse_bounded_upper(), and right().

interval_bounds boost::icl::left_subtract_bounds ( interval_bounds  x1, interval_bounds  x2  )

inline

References right().

Referenced by left_subtract_bounds().

template<class IntervalT >

boost::enable_if<has_dynamic_bounds<IntervalT>, interval_bounds>::type boost::icl::left_subtract_bounds ( const IntervalT &  x1, const IntervalT &  x2  )

inline

References left_subtract_bounds().

template<class Type >

enable_if<is_interval_container<Type>, typename Type::difference_type>::type boost::icl::length

(

const Type &

object

)

References boost::end, length(), and boost::icl::identity_element< Type >::value().

template<class Type >

boost::enable_if<is_continuous_interval<Type>, typename difference_type_of<interval_traits<Type> >::type>::type boost::icl::length ( const Type &  object )

inline

References is_empty(), lower(), upper(), and boost::icl::identity_element< Type >::value().

Referenced by length().

template<class Type >

boost::enable_if<is_discrete_interval<Type>, typename difference_type_of<interval_traits<Type> >::type>::type boost::icl::length ( const Type &  object )

inline

References first(), is_empty(), last_next(), and boost::icl::identity_element< Type >::value().

template<class Type >

boost::enable_if<is_continuous_asymmetric<Type>, typename difference_type_of<interval_traits<Type> >::type>::type boost::icl::length

(

const Type &

object

)

References is_empty(), lower(), upper(), and boost::icl::identity_element< Type >::value().

template<class Type >

boost::enable_if<is_discrete_static<Type>, typename difference_type_of<interval_traits<Type> >::type>::type boost::icl::length ( const Type &  object )

inline

References first(), is_empty(), last_next(), and boost::icl::identity_element< Type >::value().

template<class Type >

enable_if<is_interval_container<Type>, typename domain_type_of<Type>::type>::type boost::icl::lower

(

const Type &

object

)

References boost::asio::begin, is_empty(), lower(), and boost::icl::unit_element< Type >::value().

template<class Type >

enable_if<is_interval<Type>, typename interval_traits<Type>::domain_type>::type boost::icl::lower ( const Type &  object )

inline

References boost::icl::interval_traits< Type >::lower().

Referenced by bounded_lower(), cardinality(), contains(), distance(), boost::icl::non_empty::exclusive_less(), exclusive_less(), first(), hull(), inner_complement(), is_empty(), length(), lower(), lower_equal(), lower_less(), operator&(), reverse_bounded_lower(), right_subtract(), and touches().

template<class Type >

boost::enable_if<is_asymmetric_interval<Type>, bool>::type boost::icl::lower_equal	(	const Type &	left,
		const Type &	right
	)

References lower().

Referenced by lower_less_equal(), operator<(), and operator==().

template<class Type >

boost::enable_if<has_symmetric_bounds<Type>, bool>::type boost::icl::lower_equal	(	const Type &	left,
		const Type &	right
	)

References first().

template<class Type >

boost::enable_if<is_discrete_interval<Type>, bool>::type boost::icl::lower_equal	(	const Type &	left,
		const Type &	right
	)

References first().

template<class Type >

boost::enable_if<is_continuous_interval<Type>, bool>::type boost::icl::lower_equal	(	const Type &	left,
		const Type &	right
	)

References lower().

template<class Type >

boost::enable_if<has_static_bounds<Type>, bool>::type boost::icl::lower_less	(	const Type &	left,
		const Type &	right
	)

References lower().

Referenced by lower_less_equal(), lower_max(), lower_min(), and operator<().

template<class Type >

boost::enable_if<is_discrete_interval<Type>, bool>::type boost::icl::lower_less	(	const Type &	left,
		const Type &	right
	)

References first().

template<class Type >

boost::enable_if<is_continuous_interval<Type>, bool>::type boost::icl::lower_less	(	const Type &	left,
		const Type &	right
	)

References left_bounds(), lower(), and boost::icl::interval_bounds::right_open().

template<class Type >

boost::enable_if<is_interval<Type>, bool>::type boost::icl::lower_less_equal	(	const Type &	left,
		const Type &	right
	)

References lower_equal(), and lower_less().

Referenced by boost::icl::non_empty::contains(), and right_subtract().

template<class Type >

boost::enable_if<has_dynamic_bounds<Type>, typename Type::bounded_domain_type >::type boost::icl::lower_max	(	const Type &	left,
		const Type &	right
	)

References bounded_lower(), and lower_less().

Referenced by operator&().

template<class Type >

boost::enable_if<has_dynamic_bounds<Type>, typename Type::bounded_domain_type >::type boost::icl::lower_min	(	const Type &	left,
		const Type &	right
	)

References bounded_lower(), and lower_less().

Referenced by hull().

template<class Type >

enable_if<is_interval_map<Type>, typename Type::segment_type>::type boost::icl::make_segment ( const typename Type::element_type &  element )

inline

template<class Type >

enable_if<is_set<Type>, typename Type::value_type>::type boost::icl::make_value ( const typename Type::key_type &  key_val, const typename codomain_type_of< Type >::type &    )

inline

template<class Type >

enable_if<is_map<Type>, typename Type::value_type>::type boost::icl::make_value ( const typename Type::key_type &  key_val, const typename Type::codomain_type &  co_val  )

inline

template<class Type >

enable_if<is_icl_container<Type>, bool>::type boost::icl::operator!= ( const Type &  left, const Type &  right  )

inline

References right().

bool boost::icl::operator!= ( const interval_bounds  x1, const interval_bounds  x2  )

inline

References boost::icl::interval_bounds::_bits.

template<class Type >

boost::enable_if<is_interval<Type>, bool>::type boost::icl::operator!=	(	const Type &	left,
		const Type &	right
	)

References right().

interval_bounds boost::icl::operator& ( interval_bounds  x1, interval_bounds  x2  )

inline

References boost::icl::interval_bounds::_bits.

template<class Type >

enable_if<is_element_map<Type>, Type>::type boost::icl::operator& ( Type  object, const typename Type::element_type &  operand  )

inline

template<class Type >

enable_if<is_element_map<Type>, Type>::type boost::icl::operator& ( const typename Type::element_type &  operand, Type  object  )

inline

template<class Type >

enable_if<is_element_map<Type>, Type>::type boost::icl::operator& ( Type  object, const typename Type::key_object_type &  operand  )

inline

template<class Type >

enable_if<is_element_map<Type>, Type>::type boost::icl::operator& ( const typename Type::key_object_type &  operand, Type  object  )

inline

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type boost::icl::operator& ( Type  object, const typename Type::key_type &  operand  )

inline

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type boost::icl::operator& ( const typename Type::key_type &  operand, Type  object  )

inline

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type boost::icl::operator& ( Type  object, const Type &  operand  )

inline

template<class Type , class OperandT >

enable_if<is_binary_inter_combinable<Type, OperandT>, Type>::type boost::icl::operator&	(	const Type &	object,
		const OperandT &	operand
	)

References boost::move().

template<class Type , class OperandT >

enable_if<is_binary_inter_combinable<Type, OperandT>, Type>::type boost::icl::operator&	(	Type &&	object,
		const OperandT &	operand
	)

References boost::move().

template<class Type , class OperandT >

enable_if<is_binary_inter_combinable<Type, OperandT>, Type>::type boost::icl::operator&	(	const OperandT &	operand,
		const Type &	object
	)

References boost::move().

template<class Type , class OperandT >

enable_if<is_binary_inter_combinable<Type, OperandT>, Type>::type boost::icl::operator&	(	const OperandT &	operand,
		Type &&	object
	)

References boost::move().

template<class Type >

enable_if<is_interval_container<Type>, Type>::type boost::icl::operator&	(	const Type &	object,
		const Type &	operand
	)

References boost::move().

template<class Type >

enable_if<is_interval_container<Type>, Type>::type boost::icl::operator&	(	Type &&	object,
		const Type &	operand
	)

References boost::move().

template<class Type >

enable_if<is_interval_container<Type>, Type>::type boost::icl::operator&	(	const Type &	operand,
		Type &&	object
	)

References boost::move().

template<class Type >

enable_if<is_interval_container<Type>, Type>::type boost::icl::operator&	(	Type &&	object,
		Type &&	operand
	)

References boost::move().

template<class Type >

boost::enable_if<is_asymmetric_interval<Type>, Type>::type boost::icl::operator&	(	Type	left,
		const Type &	right
	)

Returns the intersection of left and right interval.

References is_empty(), lower(), boost::accumulators::extract::max, boost::accumulators::extract::min, upper(), and boost::icl::identity_element< Type >::value().

template<class Type >

boost::enable_if<has_symmetric_bounds<Type>, Type>::type boost::icl::operator&	(	Type	left,
		const Type &	right
	)

References is_empty(), lower(), boost::accumulators::extract::max, boost::accumulators::extract::min, upper(), and boost::icl::identity_element< Type >::value().

template<class Type >

boost::enable_if<has_dynamic_bounds<Type>, Type>::type boost::icl::operator&	(	Type	left,
		const Type &	right
	)

References boost::icl::dynamic_interval_traits< Type >::construct_bounded(), is_empty(), lower_max(), upper_min(), and boost::icl::identity_element< Type >::value().

template<class Type >

enable_if<mpl::and_<is_element_map<Type>, is_total<Type> >, Type>::type& boost::icl::operator&= ( Type &  object, const typename Type::element_type &  operand  )

inline

template<class Type >

enable_if<mpl::and_<is_element_map<Type>, mpl::not_<is_total<Type> > >, Type>::type& boost::icl::operator&= ( Type &  object, const typename Type::element_type &  operand  )

inline

References add_intersection().

template<class Type >

enable_if<mpl::and_<is_element_map<Type>, is_total<Type> >, Type>::type& boost::icl::operator&= ( Type &  object, const Type &  operand  )

inline

template<class Type >

enable_if<mpl::and_<is_element_map<Type>, mpl::not_<is_total<Type> > >, Type>::type& boost::icl::operator&= ( Type &  object, const Type &  operand  )

inline

References add_intersection().

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type& boost::icl::operator&= ( Type &  object, const typename Type::key_type &  operand  )

inline

References add_intersection().

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type& boost::icl::operator&= ( Type &  object, const typename key_container_type_of< Type >::type &  operand  )

inline

References add_intersection().

template<class Type , class OperandT >

enable_if<is_right_inter_combinable<Type, OperandT>, Type>::type& boost::icl::operator&=	(	Type &	object,
		const OperandT &	operand
	)

References add_intersection().

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type boost::icl::operator+ ( Type  object, const typename Type::value_type &  operand  )

inline

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type boost::icl::operator+ ( const typename Type::value_type &  operand, Type  object  )

inline

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type boost::icl::operator+ ( Type  object, const Type &  operand  )

inline

template<class Type , class OperandT >

enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type boost::icl::operator+	(	const Type &	object,
		const OperandT &	operand
	)

References boost::move().

template<class Type , class OperandT >

enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type boost::icl::operator+	(	Type &&	object,
		const OperandT &	operand
	)

References boost::move().

template<class Type , class OperandT >

enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type boost::icl::operator+	(	const OperandT &	operand,
		const Type &	object
	)

References boost::move().

template<class Type , class OperandT >

enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type boost::icl::operator+	(	const OperandT &	operand,
		Type &&	object
	)

References boost::move().

template<class Type >

enable_if<is_interval_container<Type>, Type>::type boost::icl::operator+	(	const Type &	object,
		const Type &	operand
	)

References boost::move().

template<class Type >

enable_if<is_interval_container<Type>, Type>::type boost::icl::operator+	(	Type &&	object,
		const Type &	operand
	)

References boost::move().

template<class Type >

enable_if<is_interval_container<Type>, Type>::type boost::icl::operator+	(	const Type &	operand,
		Type &&	object
	)

References boost::move().

template<class Type >

enable_if<is_interval_container<Type>, Type>::type boost::icl::operator+	(	Type &&	object,
		Type &&	operand
	)

References boost::move().

boost::posix_time::ptime boost::icl::operator++ ( boost::posix_time::ptime &  x )

inline

boost::gregorian::date boost::icl::operator++ ( boost::gregorian::date &  x )

inline

References boost::gregorian::date_duration::unit().

boost::posix_time::time_duration boost::icl::operator++ ( boost::posix_time::time_duration &  x )

inline

boost::gregorian::date_duration boost::icl::operator++ ( boost::gregorian::date_duration &  x )

inline

References boost::gregorian::date_duration::unit().

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type& boost::icl::operator+= ( Type &  object, const typename Type::value_type &  operand  )

inline

References add().

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type& boost::icl::operator+= ( Type &  object, const Type &  operand  )

inline

References add().

template<class Type , class OperandT >

enable_if<is_intra_derivative<Type, OperandT>, Type>::type& boost::icl::operator+=	(	Type &	object,
		const OperandT &	operand
	)

References add().

template<class Type , class OperandT >

enable_if<is_intra_combinable<Type, OperandT>, Type>::type& boost::icl::operator+=	(	Type &	object,
		const OperandT &	operand
	)

Requires: OperandT is an interval container addable to Type.

Effects: operand is added to object.

Returns: A reference to object.

Complexity: loglinear

References add().

template<class Type >

enable_if<is_element_map<Type>, Type>::type boost::icl::operator- ( Type  object, const typename Type::set_type &  subtrahend  )

inline

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type boost::icl::operator- ( Type  object, const typename Type::value_type &  operand  )

inline

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type boost::icl::operator- ( Type  object, const Type &  subtrahend  )

inline

template<class Type , class OperandT >

enable_if<is_right_inter_combinable<Type, OperandT>, Type>::type boost::icl::operator-	(	const Type &	object,
		const OperandT &	operand
	)

References boost::move().

template<class Type , class OperandT >

enable_if<is_right_inter_combinable<Type, OperandT>, Type>::type boost::icl::operator-	(	Type &&	object,
		const OperandT &	operand
	)

References boost::move().

boost::posix_time::ptime boost::icl::operator-- ( boost::posix_time::ptime &  x )

inline

boost::gregorian::date boost::icl::operator-- ( boost::gregorian::date &  x )

inline

References boost::gregorian::date_duration::unit().

boost::posix_time::time_duration boost::icl::operator-- ( boost::posix_time::time_duration &  x )

inline

boost::gregorian::date_duration boost::icl::operator-- ( boost::gregorian::date_duration &  x )

inline

References boost::gregorian::date_duration::unit().

template<class Type >

enable_if<is_element_map<Type>, Type>::type& boost::icl::operator-= ( Type &  object, const typename Type::set_type &  operand  )

inline

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type& boost::icl::operator-= ( Type &  object, const typename Type::value_type &  operand  )

inline

References subtract().

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type& boost::icl::operator-= ( Type &  object, const Type &  subtrahend  )

inline

References subtract().

template<class Type , class OperandT >

enable_if<is_concept_compatible<is_interval_map, Type, OperandT>, Type>::type& boost::icl::operator-=	(	Type &	object,
		const OperandT &	operand
	)

Requires: Types Type and OperandT are subtractable.

Effects: operand is subtracted from object.

Returns: A reference to object.

Complexity:

                  \ OperandT:                      interval
                   \         element    segment    container
Type:
       interval container    O(log n)     O(n)     O(m log(n+m))

                                       amortized
            interval_sets               O(log n) 

n = object.interval_count()
m = operand.interval_count()

For the subtraction of elements, segments and interval containers complexity is logarithmic, linear and loglinear respectively. For interval sets subtraction of segments is amortized logarithmic.

References subtract().

template<class Type , class OperandT >

enable_if<is_intra_derivative<Type, OperandT>, Type>::type& boost::icl::operator-=	(	Type &	object,
		const OperandT &	operand
	)

References subtract().

template<class Type , class OperandT >

enable_if<is_cross_derivative<Type, OperandT>, Type>::type& boost::icl::operator-=	(	Type &	object,
		const OperandT &	operand
	)

References erase().

template<class Type , class IntervalSetT >

enable_if<combines_right_to_interval_set<Type, IntervalSetT>, Type>::type& boost::icl::operator-=	(	Type &	object,
		const IntervalSetT &	operand
	)

References erase().

template<class Type >

enable_if<is_interval_container<Type>, bool>::type boost::icl::operator< ( const Type &  left, const Type &  right  )

inline

References boost::algorithm::lexicographical_compare().

template<class Type >

enable_if<is_associative_element_container<Type>, bool>::type boost::icl::operator< ( const Type &  left, const Type &  right  )

inline

References boost::algorithm::lexicographical_compare().

template<class Type >

boost::enable_if<is_interval<Type>, bool>::type boost::icl::operator<	(	const Type &	left,
		const Type &	right
	)

References is_empty(), lower_equal(), lower_less(), and upper_less().

interval_bounds boost::icl::operator<< ( interval_bounds  bounds, unsigned int  shift  )

inline

References boost::icl::interval_bounds::_bits.

template<class CharType , class CharTraits >

std::basic_ostream<CharType, CharTraits>& boost::icl::operator<<	(	std::basic_ostream< CharType, CharTraits > &	stream,
		interval_bounds const &	object
	)

References left_bracket(), and right_bracket().

template<class CharType , class CharTraits , class Type >

enable_if<is_element_set<Type>, std::basic_ostream<CharType, CharTraits> >::type& boost::icl::operator<< ( std::basic_ostream< CharType, CharTraits > &  stream, const Type &  object  )

inline

References boost::it.

template<class CharType , class CharTraits , class Type >

enable_if<is_interval_set<Type>, std::basic_ostream<CharType, CharTraits> >::type& boost::icl::operator<<	(	std::basic_ostream< CharType, CharTraits > &	stream,
		const Type &	object
	)

template<class CharType , class CharTraits , class Type >

enable_if<is_element_map<Type>, std::basic_ostream<CharType, CharTraits> >::type& boost::icl::operator<< ( std::basic_ostream< CharType, CharTraits > &  stream, const Type &  object  )

inline

References boost::it.

template<class CharType , class CharTraits , class Type >

enable_if<is_interval_map<Type>, std::basic_ostream<CharType, CharTraits> >::type& boost::icl::operator<<	(	std::basic_ostream< CharType, CharTraits > &	stream,
		const Type &	object
	)

template<class CharType , class CharTraits , class Type >

boost::enable_if<is_interval<Type>, std::basic_ostream<CharType, CharTraits> >::type& boost::icl::operator<<	(	std::basic_ostream< CharType, CharTraits > &	stream,
		Type const &	object
	)

References is_empty(), and boost::icl::interval_traits< Type >::upper().

template<class Type >

enable_if<is_icl_container<Type>, bool>::type boost::icl::operator<= ( const Type &  left, const Type &  right  )

inline

Partial ordering which is induced by Compare.

References right().

bool boost::icl::operator== ( const interval_bounds  x1, const interval_bounds  x2  )

inline

References boost::icl::interval_bounds::_bits.

template<class Type >

enable_if<is_interval_container<Type>, bool>::type boost::icl::operator== ( const Type &  left, const Type &  right  )

inline

template<class Type >

enable_if<is_associative_element_container<Type>, bool>::type boost::icl::operator== ( const Type &  left, const Type &  right  )

inline

Standard equality, which is lexicographical equality of the sets as sequences, that are given by their Compare order.

References boost::algorithm::detail::equal().

template<class Type >

boost::enable_if<is_interval<Type>, bool>::type boost::icl::operator==	(	const Type &	left,
		const Type &	right
	)

References is_empty(), lower_equal(), and upper_equal().

template<class Type >

enable_if<is_icl_container<Type>, bool>::type boost::icl::operator> ( const Type &  left, const Type &  right  )

inline

References left().

template<class Type >

boost::enable_if<is_interval<Type>, bool>::type boost::icl::operator> ( const Type &  left, const Type &  right  )

inline

References left().

template<class Type >

enable_if<is_icl_container<Type>, bool>::type boost::icl::operator>= ( const Type &  left, const Type &  right  )

inline

References right().

interval_bounds boost::icl::operator>> ( interval_bounds  bounds, unsigned int  shift  )

inline

References boost::icl::interval_bounds::_bits.

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type boost::icl::operator^ ( Type  object, const typename Type::value_type &  operand  )

inline

References flip().

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type boost::icl::operator^ ( const typename Type::value_type &  operand, Type  object  )

inline

References flip().

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type boost::icl::operator^ ( Type  object, const Type &  operand  )

inline

template<class Type , class OperandT >

enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type boost::icl::operator^	(	const Type &	object,
		const OperandT &	operand
	)

References boost::move().

template<class Type , class OperandT >

enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type boost::icl::operator^	(	Type &&	object,
		const OperandT &	operand
	)

References boost::move().

template<class Type , class OperandT >

enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type boost::icl::operator^	(	const OperandT &	operand,
		const Type &	object
	)

References boost::move().

template<class Type , class OperandT >

enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type boost::icl::operator^	(	const OperandT &	operand,
		Type &&	object
	)

References boost::move().

template<class Type >

enable_if<is_interval_container<Type>, Type>::type boost::icl::operator^	(	const Type &	object,
		const Type &	operand
	)

References boost::move().

template<class Type >

enable_if<is_interval_container<Type>, Type>::type boost::icl::operator^	(	Type &&	object,
		const Type &	operand
	)

References boost::move().

template<class Type >

enable_if<is_interval_container<Type>, Type>::type boost::icl::operator^	(	const Type &	operand,
		Type &&	object
	)

References boost::move().

template<class Type >

enable_if<is_interval_container<Type>, Type>::type boost::icl::operator^	(	Type &&	object,
		Type &&	operand
	)

References boost::move().

template<class Type >

enable_if<is_element_set<Type>, Type>::type& boost::icl::operator^= ( Type &  object, const typename Type::element_type &  operand  )

inline

References flip().

template<class Type >

enable_if<is_element_set<Type>, Type>::type& boost::icl::operator^= ( Type &  object, const Type &  operand  )

inline

Symmetric subtract map x2 and *this.

So *this becomes the symmetric difference of *this and x2

References flip().

template<class Type , class CoType >

enable_if< mpl::and_< is_element_map<Type> , is_total<Type> , absorbs_identities<Type> > , Type>::type& boost::icl::operator^= ( Type &  object, const CoType &    )

inline

References clear().

template<class Type >

enable_if< mpl::and_< is_element_map<Type> , is_total<Type> , mpl::not_<absorbs_identities<Type> > > , Type>::type& boost::icl::operator^= ( Type &  object, const typename Type::element_type &  operand  )

inline

template<class Type >

enable_if< mpl::and_< is_element_map<Type> , is_total<Type> , mpl::not_<absorbs_identities<Type> > > , Type>::type& boost::icl::operator^= ( Type &  object, const Type &  operand  )

inline

References flip(), and boost::icl::identity_element< Type >::value().

template<class Type >

enable_if< mpl::and_< is_element_map<Type> , mpl::not_<is_total<Type> > > , Type>::type& boost::icl::operator^= ( Type &  object, const typename Type::element_type &  operand  )

inline

References flip().

template<class Type >

enable_if< mpl::and_< is_element_map<Type> , mpl::not_<is_total<Type> > > , Type>::type& boost::icl::operator^= ( Type &  object, const Type &  operand  )

inline

References flip().

template<class Type , class OperandT >

enable_if<is_intra_combinable<Type, OperandT>, Type>::type& boost::icl::operator^=	(	Type &	object,
		const OperandT &	operand
	)

References flip().

template<class Type , class OperandT >

enable_if<is_intra_derivative<Type, OperandT>, Type>::type& boost::icl::operator^=	(	Type &	object,
		const OperandT &	operand
	)

References flip().

interval_bounds boost::icl::operator| ( interval_bounds  x1, interval_bounds  x2  )

inline

References boost::icl::interval_bounds::_bits.

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type boost::icl::operator| ( Type  object, const typename Type::value_type &  operand  )

inline

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type boost::icl::operator| ( const typename Type::value_type &  operand, Type  object  )

inline

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type boost::icl::operator| ( Type  object, const Type &  operand  )

inline

template<class Type , class OperandT >

enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type boost::icl::operator|	(	const Type &	object,
		const OperandT &	operand
	)

References boost::move().

template<class Type , class OperandT >

enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type boost::icl::operator|	(	Type &&	object,
		const OperandT &	operand
	)

References boost::move().

template<class Type , class OperandT >

enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type boost::icl::operator|	(	const OperandT &	operand,
		const Type &	object
	)

References boost::move().

template<class Type , class OperandT >

enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type boost::icl::operator|	(	const OperandT &	operand,
		Type &&	object
	)

References boost::move().

template<class Type >

enable_if<is_interval_container<Type>, Type>::type boost::icl::operator|	(	const Type &	object,
		const Type &	operand
	)

References boost::move().

template<class Type >

enable_if<is_interval_container<Type>, Type>::type boost::icl::operator|	(	Type &&	object,
		const Type &	operand
	)

References boost::move().

template<class Type >

enable_if<is_interval_container<Type>, Type>::type boost::icl::operator|	(	const Type &	operand,
		Type &&	object
	)

References boost::move().

template<class Type >

enable_if<is_interval_container<Type>, Type>::type boost::icl::operator|	(	Type &&	object,
		Type &&	operand
	)

References boost::move().

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type& boost::icl::operator|= ( Type &  object, const typename Type::value_type &  operand  )

inline

References add().

template<class Type >

enable_if<is_associative_element_container<Type>, Type>::type& boost::icl::operator|= ( Type &  object, const Type &  operand  )

inline

template<class Type , class OperandT >

enable_if<is_right_intra_combinable<Type, OperandT>, Type>::type& boost::icl::operator|=	(	Type &	object,
		const OperandT &	operand
	)

Requires: Types Type and OperandT are addable.

Effects: operand is added to object.

Returns: A reference to object.

Complexity:

                  \ OperandT:                      interval
                   \         element     segment   container
Type:
       interval container    O(log n)     O(n)     O(m log(n+m))

             interval_set               amortized
    spearate_interval_set                O(log n) 

n = object.interval_count()
m = operand.interval_count()

For the addition of elements, segments and interval containers complexity is logarithmic, linear and loglinear respectively. For interval_sets and separate_interval_sets addition of segments is amortized logarithmic.

interval_bounds boost::icl::operator~ ( interval_bounds  x1 )

inline

References boost::icl::interval_bounds::_bits, and all().

interval_bounds boost::icl::outer_bounds ( interval_bounds  x1, interval_bounds  x2  )

inline

References left(), and right().

Referenced by outer_bounds().

template<class IntervalT >

boost::enable_if<has_dynamic_bounds<IntervalT>, interval_bounds>::type boost::icl::outer_bounds ( const IntervalT &  x1, const IntervalT &  x2  )

inline

References outer_bounds().

template<class Type >

enable_if<has_dynamic_bounds<Type>, typename Type::bounded_domain_type>::type boost::icl::reverse_bounded_lower

(

const Type &

object

)

References bounds(), and lower().

Referenced by right_subtract().

template<class Type >

enable_if<has_dynamic_bounds<Type>, typename Type::bounded_domain_type>::type boost::icl::reverse_bounded_upper

(

const Type &

object

)

References bounds(), and upper().

Referenced by left_subtract().

interval_bounds boost::icl::right ( interval_bounds  x1 )

inline

References boost::icl::interval_bounds::_bits.

Referenced by boost::geometry::detail::compare::compare_loop< Direction, Point, Strategy, Dimension, DimensionCount >::apply(), boost::typeindex::type_index_facade< ctti_type_index, detail::ctti_data >::before(), bounded_upper(), boost::test_tools::tt_detail::equal_impl_frwd::call_impl(), boost::chrobak_payne_straight_line_drawing(), domain_equal(), domain_less(), domain_less_equal(), boost::typeindex::type_index_facade< ctti_type_index, detail::ctti_data >::equal(), boost::test_tools::tt_detail::equal_impl(), boost::fusion::erase(), boost::spirit::longest_parser_gen::generate(), boost::spirit::shortest_parser_gen::generate(), hull(), boost::fusion::insert(), boost::fusion::insert_range(), is_element_equal(), left_subtract(), left_subtract_bounds(), boost::geometry::strategy::buffer::distance_asymmetric< NumericType >::max_distance(), operator!=(), boost::operator!=(), boost::statechart::state_machine< MostDerived, InitialState, Allocator, ExceptionTranslator >::state_iterator::operator!=(), boost::geometry::detail::compare::compare_in_one_dimension< Point, strategy::compare::detail::select_strategy< Strategy, Direction, Point, Dimension >::type, Dimension >::operator()(), boost::attribute_value_ordering< ValueT, FunT >::operator()(), boost::numeric::functional::max_assign_base< Left, Right, void >::operator()(), boost::test_tools::tt_detail::ne_impl::operator()(), boost::test_tools::tt_detail::lt_impl::operator()(), boost::test_tools::tt_detail::le_impl::operator()(), boost::test_tools::tt_detail::gt_impl::operator()(), boost::test_tools::tt_detail::ge_impl::operator()(), boost::operator<(), boost::operator<<(), boost::uuids::operator<<(), operator<=(), boost::operator<=(), boost::operator>(), operator>=(), boost::operator>=(), outer_bounds(), right_bounds(), boost::graph::distributed::detail::parallel_dfs< DistributedGraph, ColorMap, ParentMap, ExploreMap, VertexIndexMap, DFSVisitor >::run(), boost::geometry::strategy::buffer::distance_asymmetric< NumericType >::simplify_distance(), span(), boost::swap(), boost_swap_impl::swap_impl(), and boost::gil::swap_proxy().

interval_bounds boost::icl::right_bounds ( interval_bounds  x1, interval_bounds  x2  )

inline

References right().

Referenced by right_bounds(), and upper_less().

template<class IntervalT >

boost::enable_if<has_dynamic_bounds<IntervalT>, interval_bounds>::type boost::icl::right_bounds ( const IntervalT &  x1, const IntervalT &  x2  )

inline

References right_bounds().

std::string boost::icl::right_bracket ( interval_bounds  bounds )

inline

References is_right_closed().

template<class Type >

boost:: enable_if< mpl::or_< is_static_right_open<Type> , is_static_open<Type> >, std::string>::type boost::icl::right_bracket

(

const Type &

)

Referenced by operator<<(), and right_bracket().

template<class Type >

boost:: enable_if< mpl::or_< is_static_left_open<Type> , is_static_closed<Type> >, std::string>::type boost::icl::right_bracket

(

const Type &

)

template<class Type >

boost::enable_if<has_dynamic_bounds<Type>, std::string>::type boost::icl::right_bracket

(

const Type &

object

)

References bounds(), and right_bracket().

template<class Type >

boost::enable_if<is_asymmetric_interval<Type>, Type>::type boost::icl::right_subtract	(	Type	left,
		const Type &	right_minuend
	)

subtract right_minuend from the left interval on it's right side.

Return the difference: The part of left right of right_minuend.

left_over = left - right_minuend; //on the right side.
[a      ...  : left
     [b ...  : right_minuend
[a  b)       : left_over

References exclusive_less(), left(), and lower().

Referenced by boost::icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::add_front(), boost::icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::add_rear(), boost::icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::add_segment(), boost::icl::interval_base_map< SubType, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::erase(), flip(), inner_complement(), and boost::icl::interval_base_set< SubType, DomainT, Compare, Interval, Alloc >::subtract().

template<class Type >

boost::enable_if<is_static_closed<Type>, Type>::type boost::icl::right_subtract	(	Type	left,
		const Type &	right_minuend
	)

References exclusive_less(), left(), lower(), lower_less_equal(), and boost::icl::identity_element< Type >::value().

template<class Type >

boost::enable_if<is_static_open<Type>, Type>::type boost::icl::right_subtract	(	Type	left,
		const Type &	right_minuend
	)

References exclusive_less(), left(), and lower().

template<class Type >

boost::enable_if<has_dynamic_bounds<Type>, Type>::type boost::icl::right_subtract	(	Type	left,
		const Type &	right_minuend
	)

References bounded_lower(), boost::icl::dynamic_interval_traits< Type >::construct_bounded(), exclusive_less(), left(), and reverse_bounded_lower().

interval_bounds boost::icl::right_subtract_bounds ( interval_bounds  x1, interval_bounds  x2  )

inline

References left().

Referenced by right_subtract_bounds().

template<class IntervalT >

boost::enable_if<has_dynamic_bounds<IntervalT>, interval_bounds>::type boost::icl::right_subtract_bounds ( const IntervalT &  x1, const IntervalT &  x2  )

inline

References right_subtract_bounds().

template<class Type >

enable_if<is_element_map<Type>, Type>::type& boost::icl::set_at ( Type &  object, const typename Type::element_type &  operand  )

inline

References boost::program_options::value().

Referenced by boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::set(), boost::icl::interval_base_map< interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::set(), and set_at().

template<class Type >

enable_if<is_interval_map<Type>, Type>::type& boost::icl::set_at	(	Type &	object,
		const typename Type::segment_type &	operand
	)

References erase(), and insert().

template<class Type >

enable_if<is_interval_map<Type>, Type>::type& boost::icl::set_at	(	Type &	object,
		const typename Type::element_type &	operand
	)

References set_at().

template<class Type >

enable_if<is_discrete<Type>, Type>::type boost::icl::shift_lower ( interval_bounds  decl, interval_bounds  repr, const Type &  low  )

inline

References is_left_closed(), and boost::polygon::low().

Referenced by boost::icl::static_interval< IntervalT, true, PretendedBounds, RepresentedBounds >::construct().

template<class Type >

enable_if<is_discrete<Type>, Type>::type boost::icl::shift_upper ( interval_bounds  decl, interval_bounds  repr, const Type &  up  )

inline

References is_right_closed().

Referenced by boost::icl::static_interval< IntervalT, true, PretendedBounds, RepresentedBounds >::construct().

template<class Type >

enable_if< mpl::and_< is_static_right_open<Type> , is_discrete<typename interval_traits<Type>::domain_type> > , Type>::type boost::icl::singleton

(

const typename interval_traits< Type >::domain_type &

value

)

References boost::icl::interval_traits< Type >::construct().

template<class Type >

enable_if< mpl::and_< is_static_left_open<Type> , is_discrete<typename interval_traits<Type>::domain_type> > , Type>::type boost::icl::singleton

(

const typename interval_traits< Type >::domain_type &

value

)

References BOOST_ASSERT, boost::icl::interval_traits< Type >::construct(), and boost::serialization::is_less_than().

template<class Type >

enable_if<is_discrete_static_open<Type>, Type>::type boost::icl::singleton

(

const typename interval_traits< Type >::domain_type &

value

)

References BOOST_ASSERT, boost::icl::interval_traits< Type >::construct(), and boost::serialization::is_less_than().

template<class Type >

enable_if<is_discrete_static_closed<Type>, Type>::type boost::icl::singleton

(

const typename interval_traits< Type >::domain_type &

value

)

References boost::icl::interval_traits< Type >::construct().

template<class Type >

enable_if<has_dynamic_bounds<Type>, Type>::type boost::icl::singleton

(

const typename interval_traits< Type >::domain_type &

value

)

References boost::icl::interval_bounds::closed(), and boost::icl::dynamic_interval_traits< Type >::construct().

template<class Type >

enable_if<is_associative_element_container<Type>, typename Type::size_type>::type boost::icl::size

(

const Type &

object

)

References iterative_size().

Referenced by cardinality().

template<class Type >

enable_if<is_interval_container<Type>, typename Type::size_type>::type boost::icl::size ( const Type &  object )

inline

References cardinality().

template<class Type >

enable_if<is_interval<Type>, typename size_type_of<interval_traits<Type> >::type>::type boost::icl::size ( const Type &  object )

inline

References cardinality().

template<class Type >

enable_if<is_interval<Type>, Type>::type boost::icl::span	(	const typename interval_traits< Type >::domain_type &	left,
		const typename interval_traits< Type >::domain_type &	right
	)

References left(), and right().

Referenced by flip().

template<class Type >

enable_if<is_element_set<Type>, Type>::type& boost::icl::subtract	(	Type &	object,
		const typename Type::value_type &	operand
	)

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

template<class Type >

enable_if<is_interval_set<Type>, Type>::type& boost::icl::subtract	(	Type &	object,
		const typename Type::segment_type &	operand
	)

template<class Type >

enable_if<is_interval_set<Type>, Type>::type& boost::icl::subtract ( Type &  object, const typename Type::element_type &  operand  )

inline

References subtract().

template<class Type >

enable_if<is_element_map<Type>, Type>::type& boost::icl::subtract ( Type &  object, const typename Type::element_type &  operand  )

inline

Referenced by erase(), boost::icl::interval_base_set< split_interval_set< DomainT, Compare, Interval, Alloc >, DomainT, Compare, Interval, Alloc >::erase(), boost::asio::basic_socket_streambuf< Protocol, StreamSocketService, Time, TimeTraits, TimerService >::expires_from_now(), flip(), operator-=(), subtract(), boost::icl::interval_base_set< split_interval_set< DomainT, Compare, Interval, Alloc >, DomainT, Compare, Interval, Alloc >::subtract(), boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::subtract(), and boost::icl::interval_base_map< interval_map< DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >, DomainT, CodomainT, Traits, Compare, Combine, Section, Interval, Alloc >::subtract().

template<class Type >

enable_if<is_element_map<Type>, Type>::type& boost::icl::subtract	(	Type &	object,
		const typename Type::domain_type &	key_value
	)

References erase().

template<class Type >

enable_if<is_interval_map<Type>, Type>::type& boost::icl::subtract	(	Type &	object,
		const typename Type::segment_type &	operand
	)

template<class Type >

enable_if<is_interval_map<Type>, Type>::type& boost::icl::subtract	(	Type &	object,
		const typename Type::element_type &	operand
	)

References subtract().

template<class Type >

enable_if<is_interval_map<Type>, Type>::type& boost::icl::subtract	(	Type &	object,
		const typename Type::domain_type &	operand
	)

template<class Type >

enable_if<is_interval_map<Type>, Type>::type& boost::icl::subtract	(	Type &	object,
		const typename Type::interval_type &	operand
	)

template<class Type >

enable_if<is_container<Type>, void>::type boost::icl::swap	(	Type &	left,
		Type &	right
	)

template<class Type >

boost::enable_if<is_asymmetric_interval<Type>, bool>::type boost::icl::touches	(	const Type &	left,
		const Type &	right
	)

References lower(), and upper().

Referenced by boost::icl::segmental::is_joinable().

template<class Type >

boost::enable_if<has_symmetric_bounds<Type>, bool>::type boost::icl::touches	(	const Type &	left,
		const Type &	right
	)

References first(), and last_next().

template<class Type >

boost::enable_if<is_discrete_interval<Type>, bool>::type boost::icl::touches	(	const Type &	left,
		const Type &	right
	)

References first(), and last().

template<class Type >

boost::enable_if<is_continuous_interval<Type>, bool>::type boost::icl::touches	(	const Type &	left,
		const Type &	right
	)

References inner_bounds(), is_complementary(), lower(), and upper().

template<class Type >

enable_if<is_interval_container<Type>, typename domain_type_of<Type>::type>::type boost::icl::upper

(

const Type &

object

)

References is_empty(), boost::rbegin(), upper(), and boost::icl::identity_element< Type >::value().

template<class Type >

enable_if<is_interval<Type>, typename interval_traits<Type>::domain_type>::type boost::icl::upper ( const Type &  object )

inline

References boost::icl::interval_traits< Type >::upper().

Referenced by bounded_upper(), cardinality(), contains(), distance(), boost::icl::non_empty::exclusive_less(), exclusive_less(), hull(), inner_complement(), is_empty(), last(), last_next(), left_subtract(), length(), operator&(), reverse_bounded_upper(), touches(), upper(), upper_equal(), and upper_less().

template<class Type >

boost::enable_if<is_asymmetric_interval<Type>, bool>::type boost::icl::upper_equal	(	const Type &	left,
		const Type &	right
	)

References upper().

Referenced by operator==(), and upper_less_equal().

template<class Type >

boost::enable_if<has_symmetric_bounds<Type>, bool>::type boost::icl::upper_equal	(	const Type &	left,
		const Type &	right
	)

References last().

template<class Type >

boost::enable_if<is_discrete_interval<Type>, bool>::type boost::icl::upper_equal	(	const Type &	left,
		const Type &	right
	)

References last().

template<class Type >

boost::enable_if<is_continuous_interval<Type>, bool>::type boost::icl::upper_equal	(	const Type &	left,
		const Type &	right
	)

References upper().

template<class Type >

boost::enable_if<has_static_bounds<Type>, bool>::type boost::icl::upper_less	(	const Type &	left,
		const Type &	right
	)

References upper().

Referenced by operator<(), upper_less_equal(), upper_max(), and upper_min().

template<class Type >

boost::enable_if<is_discrete_interval<Type>, bool>::type boost::icl::upper_less	(	const Type &	left,
		const Type &	right
	)

References last().

template<class Type >

boost::enable_if<is_continuous_interval<Type>, bool>::type boost::icl::upper_less	(	const Type &	left,
		const Type &	right
	)

References boost::icl::interval_bounds::left_open(), right_bounds(), and upper().

template<class Type >

boost::enable_if<is_interval<Type>, bool>::type boost::icl::upper_less_equal	(	const Type &	left,
		const Type &	right
	)

References upper_equal(), and upper_less().

Referenced by boost::icl::non_empty::contains().

template<class Type >

boost::enable_if<has_dynamic_bounds<Type>, typename Type::bounded_domain_type >::type boost::icl::upper_max	(	const Type &	left,
		const Type &	right
	)

References bounded_upper(), and upper_less().

Referenced by hull().

template<class Type >

boost::enable_if<has_dynamic_bounds<Type>, typename Type::bounded_domain_type >::type boost::icl::upper_min	(	const Type &	left,
		const Type &	right
	)

References bounded_upper(), and upper_less().

Referenced by operator&().

template<class SubT , class SuperT >

enable_if<is_interval_container<SuperT>, bool>::type boost::icl::within	(	const SubT &	sub,
		const SuperT &	super
	)

References contains().

template<class Type >

enable_if<is_element_map<Type>, bool>::type boost::icl::within	(	const typename Type::element_type &	value_pair,
		const Type &	super
	)

Checks if a key-value pair is in the map.

template<class Type >

enable_if<is_associative_element_container<Type>, bool>::type boost::icl::within	(	const typename Type::key_type &	key,
		const Type &	super
	)

Checks if a key is in the associative container.

Referenced by contains().

template<class SubT , class SuperT >

enable_if<mpl::and_< is_associative_element_container<SuperT> , is_key_container_of<SubT, SuperT> >, bool>::type boost::icl::within	(	const SubT &	sub,
		const SuperT &	super
	)

References is_empty().

template<class Type >

boost::enable_if<is_interval<Type>, bool>::type boost::icl::within ( const Type &  sub, const Type &  super  )

inline

References contains().