Interval Template Library Reference

Header <boost/itl/functions.hpp>
Header <boost/itl/functors.hpp>
Header <boost/itl/gregorian.hpp>
Header <boost/itl/impl_config.hpp>
Header <boost/itl/interval.hpp>
Header <boost/itl/interval_base_map.hpp>
Header <boost/itl/interval_base_set.hpp>
Header <boost/itl/interval_map.hpp>
Header <boost/itl/interval_set.hpp>
Header <boost/itl/iterator.hpp>
Header <boost/itl/map.hpp>
Header <boost/itl/predicates.hpp>
Header <boost/itl/ptime.hpp>
Header <boost/itl/rational.hpp>
Header <boost/itl/separate_interval_set.hpp>
Header <boost/itl/set.hpp>
Header <boost/itl/split_interval_map.hpp>
Header <boost/itl/split_interval_set.hpp>

Header <boost/itl/functions.hpp>

namespace boost {
  namespace itl {
    template<class LeftT , class RightT > 
      boost::enable_if< is_intra_combinable< LeftT, RightT >, bool >::type 
      is_element_equal(const LeftT &, const RightT &);
    template<class LeftT , class RightT > 
      boost::enable_if< is_intra_combinable< LeftT, RightT >, bool >::type 
      is_element_less(const LeftT &, const RightT &);
    template<class LeftT , class RightT > 
      boost::enable_if< is_intra_combinable< LeftT, RightT >, bool >::type 
      is_element_greater(const LeftT &, const RightT &);
    template<class LeftT , class RightT > 
      boost::enable_if< is_inter_combinable< LeftT, RightT >, int >::type 
      inclusion_compare(const LeftT & left, const RightT & right);
    template<class ObjectT , class OperandT > 
      boost::enable_if< is_intra_combinable< ObjectT, OperandT >, ObjectT >::type & 
      operator+=(ObjectT &, const OperandT &);
    template<class ObjectT , class OperandT > 
      boost::enable_if< is_binary_intra_combinable< ObjectT, OperandT >, ObjectT >::type 
      operator+(ObjectT, const OperandT &);
    template<class ObjectT , class OperandT > 
      boost::enable_if< is_binary_intra_combinable< ObjectT, OperandT >, ObjectT >::type 
      operator+(const OperandT &, ObjectT);
    template<class ObjectT > 
      ObjectT operator+(typename ObjectT::overloadable_type, const ObjectT &);
    template<class ObjectT , class OperandT > 
      boost::enable_if< is_right_intra_combinable< ObjectT, OperandT >, ObjectT >::type & 
      operator|=(ObjectT &, const OperandT &);
    template<class ObjectT , class OperandT > 
      boost::enable_if< is_binary_intra_combinable< ObjectT, OperandT >, ObjectT >::type 
      operator|(ObjectT, const OperandT &);
    template<class ObjectT , class OperandT > 
      boost::enable_if< is_binary_intra_combinable< ObjectT, OperandT >, ObjectT >::type 
      operator|(const OperandT &, ObjectT);
    template<class ObjectT > 
      ObjectT operator|(typename ObjectT::overloadable_type, const ObjectT &);
    template<class ObjectT , class OperandT > 
      boost::enable_if< is_concept_equivalent< is_interval_map, ObjectT, OperandT >, ObjectT >::type & 
      operator-=(ObjectT &, const OperandT &);
    template<class ObjectT , class IntervalSetT > 
      boost::enable_if< combines_right_to_interval_set< ObjectT, IntervalSetT >, ObjectT >::type & 
      operator-=(ObjectT & object, const IntervalSetT & operand);
    template<class ObjectT , class OperandT > 
      boost::enable_if< is_right_inter_combinable< ObjectT, OperandT >, ObjectT >::type 
      operator-(ObjectT object, const OperandT & operand);
    template<class ObjectT , class OperandT > 
      boost::enable_if< is_intra_combinable< ObjectT, OperandT >, ObjectT >::type & 
      insert(ObjectT & object, const OperandT & operand);
    template<class ObjectT , class OperandT > 
      boost::enable_if< combines_right_to_interval_container< ObjectT, OperandT >, ObjectT >::type & 
      erase(ObjectT & object, const OperandT & operand);
    template<class ObjectT , class OperandT > 
      boost::enable_if< is_right_inter_combinable< ObjectT, OperandT >, ObjectT >::type & 
      operator&=(ObjectT & object, const OperandT & operand);
    template<class ObjectT , class OperandT > 
      boost::enable_if< is_binary_inter_combinable< ObjectT, OperandT >, ObjectT >::type 
      operator&(ObjectT object, const OperandT & operand);
    template<class ObjectT , class OperandT > 
      boost::enable_if< is_binary_inter_combinable< ObjectT, OperandT >, ObjectT >::type 
      operator&(const OperandT & operand, ObjectT object);
    template<class ObjectT > 
      ObjectT operator&(typename ObjectT::overloadable_type object, 
                        const ObjectT & operand);
    template<class LeftT , class RightT > 
      boost::enable_if< is_intra_combinable< LeftT, RightT >, bool >::type 
      intersects(const LeftT & left, const RightT & right);
    template<class Type , class AssociateT > 
      boost::enable_if< is_inter_derivative< Type, AssociateT >, bool >::type 
      intersects(const Type & left, const AssociateT & right);
    template<class LeftT , class RightT > 
      boost::enable_if< is_inter_combinable< LeftT, RightT >, bool >::type 
      is_disjoint(const LeftT &, const RightT &);
    template<class Type , class AssociateT > 
      boost::enable_if< is_inter_derivative< Type, AssociateT >, bool >::type 
      is_disjoint(const Type &, const AssociateT &);
    template<class ObjectT , class OperandT > 
      boost::enable_if< is_intra_combinable< ObjectT, OperandT >, ObjectT >::type & 
      operator^=(ObjectT & object, const OperandT & operand);
    template<class ObjectT , class OperandT > 
      boost::enable_if< is_binary_intra_combinable< ObjectT, OperandT >, ObjectT >::type 
      operator^(ObjectT object, const OperandT & operand);
    template<class ObjectT , class OperandT > 
      boost::enable_if< is_binary_intra_combinable< ObjectT, OperandT >, ObjectT >::type 
      operator^(const OperandT & operand, ObjectT object);
    template<class ObjectT > 
      ObjectT operator^(typename ObjectT::overloadable_type object, 
                        const ObjectT & operand);
    template<class ObjectT > 
      boost::enable_if< is_interval_container< ObjectT >, typename ObjectT::interval_type >::type 
      hull(const ObjectT & object);
  }
}