]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | #ifndef _DATE_TIME_WRAPPING_INT_HPP__ |
2 | #define _DATE_TIME_WRAPPING_INT_HPP__ | |
3 | ||
4 | /* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc. | |
5 | * Use, modification and distribution is subject to the | |
6 | * Boost Software License, Version 1.0. (See accompanying | |
7 | * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) | |
8 | * Author: Jeff Garland, Bart Garst | |
9 | * $Date$ | |
10 | */ | |
11 | ||
12 | ||
13 | namespace boost { | |
14 | namespace date_time { | |
15 | ||
16 | //! A wrapping integer used to support time durations (WARNING: only instantiate with a signed type) | |
17 | /*! In composite date and time types this type is used to | |
18 | * wrap at the day boundary. | |
19 | * Ex: | |
20 | * A wrapping_int<short, 10> will roll over after nine, and | |
21 | * roll under below zero. This gives a range of [0,9] | |
22 | * | |
23 | * NOTE: it is strongly recommended that wrapping_int2 be used | |
24 | * instead of wrapping_int as wrapping_int is to be depricated | |
25 | * at some point soon. | |
26 | * | |
27 | * Also Note that warnings will occur if instantiated with an | |
28 | * unsigned type. Only a signed type should be used! | |
29 | */ | |
30 | template<typename int_type_, int_type_ wrap_val> | |
31 | class wrapping_int { | |
32 | public: | |
33 | typedef int_type_ int_type; | |
34 | //typedef overflow_type_ overflow_type; | |
35 | static int_type wrap_value() {return wrap_val;} | |
36 | //!Add, return true if wrapped | |
37 | wrapping_int(int_type v) : value_(v) {} | |
38 | //! Explicit converion method | |
39 | int_type as_int() const {return value_;} | |
40 | operator int_type() const {return value_;} | |
41 | //!Add, return number of wraps performed | |
42 | /*! The sign of the returned value will indicate which direction the | |
43 | * wraps went. Ex: add a negative number and wrapping under could occur, | |
44 | * this would be indicated by a negative return value. If wrapping over | |
45 | * took place, a positive value would be returned */ | |
46 | template< typename IntT > | |
47 | IntT add(IntT v) | |
48 | { | |
49 | int_type remainder = static_cast<int_type>(v % (wrap_val)); | |
50 | IntT overflow = static_cast<IntT>(v / (wrap_val)); | |
51 | value_ = static_cast<int_type>(value_ + remainder); | |
52 | return calculate_wrap(overflow); | |
53 | } | |
54 | //! Subtract will return '+d' if wrapping under took place ('d' is the number of wraps) | |
55 | /*! The sign of the returned value will indicate which direction the | |
56 | * wraps went (positive indicates wrap under, negative indicates wrap over). | |
57 | * Ex: subtract a negative number and wrapping over could | |
58 | * occur, this would be indicated by a negative return value. If | |
59 | * wrapping under took place, a positive value would be returned. */ | |
60 | template< typename IntT > | |
61 | IntT subtract(IntT v) | |
62 | { | |
63 | int_type remainder = static_cast<int_type>(v % (wrap_val)); | |
64 | IntT underflow = static_cast<IntT>(-(v / (wrap_val))); | |
65 | value_ = static_cast<int_type>(value_ - remainder); | |
66 | return calculate_wrap(underflow) * -1; | |
67 | } | |
68 | private: | |
69 | int_type value_; | |
70 | ||
71 | template< typename IntT > | |
72 | IntT calculate_wrap(IntT wrap) | |
73 | { | |
74 | if ((value_) >= wrap_val) | |
75 | { | |
76 | ++wrap; | |
77 | value_ -= (wrap_val); | |
78 | } | |
79 | else if(value_ < 0) | |
80 | { | |
81 | --wrap; | |
82 | value_ += (wrap_val); | |
83 | } | |
84 | return wrap; | |
85 | } | |
86 | ||
87 | }; | |
88 | ||
89 | ||
90 | //! A wrapping integer used to wrap around at the top (WARNING: only instantiate with a signed type) | |
91 | /*! Bad name, quick impl to fix a bug -- fix later!! | |
92 | * This allows the wrap to restart at a value other than 0. | |
93 | */ | |
94 | template<typename int_type_, int_type_ wrap_min, int_type_ wrap_max> | |
95 | class wrapping_int2 { | |
96 | public: | |
97 | typedef int_type_ int_type; | |
98 | static int_type wrap_value() {return wrap_max;} | |
99 | static int_type min_value() {return wrap_min;} | |
100 | /*! If initializing value is out of range of [wrap_min, wrap_max], | |
101 | * value will be initialized to closest of min or max */ | |
102 | wrapping_int2(int_type v) : value_(v) { | |
103 | if(value_ < wrap_min) | |
104 | { | |
105 | value_ = wrap_min; | |
106 | } | |
107 | if(value_ > wrap_max) | |
108 | { | |
109 | value_ = wrap_max; | |
110 | } | |
111 | } | |
112 | //! Explicit converion method | |
113 | int_type as_int() const {return value_;} | |
114 | operator int_type() const {return value_;} | |
115 | //!Add, return number of wraps performed | |
116 | /*! The sign of the returned value will indicate which direction the | |
117 | * wraps went. Ex: add a negative number and wrapping under could occur, | |
118 | * this would be indicated by a negative return value. If wrapping over | |
119 | * took place, a positive value would be returned */ | |
120 | template< typename IntT > | |
121 | IntT add(IntT v) | |
122 | { | |
123 | int_type remainder = static_cast<int_type>(v % (wrap_max - wrap_min + 1)); | |
124 | IntT overflow = static_cast<IntT>(v / (wrap_max - wrap_min + 1)); | |
125 | value_ = static_cast<int_type>(value_ + remainder); | |
126 | return calculate_wrap(overflow); | |
127 | } | |
128 | //! Subtract will return '-d' if wrapping under took place ('d' is the number of wraps) | |
129 | /*! The sign of the returned value will indicate which direction the | |
130 | * wraps went. Ex: subtract a negative number and wrapping over could | |
131 | * occur, this would be indicated by a positive return value. If | |
132 | * wrapping under took place, a negative value would be returned */ | |
133 | template< typename IntT > | |
134 | IntT subtract(IntT v) | |
135 | { | |
136 | int_type remainder = static_cast<int_type>(v % (wrap_max - wrap_min + 1)); | |
137 | IntT underflow = static_cast<IntT>(-(v / (wrap_max - wrap_min + 1))); | |
138 | value_ = static_cast<int_type>(value_ - remainder); | |
139 | return calculate_wrap(underflow); | |
140 | } | |
141 | ||
142 | private: | |
143 | int_type value_; | |
144 | ||
145 | template< typename IntT > | |
146 | IntT calculate_wrap(IntT wrap) | |
147 | { | |
148 | if ((value_) > wrap_max) | |
149 | { | |
150 | ++wrap; | |
151 | value_ -= (wrap_max - wrap_min + 1); | |
152 | } | |
153 | else if((value_) < wrap_min) | |
154 | { | |
155 | --wrap; | |
156 | value_ += (wrap_max - wrap_min + 1); | |
157 | } | |
158 | return wrap; | |
159 | } | |
160 | }; | |
161 | ||
162 | ||
163 | ||
164 | } } //namespace date_time | |
165 | ||
166 | ||
167 | ||
168 | #endif | |
169 |