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