ceph/src/boost/libs/icl/include/boost/icl/continuous_interval.hpp

   1 /*-----------------------------------------------------------------------------+
   2 Copyright (c) 2010-2010: Joachim Faulhaber
   3 +------------------------------------------------------------------------------+
   4    Distributed under the Boost Software License, Version 1.0.
   5       (See accompanying file LICENCE.txt or copy at
   6            http://www.boost.org/LICENSE_1_0.txt)
   7 +-----------------------------------------------------------------------------*/
   8 #ifndef BOOST_ICL_CONTINUOUS_INTERVAL_HPP_JOFA_100327
   9 #define BOOST_ICL_CONTINUOUS_INTERVAL_HPP_JOFA_100327
  10
  11 #include <functional>
  12 #include <boost/static_assert.hpp>
  13 #include <boost/concept/assert.hpp>
  14 #include <boost/icl/detail/concept_check.hpp>
  15 #include <boost/icl/concept/interval.hpp>
  16 #include <boost/icl/concept/container.hpp>
  17 #include <boost/icl/type_traits/value_size.hpp>
  18 #include <boost/icl/type_traits/type_to_string.hpp>
  19 #include <boost/icl/type_traits/is_continuous.hpp>
  20 #include <boost/icl/type_traits/is_continuous_interval.hpp>
  21 #include <boost/icl/interval_bounds.hpp>
  22
  23 namespace boost{namespace icl
  24 {
  25
  26 template <class DomainT,
  27           ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT)>
  28 class continuous_interval
  29 {
  30 public:
  31     typedef continuous_interval<DomainT,Compare> type;
  32     typedef DomainT domain_type;
  33     typedef ICL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
  34     typedef typename bounded_value<DomainT>::type bounded_domain_type;
  35
  36 public:
  37     //==========================================================================
  38     //= Construct, copy, destruct
  39     //==========================================================================
  40     /** Default constructor; yields an empty interval <tt>[0,0)</tt>. */
  41     continuous_interval()
  42         : _lwb(identity_element<DomainT>::value()), _upb(identity_element<DomainT>::value())
  43         , _bounds(interval_bounds::right_open())
  44     {
  45         BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
  46         BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
  47         BOOST_STATIC_ASSERT((icl::is_continuous<DomainT>::value));
  48     }
  49
  50     //NOTE: Compiler generated copy constructor is used
  51
  52     /** Constructor for a closed singleton interval <tt>[val,val]</tt> */
  53     explicit continuous_interval(const DomainT& val)
  54         : _lwb(val), _upb(val), _bounds(interval_bounds::closed())
  55     {
  56         BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
  57         BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
  58         BOOST_STATIC_ASSERT((icl::is_continuous<DomainT>::value));
  59     }
  60
  61     /** Interval from <tt>low</tt> to <tt>up</tt> with bounds <tt>bounds</tt> */
  62     continuous_interval(const DomainT& low, const DomainT& up,
  63                       interval_bounds bounds = interval_bounds::right_open(),
  64                       continuous_interval* = 0)
  65         : _lwb(low), _upb(up), _bounds(bounds)
  66     {
  67         BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
  68         BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
  69         BOOST_STATIC_ASSERT((icl::is_continuous<DomainT>::value));
  70     }
  71
  72     domain_type     lower()const { return _lwb; }
  73     domain_type     upper()const { return _upb; }
  74     interval_bounds bounds()const{ return _bounds; }
  75
  76     static continuous_interval open     (const DomainT& lo, const DomainT& up){ return continuous_interval(lo, up, interval_bounds::open());      }
  77     static continuous_interval right_open(const DomainT& lo, const DomainT& up){ return continuous_interval(lo, up, interval_bounds::right_open());}
  78     static continuous_interval left_open (const DomainT& lo, const DomainT& up){ return continuous_interval(lo, up, interval_bounds::left_open()); }
  79     static continuous_interval closed   (const DomainT& lo, const DomainT& up){ return continuous_interval(lo, up, interval_bounds::closed());    }
  80
  81 private:
  82     domain_type     _lwb;
  83     domain_type     _upb;
  84     interval_bounds _bounds;
  85 };
  86
  87
  88 //==============================================================================
  89 //=T continuous_interval -> concept interval
  90 //==============================================================================
  91 template<class DomainT, ICL_COMPARE Compare>
  92 struct interval_traits< icl::continuous_interval<DomainT, Compare> >
  93 {
  94     typedef interval_traits type;
  95     typedef DomainT domain_type;
  96     typedef ICL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
  97     typedef icl::continuous_interval<DomainT, Compare> interval_type;
  98
  99     static interval_type construct(const domain_type& lo, const domain_type& up)
 100     {
 101         return interval_type(lo, up);
 102     }
 103
 104     static domain_type lower(const interval_type& inter_val){ return inter_val.lower(); };
 105     static domain_type upper(const interval_type& inter_val){ return inter_val.upper(); };
 106 };
 107
 108
 109 //==============================================================================
 110 //=T continuous_interval -> concept dynamic_interval
 111 //==============================================================================
 112 template<class DomainT, ICL_COMPARE Compare>
 113 struct dynamic_interval_traits<boost::icl::continuous_interval<DomainT,Compare> >
 114 {
 115     typedef dynamic_interval_traits type;
 116     typedef boost::icl::continuous_interval<DomainT,Compare> interval_type;
 117     typedef DomainT domain_type;
 118     typedef ICL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
 119
 120     static interval_type construct(const domain_type lo, const domain_type up, interval_bounds bounds)
 121     {
 122         return icl::continuous_interval<DomainT,Compare>(lo, up, bounds,
 123             static_cast<icl::continuous_interval<DomainT,Compare>* >(0) );
 124     }
 125
 126     static interval_type construct_bounded(const bounded_value<DomainT>& lo,
 127                                            const bounded_value<DomainT>& up)
 128     {
 129         return  icl::continuous_interval<DomainT,Compare>
 130                 (
 131                     lo.value(), up.value(),
 132                     lo.bound().left() | up.bound().right(),
 133                     static_cast<icl::continuous_interval<DomainT,Compare>* >(0)
 134                 );
 135     }
 136 };
 137
 138 //==============================================================================
 139 //= Type traits
 140 //==============================================================================
 141 template <class DomainT, ICL_COMPARE Compare>
 142 struct interval_bound_type< continuous_interval<DomainT,Compare> >
 143 {
 144     typedef interval_bound_type type;
 145     BOOST_STATIC_CONSTANT(bound_type, value = interval_bounds::dynamic);
 146 };
 147
 148 template <class DomainT, ICL_COMPARE Compare>
 149 struct is_continuous_interval<continuous_interval<DomainT,Compare> >
 150 {
 151     typedef is_continuous_interval<continuous_interval<DomainT,Compare> > type;
 152     BOOST_STATIC_CONSTANT(bool, value = true);
 153 };
 154
 155 template <class DomainT, ICL_COMPARE Compare>
 156 struct type_to_string<icl::continuous_interval<DomainT,Compare> >
 157 {
 158     static std::string apply()
 159     { return "cI<"+ type_to_string<DomainT>::apply() +">"; }
 160 };
 161
 162 template<class DomainT>
 163 struct value_size<icl::continuous_interval<DomainT> >
 164 {
 165     static std::size_t apply(const icl::continuous_interval<DomainT>&)
 166     { return 2; }
 167 };
 168
 169 }} // namespace icl boost
 170
 171 #endif
 172