import new upstream nautilus stable release 14.2.8

[ceph.git] / ceph / src / boost / boost / icl / concept / interval.hpp

diff --git a/ceph/src/boost/boost/icl/concept/interval.hpp b/ceph/src/boost/boost/icl/concept/interval.hpp
index 487d424abdc129df1b612c28da21693526ade914..1a4654a8d29cc206d849330386e86c1f51d5bdeb 100644 (file)
--- a/ceph/src/boost/boost/icl/concept/interval.hpp
+++ b/ceph/src/boost/boost/icl/concept/interval.hpp
@@ -8,7 +8,7 @@ Copyright (c) 2010-2010: Joachim Faulhaber
 #ifndef BOOST_ICL_CONCEPT_INTERVAL_HPP_JOFA_100323
 #define BOOST_ICL_CONCEPT_INTERVAL_HPP_JOFA_100323
 
-#include <boost/assert.hpp> 
+#include <boost/assert.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/mpl/and.hpp>
 #include <boost/mpl/or.hpp>
@@ -38,7 +38,7 @@ namespace boost{namespace icl
 //==============================================================================
 template<class Type>
 inline typename enable_if<is_interval<Type>, bool>::type
-domain_less(const typename interval_traits<Type>::domain_type& left, 
+domain_less(const typename interval_traits<Type>::domain_type& left,
             const typename interval_traits<Type>::domain_type& right)
 {
     return typename interval_traits<Type>::domain_compare()(left, right);
@@ -46,7 +46,7 @@ domain_less(const typename interval_traits<Type>::domain_type& left,
 
 template<class Type>
 inline typename enable_if<is_interval<Type>, bool>::type
-domain_less_equal(const typename interval_traits<Type>::domain_type& left, 
+domain_less_equal(const typename interval_traits<Type>::domain_type& left,
                   const typename interval_traits<Type>::domain_type& right)
 {
     return !(typename interval_traits<Type>::domain_compare()(right, left));
@@ -54,7 +54,7 @@ domain_less_equal(const typename interval_traits<Type>::domain_type& left,
 
 template<class Type>
 inline typename enable_if<is_interval<Type>, bool>::type
-domain_equal(const typename interval_traits<Type>::domain_type& left, 
+domain_equal(const typename interval_traits<Type>::domain_type& left,
              const typename interval_traits<Type>::domain_type& right)
 {
     typedef typename interval_traits<Type>::domain_compare domain_compare;
@@ -64,7 +64,7 @@ domain_equal(const typename interval_traits<Type>::domain_type& left,
 template<class Type>
 inline typename enable_if< is_interval<Type>
                          , typename interval_traits<Type>::domain_type>::type
-domain_next(const typename interval_traits<Type>::domain_type value) 
+domain_next(const typename interval_traits<Type>::domain_type value)
 {
     typedef typename interval_traits<Type>::domain_type domain_type;
     typedef typename interval_traits<Type>::domain_compare domain_compare;
@@ -74,7 +74,7 @@ domain_next(const typename interval_traits<Type>::domain_type value)
 template<class Type>
 inline typename enable_if< is_interval<Type>
                          , typename interval_traits<Type>::domain_type>::type
-domain_prior(const typename interval_traits<Type>::domain_type value) 
+domain_prior(const typename interval_traits<Type>::domain_type value)
 {
     typedef typename interval_traits<Type>::domain_type domain_type;
     typedef typename interval_traits<Type>::domain_compare domain_compare;
@@ -110,7 +110,7 @@ singleton(const typename interval_traits<Type>::domain_type& value)
     typedef typename interval_traits<Type>::domain_type    domain_type;
     typedef typename interval_traits<Type>::domain_compare domain_compare;
     BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
-                                 ::is_less_than(value) )); 
+                                 ::is_less_than(value) ));
 
     return interval_traits<Type>::construct(domain_prior<Type>(value), value);
 }
@@ -123,7 +123,7 @@ singleton(const typename interval_traits<Type>::domain_type& value)
     typedef typename interval_traits<Type>::domain_type    domain_type;
     typedef typename interval_traits<Type>::domain_compare domain_compare;
     BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
-                                 ::is_less_than(value))); 
+                                 ::is_less_than(value)));
 
     return interval_traits<Type>::construct( domain_prior<Type>(value)
                                            , domain_next<Type>(value));
@@ -149,10 +149,10 @@ namespace detail
 
 //==============================================================================
 //= Construct<Interval> unit_trail == generalized singleton
-// The smallest interval on an incrementable (and decrementable) type that can 
+// The smallest interval on an incrementable (and decrementable) type that can
 // be constructed using ++ and -- and such that it contains a given value.
-// If 'Type' is discrete, 'unit_trail' and 'singleton' are identical. So we 
-// can view 'unit_trail' as a generalized singleton for static intervals of 
+// If 'Type' is discrete, 'unit_trail' and 'singleton' are identical. So we
+// can view 'unit_trail' as a generalized singleton for static intervals of
 // continuous types.
 //==============================================================================
 template<class Type>
@@ -179,7 +179,7 @@ unit_trail(const typename interval_traits<Type>::domain_type& value)
     typedef typename interval_traits<Type>::domain_type    domain_type;
     typedef typename interval_traits<Type>::domain_compare domain_compare;
     BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
-                                 ::is_less_than(value) )); 
+                                 ::is_less_than(value) ));
 
     return interval_traits<Type>::construct(domain_prior<Type>(value), value);
 }
@@ -196,7 +196,7 @@ unit_trail(const typename interval_traits<Type>::domain_type& value)
     typedef typename interval_traits<Type>::domain_type    domain_type;
     typedef typename interval_traits<Type>::domain_compare domain_compare;
     BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
-                                 ::is_less_than(value))); 
+                                 ::is_less_than(value)));
 
     return interval_traits<Type>::construct( domain_prior<Type>(value)
                                            ,  domain_next<Type>(value));
@@ -263,7 +263,8 @@ typename enable_if<is_interval<Type>, Type>::type
 span(const typename interval_traits<Type>::domain_type& left,
      const typename interval_traits<Type>::domain_type& right)
 {
-    if(interval_traits<Type>::domain_compare()(left,right))
+    typedef typename interval_traits<Type>::domain_compare domain_compare;
+    if(domain_compare()(left,right))
         return construct<Type>(left, right);
     else
         return construct<Type>(right, left);
@@ -276,7 +277,8 @@ typename 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)
 {
-    if(interval_traits<Type>::domain_compare()(left,right))
+    typedef typename interval_traits<Type>::domain_compare domain_compare;
+    if(domain_compare()(left,right))
         return construct<Type>(left, domain_next<Type>(right));
     else
         return construct<Type>(right, domain_next<Type>(left));
@@ -289,16 +291,16 @@ hull(const typename interval_traits<Type>::domain_type& left,
 {
     typedef typename interval_traits<Type>::domain_type    domain_type;
     typedef typename interval_traits<Type>::domain_compare domain_compare;
-    if(interval_traits<Type>::domain_compare()(left,right))
+    if(domain_compare()(left,right))
     {
         BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
-                                     ::is_less_than(left) )); 
+                                     ::is_less_than(left) ));
         return construct<Type>(domain_prior<Type>(left), right);
     }
     else
     {
         BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
-                                     ::is_less_than(right) )); 
+                                     ::is_less_than(right) ));
         return construct<Type>(domain_prior<Type>(right), left);
     }
 }
@@ -308,7 +310,8 @@ typename 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)
 {
-    if(interval_traits<Type>::domain_compare()(left,right))
+    typedef typename interval_traits<Type>::domain_compare domain_compare;
+    if(domain_compare()(left,right))
         return construct<Type>(left, right);
     else
         return construct<Type>(right, left);
@@ -321,17 +324,17 @@ hull(const typename interval_traits<Type>::domain_type& left,
 {
     typedef typename interval_traits<Type>::domain_type    domain_type;
     typedef typename interval_traits<Type>::domain_compare domain_compare;
-    if(interval_traits<Type>::domain_compare()(left,right))
+    if(domain_compare()(left,right))
     {
         BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
-                                     ::is_less_than(left) )); 
+                                     ::is_less_than(left) ));
         return construct<Type>( domain_prior<Type>(left)
                               ,  domain_next<Type>(right));
     }
     else
     {
         BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
-                                     ::is_less_than(right) )); 
+                                     ::is_less_than(right) ));
         return construct<Type>( domain_prior<Type>(right)
                               ,  domain_next<Type>(left));
     }
@@ -342,7 +345,8 @@ typename 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)
 {
-    if(interval_traits<Type>::domain_compare()(left,right))
+    typedef typename interval_traits<Type>::domain_compare domain_compare;
+    if(domain_compare()(left,right))
         return construct<Type>(left, right, interval_bounds::closed());
     else
         return construct<Type>(right, left, interval_bounds::closed());
@@ -353,160 +357,160 @@ hull(const typename interval_traits<Type>::domain_type& left,
 //==============================================================================
 
 template<class Type>
-inline typename enable_if<is_interval<Type>, 
+inline typename enable_if<is_interval<Type>,
                           typename interval_traits<Type>::domain_type>::type
 lower(const Type& object)
-{ 
+{
     return interval_traits<Type>::lower(object);
 }
 
 template<class Type>
-inline typename enable_if<is_interval<Type>, 
+inline typename enable_if<is_interval<Type>,
                           typename interval_traits<Type>::domain_type>::type
 upper(const Type& object)
-{ 
+{
     return interval_traits<Type>::upper(object);
 }
 
 
 //- first ----------------------------------------------------------------------
 template<class Type>
-inline typename 
+inline typename
 enable_if< mpl::or_<is_static_right_open<Type>, is_static_closed<Type> >
          , typename interval_traits<Type>::domain_type>::type
 first(const Type& object)
-{ 
+{
     return lower(object);
 }
 
 template<class Type>
-inline typename 
+inline typename
 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)
-{ 
+{
     return domain_next<Type>(lower(object));
 }
 
 template<class Type>
-inline typename enable_if<is_discrete_interval<Type>, 
+inline typename enable_if<is_discrete_interval<Type>,
                           typename interval_traits<Type>::domain_type>::type
 first(const Type& object)
-{ 
-    return is_left_closed(object.bounds()) ? 
-                                 lower(object) : 
+{
+    return is_left_closed(object.bounds()) ?
+                                 lower(object) :
                domain_next<Type>(lower(object));
 }
 
 //- last -----------------------------------------------------------------------
 template<class Type>
-inline typename 
+inline typename
 enable_if< mpl::or_<is_static_left_open<Type>, is_static_closed<Type> >
          , typename interval_traits<Type>::domain_type>::type
 last(const Type& object)
-{ 
+{
     return upper(object);
 }
 
 template<class Type>
-inline typename 
+inline typename
 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)
-{ 
+{
     typedef typename interval_traits<Type>::domain_type    domain_type;
     typedef typename interval_traits<Type>::domain_compare domain_compare;
     BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
-                                 ::is_less_than(upper(object)) )); 
+                                 ::is_less_than(upper(object)) ));
     return domain_prior<Type>(upper(object));
 }
 
 template<class Type>
-inline typename enable_if<is_discrete_interval<Type>, 
+inline typename enable_if<is_discrete_interval<Type>,
                           typename interval_traits<Type>::domain_type>::type
 last(const Type& object)
-{ 
+{
     typedef typename interval_traits<Type>::domain_type    domain_type;
     typedef typename interval_traits<Type>::domain_compare domain_compare;
     BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
-                                 ::is_less_than_or(upper(object), is_right_closed(object.bounds())) )); 
-    return is_right_closed(object.bounds()) ? 
-                                  upper(object) : 
+                                 ::is_less_than_or(upper(object), is_right_closed(object.bounds())) ));
+    return is_right_closed(object.bounds()) ?
+                                  upper(object) :
                domain_prior<Type>(upper(object));
 }
 
 //- last_next ------------------------------------------------------------------
 template<class Type>
-inline typename 
+inline typename
 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)
-{ 
+{
     return domain_next<Type>(upper(object));
 }
 
 template<class Type>
-inline typename 
+inline typename
 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)
-{ 
+{
     //CL typedef typename interval_traits<Type>::domain_type domain_type;
     return upper(object); // NOTE: last_next is implemented to avoid calling pred(object)
 }                         // For unsigned integral types this may cause underflow.
 
 template<class Type>
-inline typename enable_if<is_discrete_interval<Type>, 
+inline typename enable_if<is_discrete_interval<Type>,
                           typename interval_traits<Type>::domain_type>::type
 last_next(const Type& object)
-{ 
-    return is_right_closed(object.bounds()) ? 
-               domain_next<Type>(upper(object)): 
+{
+    return is_right_closed(object.bounds()) ?
+               domain_next<Type>(upper(object)):
                                  upper(object) ;
 }
 
 //------------------------------------------------------------------------------
 template<class Type>
-typename enable_if<has_dynamic_bounds<Type>, 
+typename enable_if<has_dynamic_bounds<Type>,
                    typename Type::bounded_domain_type>::type
 bounded_lower(const Type& object)
-{ 
-    return typename 
-        Type::bounded_domain_type(lower(object), object.bounds().left()); 
+{
+    return typename
+        Type::bounded_domain_type(lower(object), object.bounds().left());
 }
 
 template<class Type>
-typename enable_if<has_dynamic_bounds<Type>, 
+typename enable_if<has_dynamic_bounds<Type>,
                    typename Type::bounded_domain_type>::type
 reverse_bounded_lower(const Type& object)
-{ 
-    return typename 
-        Type::bounded_domain_type(lower(object), 
-                                  object.bounds().reverse_left()); 
+{
+    return typename
+        Type::bounded_domain_type(lower(object),
+                                  object.bounds().reverse_left());
 }
 
 template<class Type>
-typename enable_if<has_dynamic_bounds<Type>, 
+typename enable_if<has_dynamic_bounds<Type>,
                    typename Type::bounded_domain_type>::type
 bounded_upper(const Type& object)
-{ 
-    return typename 
-        Type::bounded_domain_type(upper(object), 
-                                  object.bounds().right()); 
+{
+    return typename
+        Type::bounded_domain_type(upper(object),
+                                  object.bounds().right());
 }
 
 template<class Type>
-typename enable_if<has_dynamic_bounds<Type>, 
+typename enable_if<has_dynamic_bounds<Type>,
                    typename Type::bounded_domain_type>::type
 reverse_bounded_upper(const Type& object)
-{ 
-    return typename 
-        Type::bounded_domain_type(upper(object), 
-                                  object.bounds().reverse_right()); 
+{
+    return typename
+        Type::bounded_domain_type(upper(object),
+                                  object.bounds().reverse_right());
 }
 
 //- bounds ---------------------------------------------------------------------
@@ -532,36 +536,36 @@ bounds(const Type&)
 template<class Type>
 typename boost::enable_if<is_asymmetric_interval<Type>, bool>::type
 is_empty(const Type& object)
-{ 
-    return domain_less_equal<Type>(upper(object), lower(object)); 
+{
+    return domain_less_equal<Type>(upper(object), lower(object));
 }
 
 template<class Type>
 typename boost::enable_if<is_static_closed<Type>, bool>::type
 is_empty(const Type& object)
-{ 
-    return domain_less<Type>(upper(object), lower(object)); 
+{
+    return domain_less<Type>(upper(object), lower(object));
 }
 
 template<class Type>
 typename boost::enable_if<is_static_open<Type>, bool>::type
 is_empty(const Type& object)
-{ 
-    return domain_less_equal<Type>(upper(object),                   lower(object) ) 
+{
+    return domain_less_equal<Type>(upper(object),                   lower(object) )
         || domain_less_equal<Type>(upper(object), domain_next<Type>(lower(object)));
 }
 
 template<class Type>
 typename boost::enable_if<is_discrete_interval<Type>, bool>::type
 is_empty(const Type& object)
-{ 
+{
     if(object.bounds() == interval_bounds::closed())
-        return domain_less<Type>(upper(object), lower(object)); 
+        return domain_less<Type>(upper(object), lower(object));
     else if(object.bounds() == interval_bounds::open())
         return domain_less_equal<Type>(upper(object),                   lower(object) )
             || domain_less_equal<Type>(upper(object), domain_next<Type>(lower(object)));
     else
-        return domain_less_equal<Type>(upper(object), lower(object)); 
+        return domain_less_equal<Type>(upper(object), lower(object));
 }
 
 template<class Type>
@@ -582,32 +586,32 @@ namespace non_empty
     template<class Type>
     inline typename boost::enable_if<is_asymmetric_interval<Type>, bool>::type
     exclusive_less(const Type& left, const Type& right)
-    { 
+    {
         BOOST_ASSERT(!(icl::is_empty(left) || icl::is_empty(right)));
-        return domain_less_equal<Type>(upper(left), lower(right)); 
+        return domain_less_equal<Type>(upper(left), lower(right));
     }
 
     template<class Type>
     inline typename boost::enable_if<is_discrete_interval<Type>, bool>::type
     exclusive_less(const Type& left, const Type& right)
-    { 
+    {
         BOOST_ASSERT(!(icl::is_empty(left) || icl::is_empty(right)));
-        return domain_less<Type>(last(left), first(right)); 
+        return domain_less<Type>(last(left), first(right));
     }
 
     template<class Type>
     inline typename boost::
     enable_if<has_symmetric_bounds<Type>, bool>::type
     exclusive_less(const Type& left, const Type& right)
-    { 
+    {
         BOOST_ASSERT(!(icl::is_empty(left) || icl::is_empty(right)));
-        return domain_less<Type>(last(left), first(right)); 
+        return domain_less<Type>(last(left), first(right));
     }
 
     template<class Type>
     inline typename boost::enable_if<is_continuous_interval<Type>, bool>::type
     exclusive_less(const Type& left, const Type& right)
-    { 
+    {
         BOOST_ASSERT(!(icl::is_empty(left) || icl::is_empty(right)));
         return     domain_less <Type>(upper(left), lower(right))
             || (   domain_equal<Type>(upper(left), lower(right))
@@ -617,7 +621,7 @@ namespace non_empty
     template<class Type>
     inline typename boost::enable_if<is_interval<Type>, bool>::type
     contains(const Type& super, const Type& sub)
-    { 
+    {
         return lower_less_equal(super,sub) && upper_less_equal(sub,super);
     }
 
@@ -629,7 +633,7 @@ namespace non_empty
 template<class Type>
 inline typename boost::enable_if<is_interval<Type>, bool>::type
 contains(const Type& super, const Type& sub)
-{ 
+{
     return icl::is_empty(sub) || non_empty::contains(super, sub);
 }
 
@@ -637,7 +641,7 @@ template<class Type>
 typename boost::enable_if<is_discrete_static<Type>, bool>::type
 contains(const Type& super, const typename interval_traits<Type>::domain_type& element)
 {
-    return domain_less_equal<Type>(icl::first(super), element                  ) 
+    return domain_less_equal<Type>(icl::first(super), element                  )
         && domain_less_equal<Type>(                   element, icl::last(super));
 }
 
@@ -645,7 +649,7 @@ template<class Type>
 typename boost::enable_if<is_continuous_left_open<Type>, bool>::type
 contains(const Type& super, const typename interval_traits<Type>::domain_type& element)
 {
-    return domain_less      <Type>(icl::lower(super), element                   ) 
+    return domain_less      <Type>(icl::lower(super), element                   )
         && domain_less_equal<Type>(                   element, icl::upper(super));
 }
 
@@ -653,7 +657,7 @@ template<class Type>
 typename boost::enable_if<is_continuous_right_open<Type>, bool>::type
 contains(const Type& super, const typename interval_traits<Type>::domain_type& element)
 {
-    return domain_less_equal<Type>(icl::lower(super), element                   ) 
+    return domain_less_equal<Type>(icl::lower(super), element                   )
         && domain_less      <Type>(                   element, icl::upper(super));
 }
 
@@ -662,12 +666,12 @@ typename boost::enable_if<has_dynamic_bounds<Type>, bool>::type
 contains(const Type& super, const typename interval_traits<Type>::domain_type& element)
 {
     return
-        (is_left_closed(super.bounds())  
-            ? domain_less_equal<Type>(lower(super), element) 
+        (is_left_closed(super.bounds())
+            ? domain_less_equal<Type>(lower(super), element)
             :       domain_less<Type>(lower(super), element))
     &&
-        (is_right_closed(super.bounds()) 
-            ? domain_less_equal<Type>(element, upper(super)) 
+        (is_right_closed(super.bounds())
+            ? domain_less_equal<Type>(element, upper(super))
             :       domain_less<Type>(element, upper(super)));
 }
 
@@ -675,7 +679,7 @@ contains(const Type& super, const typename interval_traits<Type>::domain_type& e
 template<class Type>
 inline typename boost::enable_if<is_interval<Type>, bool>::type
 within(const Type& sub, const Type& super)
-{ 
+{
     return contains(super,sub);
 }
 
@@ -684,37 +688,37 @@ within(const Type& sub, const Type& super)
 //= Equivalences and Orderings
 //==============================================================================
 //- exclusive_less -------------------------------------------------------------
-/** Maximal element of <tt>left</tt> is less than the minimal element of 
+/** Maximal element of <tt>left</tt> is less than the minimal element of
     <tt>right</tt> */
 template<class Type>
 inline typename boost::enable_if<is_asymmetric_interval<Type>, bool>::type
 exclusive_less(const Type& left, const Type& right)
-{ 
+{
     return icl::is_empty(left) || icl::is_empty(right)
-        || domain_less_equal<Type>(upper(left), lower(right)); 
+        || domain_less_equal<Type>(upper(left), lower(right));
 }
 
 template<class Type>
 inline typename boost::enable_if<is_discrete_interval<Type>, bool>::type
 exclusive_less(const Type& left, const Type& right)
-{ 
+{
     return icl::is_empty(left) || icl::is_empty(right)
-        || domain_less<Type>(last(left), first(right)); 
+        || domain_less<Type>(last(left), first(right));
 }
 
 template<class Type>
 inline typename boost::
 enable_if<has_symmetric_bounds<Type>, bool>::type
 exclusive_less(const Type& left, const Type& right)
-{ 
+{
     return icl::is_empty(left) || icl::is_empty(right)
-        || domain_less<Type>(last(left), first(right)); 
+        || domain_less<Type>(last(left), first(right));
 }
 
 template<class Type>
 inline typename boost::enable_if<is_continuous_interval<Type>, bool>::type
 exclusive_less(const Type& left, const Type& right)
-{ 
+{
     return     icl::is_empty(left) || icl::is_empty(right)
         ||     domain_less<Type>(upper(left), lower(right))
         || (   domain_equal<Type>(upper(left), lower(right))
@@ -729,24 +733,24 @@ lower_less(const Type& left, const Type& right)
 {
     return domain_less<Type>(lower(left), lower(right));
 }
-    
+
 template<class Type>
 typename boost::enable_if<is_discrete_interval<Type>, bool>::type
 lower_less(const Type& left, const Type& right)
 {
     return domain_less<Type>(first(left), first(right));
 }
-    
+
 template<class Type>
 typename boost::enable_if<is_continuous_interval<Type>, bool>::type
 lower_less(const Type& left, const Type& right)
 {
     if(left_bounds(left,right) == interval_bounds::right_open())  //'[(' == 10
         return domain_less_equal<Type>(lower(left), lower(right));
-    else 
+    else
         return domain_less<Type>(lower(left), lower(right));
 }
-    
+
 
 //------------------------------------------------------------------------------
 template<class Type>
@@ -762,7 +766,7 @@ upper_less(const Type& left, const Type& right)
 {
     return domain_less<Type>(last(left), last(right));
 }
-    
+
 template<class Type>
 typename boost::enable_if<is_continuous_interval<Type>, bool>::type
 upper_less(const Type& left, const Type& right)
@@ -772,10 +776,10 @@ upper_less(const Type& left, const Type& right)
     else
         return domain_less<Type>(upper(left), upper(right));
 }
-    
+
 //------------------------------------------------------------------------------
 template<class Type>
-typename boost::enable_if<has_dynamic_bounds<Type>, 
+typename boost::enable_if<has_dynamic_bounds<Type>,
                           typename Type::bounded_domain_type   >::type
 lower_min(const Type& left, const Type& right)
 {
@@ -784,7 +788,7 @@ lower_min(const Type& left, const Type& right)
 
 //------------------------------------------------------------------------------
 template<class Type>
-typename boost::enable_if<has_dynamic_bounds<Type>, 
+typename boost::enable_if<has_dynamic_bounds<Type>,
                           typename Type::bounded_domain_type   >::type
 lower_max(const Type& left, const Type& right)
 {
@@ -793,7 +797,7 @@ lower_max(const Type& left, const Type& right)
 
 //------------------------------------------------------------------------------
 template<class Type>
-typename boost::enable_if<has_dynamic_bounds<Type>, 
+typename boost::enable_if<has_dynamic_bounds<Type>,
                           typename Type::bounded_domain_type   >::type
 upper_max(const Type& left, const Type& right)
 {
@@ -802,7 +806,7 @@ upper_max(const Type& left, const Type& right)
 
 //------------------------------------------------------------------------------
 template<class Type>
-typename boost::enable_if<has_dynamic_bounds<Type>, 
+typename boost::enable_if<has_dynamic_bounds<Type>,
                           typename Type::bounded_domain_type   >::type
 upper_min(const Type& left, const Type& right)
 {
@@ -892,7 +896,7 @@ template<class Type>
 typename boost::enable_if<is_interval<Type>, bool>::type
 operator == (const Type& left, const Type& right)
 {
-    return (icl::is_empty(left) && icl::is_empty(right)) 
+    return (icl::is_empty(left) && icl::is_empty(right))
         || (lower_equal(left,right) && upper_equal(left,right));
 }
 
@@ -908,11 +912,11 @@ template<class Type>
 typename boost::enable_if<is_interval<Type>, bool>::type
 operator < (const Type& left, const Type& right)
 {
-    if(icl::is_empty(left)) 
+    if(icl::is_empty(left))
         return !icl::is_empty(right);
-    else 
-        return lower_less(left,right) 
-            || (lower_equal(left,right) && upper_less(left,right)); 
+    else
+        return lower_less(left,right)
+            || (lower_equal(left,right) && upper_less(left,right));
 }
 
 template<class Type>
@@ -928,15 +932,15 @@ operator > (const Type& left, const Type& right)
 template<class Type>
 typename boost::enable_if<is_asymmetric_interval<Type>, bool>::type
 touches(const Type& left, const Type& right)
-{ 
-    return domain_equal<Type>(upper(left), lower(right)); 
+{
+    return domain_equal<Type>(upper(left), lower(right));
 }
 
 template<class Type>
 typename boost::enable_if<has_symmetric_bounds<Type>, bool>::type
 touches(const Type& left, const Type& right)
-{ 
-    return domain_equal<Type>(last_next(left), first(right)); 
+{
+    return domain_equal<Type>(last_next(left), first(right));
 }
 
 template<class Type>
@@ -961,22 +965,22 @@ touches(const Type& left, const Type& right)
 //- cardinality ----------------------------------------------------------------
 
 template<class Type>
-typename boost::enable_if<is_continuous_interval<Type>, 
+typename boost::enable_if<is_continuous_interval<Type>,
     typename size_type_of<interval_traits<Type> >::type>::type
 cardinality(const Type& object)
 {
     typedef typename size_type_of<interval_traits<Type> >::type SizeT;
     if(icl::is_empty(object))
         return icl::identity_element<SizeT>::value();
-    else if(   object.bounds() == interval_bounds::closed() 
+    else if(   object.bounds() == interval_bounds::closed()
             && domain_equal<Type>(lower(object), upper(object)))
         return icl::unit_element<SizeT>::value();
-    else 
+    else
         return icl::infinity<SizeT>::value();
 }
 
 template<class Type>
-typename boost::enable_if<is_discrete_interval<Type>, 
+typename boost::enable_if<is_discrete_interval<Type>,
     typename size_type_of<interval_traits<Type> >::type>::type
 cardinality(const Type& object)
 {
@@ -986,19 +990,19 @@ cardinality(const Type& object)
 }
 
 template<class Type>
-typename boost::enable_if<is_continuous_asymmetric<Type>, 
+typename boost::enable_if<is_continuous_asymmetric<Type>,
     typename size_type_of<interval_traits<Type> >::type>::type
 cardinality(const Type& object)
 {
     typedef typename size_type_of<interval_traits<Type> >::type SizeT;
     if(icl::is_empty(object))
         return icl::identity_element<SizeT>::value();
-    else 
+    else
         return icl::infinity<SizeT>::value();
 }
 
 template<class Type>
-typename boost::enable_if<is_discrete_asymmetric<Type>, 
+typename boost::enable_if<is_discrete_asymmetric<Type>,
     typename size_type_of<interval_traits<Type> >::type>::type
 cardinality(const Type& object)
 {
@@ -1008,7 +1012,7 @@ cardinality(const Type& object)
 }
 
 template<class Type>
-typename boost::enable_if<has_symmetric_bounds<Type>, 
+typename boost::enable_if<has_symmetric_bounds<Type>,
     typename size_type_of<interval_traits<Type> >::type>::type
 cardinality(const Type& object)
 {
@@ -1021,7 +1025,7 @@ cardinality(const Type& object)
 
 //- size -----------------------------------------------------------------------
 template<class Type>
-inline typename enable_if<is_interval<Type>, 
+inline typename enable_if<is_interval<Type>,
     typename size_type_of<interval_traits<Type> >::type>::type
 size(const Type& object)
 {
@@ -1030,7 +1034,7 @@ size(const Type& object)
 
 //- length ---------------------------------------------------------------------
 template<class Type>
-inline typename boost::enable_if<is_continuous_interval<Type>, 
+inline typename boost::enable_if<is_continuous_interval<Type>,
     typename difference_type_of<interval_traits<Type> >::type>::type
 length(const Type& object)
 {
@@ -1040,7 +1044,7 @@ length(const Type& object)
 }
 
 template<class Type>
-inline typename boost::enable_if<is_discrete_interval<Type>, 
+inline typename boost::enable_if<is_discrete_interval<Type>,
     typename difference_type_of<interval_traits<Type> >::type>::type
 length(const Type& object)
 {
@@ -1050,7 +1054,7 @@ length(const Type& object)
 }
 
 template<class Type>
-typename boost::enable_if<is_continuous_asymmetric<Type>, 
+typename boost::enable_if<is_continuous_asymmetric<Type>,
     typename difference_type_of<interval_traits<Type> >::type>::type
 length(const Type& object)
 {
@@ -1060,7 +1064,7 @@ length(const Type& object)
 }
 
 template<class Type>
-inline typename boost::enable_if<is_discrete_static<Type>, 
+inline typename boost::enable_if<is_discrete_static<Type>,
     typename difference_type_of<interval_traits<Type> >::type>::type
 length(const Type& object)
 {
@@ -1071,7 +1075,7 @@ length(const Type& object)
 
 //- iterative_size -------------------------------------------------------------
 template<class Type>
-inline typename enable_if<is_interval<Type>, 
+inline typename enable_if<is_interval<Type>,
     typename size_type_of<interval_traits<Type> >::type>::type
 iterative_size(const Type&)
 {
@@ -1095,10 +1099,10 @@ hull(Type left, const Type& right)
     else if(icl::is_empty(left))
         return right;
 
-    return 
+    return
         construct<Type>
         (
-            (std::min)(lower(left), lower(right), domain_compare()), 
+            (std::min)(lower(left), lower(right), domain_compare()),
             (std::max)(upper(left), upper(right), domain_compare())
         );
 }
@@ -1114,7 +1118,7 @@ hull(Type left, const Type& right)
 
     return  dynamic_interval_traits<Type>::construct_bounded
             (
-                lower_min(left, right), 
+                lower_min(left, right),
                 upper_max(left, right)
             );
 }
@@ -1123,7 +1127,7 @@ hull(Type left, const Type& right)
 //= Subtraction
 //==============================================================================
 //- left_subtract --------------------------------------------------------------
-/** subtract \c left_minuend from the \c right interval on it's left side. 
+/** subtract \c left_minuend from the \c right interval on it's left side.
     Return the difference: The part of \c right right of \c left_minuend.
 \code
 right_over = right - left_minuend; //on the left.
@@ -1137,7 +1141,7 @@ typename boost::enable_if<is_asymmetric_interval<Type>, Type>::type
 left_subtract(Type right, const Type& left_minuend)
 {
     if(exclusive_less(left_minuend, right))
-        return right; 
+        return right;
 
     return construct<Type>(upper(left_minuend), upper(right));
 }
@@ -1147,7 +1151,7 @@ typename boost::enable_if<is_static_closed<Type>, Type>::type
 left_subtract(Type right, const Type& left_minuend)
 {
     if(exclusive_less(left_minuend, right))
-        return right; 
+        return right;
     else if(upper_less_equal(right, left_minuend))
         return identity_element<Type>::value();
 
@@ -1159,7 +1163,7 @@ typename boost::enable_if<is_static_open<Type>, Type>::type
 left_subtract(Type right, const Type& left_minuend)
 {
     if(exclusive_less(left_minuend, right))
-        return right; 
+        return right;
 
     return construct<Type>(domain_prior<Type>(upper(left_minuend)), upper(right));
 }
@@ -1169,14 +1173,14 @@ typename boost::enable_if<has_dynamic_bounds<Type>, Type>::type
 left_subtract(Type right, const Type& left_minuend)
 {
     if(exclusive_less(left_minuend, right))
-        return right; 
+        return right;
     return  dynamic_interval_traits<Type>::construct_bounded
             ( reverse_bounded_upper(left_minuend), bounded_upper(right) );
 }
 
 
 //- right_subtract -------------------------------------------------------------
-/** subtract \c right_minuend from the \c left interval on it's right side. 
+/** subtract \c right_minuend from the \c left interval on it's right side.
     Return the difference: The part of \c left left of \c right_minuend.
 \code
 left_over = left - right_minuend; //on the right side.
@@ -1190,7 +1194,7 @@ typename boost::enable_if<is_asymmetric_interval<Type>, Type>::type
 right_subtract(Type left, const Type& right_minuend)
 {
     if(exclusive_less(left, right_minuend))
-        return left; 
+        return left;
     return construct<Type>(lower(left), lower(right_minuend));
 }
 
@@ -1221,7 +1225,7 @@ typename boost::enable_if<has_dynamic_bounds<Type>, Type>::type
 right_subtract(Type left, const Type& right_minuend)
 {
     if(exclusive_less(left, right_minuend))
-        return left; 
+        return left;
 
     return  dynamic_interval_traits<Type>::construct_bounded
             ( bounded_lower(left), reverse_bounded_lower(right_minuend) );
@@ -1272,11 +1276,11 @@ operator & (Type left, const Type& right)
 {
     if(icl::is_empty(left) || icl::is_empty(right))
         return identity_element<Type>::value();
-    else 
+    else
         return  dynamic_interval_traits<Type>::construct_bounded
                 (
-                    lower_max(left, right), 
-                    upper_min(left, right) 
+                    lower_max(left, right),
+                    upper_min(left, right)
                 );
 }
 
@@ -1285,18 +1289,18 @@ operator & (Type left, const Type& right)
 template<class Type>
 typename boost::enable_if<is_interval<Type>, bool>::type
 intersects(const Type& left, const Type& right)
-{ 
-    return !(   icl::is_empty(left) || icl::is_empty(right) 
-             || exclusive_less(left,right) || exclusive_less(right,left)); 
+{
+    return !(   icl::is_empty(left) || icl::is_empty(right)
+             || exclusive_less(left,right) || exclusive_less(right,left));
 }
 
 //- disjoint -------------------------------------------------------------------
 template<class Type>
 typename boost::enable_if<is_interval<Type>, bool>::type
 disjoint(const Type& left, const Type& right)
-{ 
-    return icl::is_empty(left) || icl::is_empty(right) 
-        || exclusive_less(left,right) || exclusive_less(right,left); 
+{
+    return icl::is_empty(left) || icl::is_empty(right)
+        || exclusive_less(left,right) || exclusive_less(right,left);
 }
 
 //==============================================================================
@@ -1362,7 +1366,7 @@ inner_complement(const Type& left, const Type& right)
 template<class Type>
 inline typename boost::enable_if<is_interval<Type>, Type>::type
 between(const Type& left, const Type& right)
-{ 
+{
     return inner_complement(left, right);
 }
 
@@ -1375,7 +1379,7 @@ template<class Type>
 typename boost::
 enable_if< mpl::and_< is_interval<Type>
                     , has_difference<typename interval_traits<Type>::domain_type>
-                    , is_discrete<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)
@@ -1396,7 +1400,7 @@ template<class Type>
 typename boost::
 enable_if< mpl::and_< is_interval<Type>
                     , has_difference<typename interval_traits<Type>::domain_type>
-                    , is_continuous<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)
@@ -1430,9 +1434,9 @@ left_bracket(const Type&) { return "["; }
 
 template<class Type>
 typename boost::enable_if<has_dynamic_bounds<Type>, std::string>::type
-left_bracket(const Type& object) 
-{ 
-    return left_bracket(object.bounds()); 
+left_bracket(const Type& object)
+{
+    return left_bracket(object.bounds());
 }
 
 //------------------------------------------------------------------------------
@@ -1450,28 +1454,27 @@ right_bracket(const Type&) { return "]"; }
 
 template<class Type>
 typename boost::enable_if<has_dynamic_bounds<Type>, std::string>::type
-right_bracket(const Type& object) 
-{ 
-    return right_bracket(object.bounds()); 
+right_bracket(const Type& object)
+{
+    return right_bracket(object.bounds());
 }
 
 //------------------------------------------------------------------------------
 template<class CharType, class CharTraits, class Type>
-typename boost::enable_if<is_interval<Type>, 
+typename boost::enable_if<is_interval<Type>,
                           std::basic_ostream<CharType, CharTraits> >::type&
 operator << (std::basic_ostream<CharType, CharTraits> &stream, Type const& object)
 {
     if(boost::icl::is_empty(object))
-        return stream << left_bracket<Type>(object) << right_bracket<Type>(object); 
+        return stream << left_bracket<Type>(object) << right_bracket<Type>(object);
     else
-        return stream << left_bracket<Type>(object) 
-                      << interval_traits<Type>::lower(object) 
-                      << "," 
-                      << interval_traits<Type>::upper(object) 
+        return stream << left_bracket<Type>(object)
+                      << interval_traits<Type>::lower(object)
+                      << ","
+                      << interval_traits<Type>::upper(object)
                       << right_bracket<Type>(object) ;
 }
 
 }} // namespace icl boost
 
 #endif
-