1 | // Copyright 2002 The Trustees of Indiana University. |
2 | |
3 | // Use, modification and distribution is subject to the Boost Software |
4 | // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at |
5 | // http://www.boost.org/LICENSE_1_0.txt) |
6 | |
7 | // Boost.MultiArray Library |
8 | // Authors: Ronald Garcia |
9 | // Jeremy Siek |
10 | // Andrew Lumsdaine |
11 | // See http://www.boost.org/libs/multi_array for documentation. |
12 | |
13 | #ifndef BOOST_INDEX_RANGE_RG071801_HPP |
14 | #define BOOST_INDEX_RANGE_RG071801_HPP |
15 | |
16 | #include <boost/config.hpp> |
17 | #include <utility> |
18 | #include <boost/limits.hpp> |
19 | |
20 | // For representing intervals, also with stride. |
21 | // A degenerate range is a range with one element. |
22 | |
23 | // Thanks to Doug Gregor for the really cool idea of using the |
24 | // comparison operators to express various interval types! |
25 | |
26 | // Internally, we represent the interval as half-open. |
27 | |
28 | namespace boost { |
29 | namespace detail { |
30 | namespace multi_array { |
31 | |
32 | template <typename Index,typename SizeType> |
33 | class index_range { |
34 | public: |
35 | typedef Index index; |
36 | typedef SizeType size_type; |
37 | |
38 | private: |
39 | static index from_start() |
40 | { return (std::numeric_limits<index>::min)(); } |
41 | |
42 | static index to_end() |
43 | { return (std::numeric_limits<index>::max)(); } |
44 | |
45 | public: |
46 | |
47 | index_range() |
48 | { |
49 | start_ = from_start(); |
50 | finish_ = to_end(); |
51 | stride_ = 1; |
52 | degenerate_ = false; |
53 | } |
54 | |
55 | explicit index_range(index pos) |
56 | { |
57 | start_ = pos; |
58 | finish_ = pos+1; |
59 | stride_ = 1; |
60 | degenerate_ = true; |
61 | } |
62 | |
63 | explicit index_range(index start, index finish, index stride=1) |
64 | : start_(start), finish_(finish), stride_(stride), |
65 | degenerate_(false) |
66 | { } |
67 | |
68 | |
69 | // These are for chaining assignments to an index_range |
70 | index_range& start(index s) { |
71 | start_ = s; |
72 | degenerate_ = false; |
73 | return *this; |
74 | } |
75 | |
76 | index_range& finish(index f) { |
77 | finish_ = f; |
78 | degenerate_ = false; |
79 | return *this; |
80 | } |
81 | |
82 | index_range& stride(index s) { stride_ = s; return *this; } |
83 | |
84 | index start() const |
85 | { |
86 | return start_; |
87 | } |
88 | |
89 | index get_start(index low_index_range = index_range::from_start()) const |
90 | { |
91 | if (start_ == from_start()) |
92 | return low_index_range; |
93 | return start_; |
94 | } |
95 | |
96 | index finish() const |
97 | { |
98 | return finish_; |
99 | } |
100 | |
101 | index get_finish(index high_index_range = index_range::to_end()) const |
102 | { |
103 | if (finish_ == to_end()) |
104 | return high_index_range; |
105 | return finish_; |
106 | } |
107 | |
108 | index stride() const { return stride_; } |
109 | |
110 | void set_index_range(index start, index finish, index stride=1) |
111 | { |
112 | start_ = start; |
113 | finish_ = finish; |
114 | stride_ = stride; |
115 | } |
116 | |
117 | static index_range all() |
118 | { return index_range(from_start(), to_end(), 1); } |
119 | |
120 | bool is_degenerate() const { return degenerate_; } |
121 | |
122 | index_range operator-(index shift) const |
123 | { |
124 | return index_range(start_ - shift, finish_ - shift, stride_); |
125 | } |
126 | |
127 | index_range operator+(index shift) const |
128 | { |
129 | return index_range(start_ + shift, finish_ + shift, stride_); |
130 | } |
131 | |
132 | index operator[](unsigned i) const |
133 | { |
134 | return start_ + i * stride_; |
135 | } |
136 | |
137 | index operator()(unsigned i) const |
138 | { |
139 | return start_ + i * stride_; |
140 | } |
141 | |
142 | // add conversion to std::slice? |
143 | |
144 | public: |
145 | index start_, finish_, stride_; |
146 | bool degenerate_; |
147 | }; |
148 | |
149 | // Express open and closed interval end-points using the comparison |
150 | // operators. |
151 | |
152 | // left closed |
153 | template <typename Index, typename SizeType> |
154 | inline index_range<Index,SizeType> |
155 | operator<=(Index s, const index_range<Index,SizeType>& r) |
156 | { |
157 | return index_range<Index,SizeType>(s, r.finish(), r.stride()); |
158 | } |
159 | |
160 | // left open |
161 | template <typename Index, typename SizeType> |
162 | inline index_range<Index,SizeType> |
163 | operator<(Index s, const index_range<Index,SizeType>& r) |
164 | { |
165 | return index_range<Index,SizeType>(s + 1, r.finish(), r.stride()); |
166 | } |
167 | |
168 | // right open |
169 | template <typename Index, typename SizeType> |
170 | inline index_range<Index,SizeType> |
171 | operator<(const index_range<Index,SizeType>& r, Index f) |
172 | { |
173 | return index_range<Index,SizeType>(r.start(), f, r.stride()); |
174 | } |
175 | |
176 | // right closed |
177 | template <typename Index, typename SizeType> |
178 | inline index_range<Index,SizeType> |
179 | operator<=(const index_range<Index,SizeType>& r, Index f) |
180 | { |
181 | return index_range<Index,SizeType>(r.start(), f + 1, r.stride()); |
182 | } |
183 | |
184 | } // namespace multi_array |
185 | } // namespace detail |
186 | } // namespace boost |
187 | |
188 | #endif // BOOST_INDEX_RANGE_RG071801_HPP |
189 | |