libUTL++
Number.h
1 #pragma once
2 
4 
5 #include <libutl/String.h>
6 
8 
9 UTL_NS_BEGIN;
10 
12 
20 
22 template <class T>
23 class Number : public Object
24 {
26 
27 public:
32  Number(T n)
33  {
34  set(n);
35  }
36 
37  virtual void copy(const Object& rhs);
38 
39  virtual int compare(const Object& rhs) const;
40 
41  virtual void serialize(Stream& stream, uint_t io, uint_t mode = ser_default);
42 
43  String toString() const;
44 
49  String toString(const char* fmt) const;
50 
52  T
53  get() const
54  {
55  return _n;
56  }
57 
59  void
60  set(T n)
61  {
62  _n = n;
63  }
64 
66  virtual Number<T>&
67  set(const String&)
68  {
69  ABORT();
70  return self;
71  }
72 
74  operator T() const
75  {
76  return _n;
77  }
78 
80 
81  Number<T>& operator+=(T rhs)
82  {
83  _n += rhs;
84  return self;
85  }
86 
87  Number<T>& operator-=(T rhs)
88  {
89  _n -= rhs;
90  return self;
91  }
92 
93  Number<T>& operator*=(T rhs)
94  {
95  _n *= rhs;
96  return self;
97  }
98 
99  Number<T>& operator/=(T rhs)
100  {
101  _n /= rhs;
102  return self;
103  }
104 
105  Number<T>& operator+=(const Number<T>& rhs)
106  {
107  _n += rhs._n;
108  return self;
109  }
110 
111  Number<T>& operator-=(const Number<T>& rhs)
112  {
113  _n -= rhs._n;
114  return self;
115  }
116 
117  Number<T>& operator*=(const Number<T>& rhs)
118  {
119  _n *= rhs._n;
120  return self;
121  }
122 
123  Number<T>& operator/=(const Number<T>& rhs)
124  {
125  _n /= rhs._n;
126  return self;
127  }
129 
131 
132  T operator+(T rhs) const
133  {
134  return _n + rhs;
135  }
136 
137  T operator-(T rhs) const
138  {
139  return _n - rhs;
140  }
141 
142  T operator*(T rhs) const
143  {
144  return _n * rhs;
145  }
146 
147  T operator/(T rhs) const
148  {
149  return _n / rhs;
150  }
151 
152  T operator+(const Number<T>& rhs) const
153  {
154  return _n + rhs._n;
155  }
156 
157  T operator-(const Number<T>& rhs) const
158  {
159  return _n - rhs._n;
160  }
161 
162  Number<T> operator*(const Number<T>& rhs) const
163  {
164  return _n * rhs._n;
165  }
166 
167  Number<T> operator/(const Number<T>& rhs) const
168  {
169  return _n / rhs._n;
170  }
171 
172  Number<T>& operator++()
173  {
174  ++_n;
175  return self;
176  }
177 
178  Number<T>& operator--()
179  {
180  --_n;
181  return self;
182  }
183 
184  T operator++(int)
185  {
186  return _n++;
187  }
188 
189  T operator--(int)
190  {
191  return _n--;
192  }
194 protected:
195  T _n;
196 
197 private:
198  void
199  init()
200  {
201  _n = 0;
202  }
203 
204  void
205  deInit()
206  {
207  }
208 };
209 
211 
212 UTL_NS_END;
213 
215 
216 #include <libutl/Tokenizer.h>
217 
219 
221 
223 
224 UTL_NS_BEGIN;
225 
227 
228 template <class T>
229 void
231 {
232  auto& num = utl::cast<Number<T>>(rhs);
233  super::copy(num);
234  _n = num._n;
235 }
236 
238 
239 template <class T>
240 int
241 Number<T>::compare(const Object& rhs) const
242 {
243  int res;
244  if (rhs.isA(Number<T>))
245  {
246  auto& num = utl::cast<Number<T>>(rhs);
247  res = utl::compare(_n, num._n);
248  }
249  else
250  {
251  res = super::compare(rhs);
252  }
253  return res;
254 }
255 
257 
258 template <class T>
259 void
261 {
262  super::serialize(stream, io, mode);
263  if (io == io_rd)
264  {
265  String s;
266  s.serializeIn(stream, mode);
267  set(s);
268  }
269  else
270  {
271  toString().serializeOut(stream, mode);
272  }
273 }
274 
276 
277 template <class T>
278 String
280 {
281  char fmt[64] = "%";
282  strcat(fmt, Printf<T>::formatType);
283  return toString(fmt);
284 }
285 
287 
288 template <class T>
289 String
290 Number<T>::toString(const char* fmt) const
291 {
292  char buf[256];
293  sprintf(buf, fmt, _n);
294  return buf;
295 }
296 
298 
299 UTL_NS_END;
#define UTL_CLASS_IMPL_TPL(className, T)
Implementation of standard UTL++ functionality for a template class.
Definition: macros.h:906
void serializeIn(Stream &is, uint_t mode=ser_default)
Serialize from an input stream.
Definition: Object.h:164
String toString(const FwdIt &begin, const FwdIt &end, const String &sep, bool key=false)
Obtain a string representation of a sequence (via Object::toString()).
void serialize(bool &b, Stream &stream, uint_t io, uint_t mode=ser_default)
Serialize a boolean.
void deInit()
De-initialize UTL++.
default representation (via getSerializeMode())
Definition: util.h:75
Numeric value.
Definition: Number.h:23
Character string.
Definition: String.h:31
void copy(T *dest, const T *src, size_t len)
Copy one array of objects to another.
Definition: util_inl.h:690
read
Definition: util.h:58
void serializeOut(Stream &os, uint_t mode=ser_default) const
Serialize to an output stream.
Definition: Object.h:175
unsigned int uint_t
Unsigned integer.
Definition: types.h:59
Number(T n)
Constructor.
Definition: Number.h:32
#define ABORT()
Immediately terminates the program.
Definition: macros.h:59
Stream I/O abstraction.
Definition: Stream.h:68
Provide printf formatting strings for common types.
Definition: types.h:435
#define UTL_CLASS_DECL_TPL(DC, T, BC)
Declaration of standard UTL++ functionality for a template class with one parameter.
Definition: macros.h:713
Root of UTL++ class hierarchy.
Definition: Object.h:52
int compare(bool lhs, bool rhs)
Compare two boolean values.
void init()
Initialize UTL++.