addr_range.hh revision 531 
1/*
2 * Copyright (c) 2003 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#ifndef __RANGE_HH__
30#define __RANGE_HH__
31
32#include <cassert>
33#include <string>
34
35template <class T>
36bool __parse_range(const std::string &s, T &start, T &end);
37
38template <class T>
39struct Range
40{
41  private:
42    /**
43     * @param s range string
44     * Ranges are in the following format:
45     *    <range> := {<start_val>}:{<end>}
46     *    <end>   := <end_val> | +<delta>
47     */
48    void
49    parse(const std::string &s)
50    {
51        if (!__parse_range(s, start, end))
52            invalidate();
53    }
54
55  public:
56    T start;
57    T end;
58
59  public:
60    Range()
61    {
62        invalidate();
63    }
64
65    template <class U>
66    Range(const Range<U> &r)
67        : start(r.start), end(r.end)
68    {}
69
70    template <class U>
71    Range(const std::pair<U, U> &r)
72        : start(r.first), end(r.second)
73    {}
74
75    Range(const std::string &s)
76    {
77        parse(s);
78    }
79
80    template <class U>
81    const Range<T> &operator=(const Range<U> &r)
82    {
83        start = r.start;
84        end = r.end;
85        return *this;
86    }
87
88    template <class U>
89    const Range<T> &operator=(const std::pair<U, U> &r)
90    {
91        start = r.first;
92        end = r.second;
93        return *this;
94    }
95
96    const Range &operator=(const std::string &s)
97    {
98        parse(s);
99        return *this;
100    }
101
102    void invalidate() { start = 0; end = 0; }
103    bool size() const { return end - start; }
104    bool valid() const { return start < end; }
105};
106
107template<class T>
108inline std::ostream &
109operator<<(std::ostream &o, const Range<T> &r)
110{
111    // don't currently support output of invalid ranges
112    assert(r.valid());
113    o << r.start << ":" << r.end;
114    return o;
115}
116
117////////////////////////////////////////////////////////////////////////
118//
119// Range to Range Comparisons
120//
121
122/**
123 * @param range1 is a range.
124 * @param range2 is a range.
125 * @return if range1 and range2 are identical.
126 */
127template<class T, class U>
128inline bool
129operator==(const Range<T> &range1, const Range<U> &range2)
130{
131    assert(range1.valid() && range2.valid());
132    return range1.start == range2.start && range1.end == range2.end;
133}
134
135/**
136 * @param range1 is a range.
137 * @param range2 is a range.
138 * @return if range1 and range2 are not identical.
139 */
140template<class T, class U>
141inline bool
142operator!=(const Range<T> &range1, const Range<U> &range2)
143{
144    assert(range1.valid() && range2.valid());
145    return range1.start != range2.start || range1.end != range2.end;
146}
147
148/**
149 * @param range1 is a range.
150 * @param range2 is a range.
151 * @return if range1 is less than range2 and does not overlap range1.
152 */
153template<class T, class U>
154inline bool
155operator<(const Range<T> &range1, const Range<U> &range2)
156{
157    assert(range1.valid() && range2.valid());
158    return range1.end <= range2.start;
159}
160
161/**
162 * @param range1 is a range.
163 * @param range2 is a range.
164 * @return if range1 is less than range2.  range1 may overlap range2,
165 * but not extend beyond the end of range2.
166 */
167template<class T, class U>
168inline bool
169operator<=(const Range<T> &range1, const Range<U> &range2)
170{
171    assert(range1.valid() && range2.valid());
172    return range1.start <= range2.start && range1.end <= range2.end;
173}
174
175/**
176 * @param range1 is a range.
177 * @param range2 is a range.
178 * @return if range1 is greater than range2 and does not overlap range2.
179 */
180template<class T, class U>
181inline bool
182operator>(const Range<T> &range1, const Range<U> &range2)
183{
184    assert(range1.valid() && range2.valid());
185    return range1.start >= range2.end;
186}
187
188/**
189 * @param range1 is a range.
190 * @param range2 is a range.
191 * @return if range1 is greater than range2.  range1 may overlap range2,
192 * but not extend beyond the beginning of range2.
193 */
194template<class T, class U>
195inline bool
196operator>=(const Range<T> &range1, const Range<U> &range2)
197{
198    assert(range1.valid() && range2.valid());
199    return range1.start >= range2.start && range1.end >= range2.end;
200}
201
202////////////////////////////////////////////////////////////////////////
203//
204// Position to Range Comparisons
205//
206
207/**
208 * @param pos position compared to the range.
209 * @param range range compared against.
210 * @return indicates that position pos is within the range.
211 */
212template<class T, class U>
213inline bool
214operator==(const T &pos, const Range<U> &range)
215{
216    assert(range.valid());
217    return pos >= range.start && pos < range.end;
218}
219
220/**
221 * @param pos position compared to the range.
222 * @param range range compared against.
223 * @return indicates that position pos is not within the range.
224 */
225template<class T, class U>
226inline bool
227operator!=(const T &pos, const Range<U> &range)
228{
229    assert(range.valid());
230    return pos < range.start || pos >= range.end;
231}
232
233/**
234 * @param pos position compared to the range.
235 * @param range range compared against.
236 * @return indicates that position pos is below the range.
237 */
238template<class T, class U>
239inline bool
240operator<(const T &pos, const Range<U> &range)
241{
242    assert(range.valid());
243    return pos < range.start;
244}
245
246/**
247 * @param pos position compared to the range.
248 * @param range range compared against.
249 * @return indicates that position pos is below or in the range.
250 */
251template<class T, class U>
252inline bool
253operator<=(const T &pos, const Range<U> &range)
254{
255    assert(range.valid());
256    return pos < range.end;
257}
258
259/**
260 * @param pos position compared to the range.
261 * @param range range compared against.
262 * @return indicates that position pos is above the range.
263 */
264template<class T, class U>
265inline bool
266operator>(const T &pos, const Range<U> &range)
267{
268    assert(range.valid());
269    return pos >= range.end;
270}
271
272/**
273 * @param pos position compared to the range.
274 * @param range range compared against.
275 * @return indicates that position pos is above or in the range.
276 */
277template<class T, class U>
278inline bool
279operator>=(const T &pos, const Range<U> &range)
280{
281    assert(range.valid());
282    return pos >= range.start;
283}
284
285////////////////////////////////////////////////////////////////////////
286//
287// Range to Position Comparisons (for symmetry)
288//
289
290/**
291 * @param range range compared against.
292 * @param pos position compared to the range.
293 * @return indicates that position pos is within the range.
294 */
295template<class T, class U>
296inline bool
297operator==(const Range<T> &range, const U &pos)
298{
299    assert(range.valid());
300    return pos >= range.start && pos < range.end;
301}
302
303/**
304 * @param range range compared against.
305 * @param pos position compared to the range.
306 * @return indicates that position pos is not within the range.
307 */
308template<class T, class U>
309inline bool
310operator!=(const Range<T> &range, const U &pos)
311{
312    assert(range.valid());
313    return pos < range.start || pos >= range.end;
314}
315
316/**
317 * @param range range compared against.
318 * @param pos position compared to the range.
319 * @return indicates that position pos is above the range.
320 */
321template<class T, class U>
322inline bool
323operator<(const Range<T> &range, const U &pos)
324{
325    assert(range.valid());
326    return range.end <= pos;
327}
328
329/**
330 * @param range range compared against.
331 * @param pos position compared to the range.
332 * @return indicates that position pos is above or in the range.
333 */
334template<class T, class U>
335inline bool
336operator<=(const Range<T> &range, const U &pos)
337{
338    assert(range.valid());
339    return range.start <= pos;
340}
341
342/**
343 * @param range range compared against.
344 * @param pos position compared to the range.
345 * 'range > pos' indicates that position pos is below the range.
346 */
347template<class T, class U>
348inline bool
349operator>(const Range<T> &range, const U &pos)
350{
351    assert(range.valid());
352    return range.start > pos;
353}
354
355/**
356 * @param range range compared against.
357 * @param pos position compared to the range.
358 * 'range >= pos' indicates that position pos is below or in the range.
359 */
360template<class T, class U>
361inline bool
362operator>=(const Range<T> &range, const U &pos)
363{
364    assert(range.valid());
365    return range.end > pos;
366}
367
368#endif // __RANGE_HH__
369