ubit
unumber.hpp
1 /************************************************************************
2  *
3  * unumber.hpp
4  * Ubit GUI Toolkit - Version 6
5  * (C) 2009 | Eric Lecolinet | TELECOM ParisTech | http://www.enst.fr/~elc/ubit
6  *
7  * ***********************************************************************
8  * COPYRIGHT NOTICE :
9  * THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY AND WITHOUT EVEN THE
10  * IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
11  * YOU CAN REDISTRIBUTE IT AND/OR MODIFY IT UNDER THE TERMS OF THE GNU
12  * GENERAL PUBLIC LICENSE AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION;
13  * EITHER VERSION 2 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
14  * SEE FILES 'COPYRIGHT' AND 'COPYING' FOR MORE DETAILS.
15  * ***********************************************************************/
16 
17 #ifndef _unumber_hpp_
18 #define _unumber_hpp_ 1
19 #include <iostream>
20 #include <ubit/unode.hpp>
21 namespace ubit {
22 
23 // !!! should not inherit from UNode
24 
27 class UNumber: public UNode {
28 public:
29  //UCLASS("#number", UNumber, null)
30  UABSTRACT_CLASS(UNumber)
31 
32  virtual int intValue() const = 0;
33  virtual float floatValue() const = 0;
34  virtual double doubleValue() const = 0;
35  virtual UStr toString() const = 0;
36 
37  virtual UNumber& onChange(UCall&);
39 
40  virtual void changed(bool = true);
42 };
43 
44 
45 /* ==================================================== ===== ======= */
48 class UInt : public UNumber {
49 public:
50  UCLASS(UInt)
51 
52  UInt(int v = 0) : value(v) {}
53  UInt(const UInt& v) : value(v.value) {}
54  UInt(const UStr&);
55  UInt(const std::string&);
56 
57  operator int() const {return value;}
59 
60  friend std::istream& operator>>(std::istream&, UInt&);
62 
63  int intValue() const {return value;}
64  float floatValue() const {return float(value);}
65  double doubleValue() const {return double(value);}
66  UStr toString() const;
67  //static int parseInt(String s);
68  //static int parseInt(String s, int radix);
69 
70  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
71 
72  UInt& operator=(int v) {return setImpl(v);}
73  UInt& operator=(const UInt& v) {return setImpl(v.value);}
74 
75  UInt& operator=(const char* s) {return setImpl(s);}
76  UInt& operator=(const UStr& s);
77  UInt& operator=(const std::string& s);
78 
79  friend std::ostream& operator<<(std::ostream&, const UInt&);
81 
82  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
83 
84  bool operator==(int v) const {return value == v;}
85  bool operator==(double v) const {return value == v;}
86  bool operator==(const UInt& v) const {return value == v.value;}
87 
88  bool operator!=(int v) const {return value != v;}
89  bool operator!=(double v) const {return value != v;}
90  bool operator!=(const UInt& v) const {return value != v.value;}
91 
92  bool operator<(int v) const {return value < v;}
93  bool operator<(double v) const {return value < v;}
94  bool operator<(const UInt& v) const {return value < v.value;}
95 
96  bool operator<=(int v) const {return value <= v;}
97  bool operator<=(double v) const {return value <= v;}
98  bool operator<=(const UInt& v) const {return value <= v.value;}
99 
100  bool operator>(int v) const {return value > v;}
101  bool operator>(double v) const {return value > v;}
102  bool operator>(const UInt& v) const {return value > v.value;}
103 
104  bool operator>=(int v) const {return value >= v;}
105  bool operator>=(double v) const {return value >= v;}
106  bool operator>=(const UInt& v) const {return value >= v.value;}
107 
108  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
109 
110  UInt& operator++() {return setImpl(value+1);}
111  UInt operator++(int);
112  UInt& operator--() {return setImpl(value-1);}
113  UInt operator--(int);
114 
115  UInt& operator+=(int v) {return setImpl(value+v);}
116  UInt& operator+=(const UInt& v) {return setImpl(value+v.value);}
117  UInt& operator-=(int v) {return setImpl(value-v);}
118  UInt& operator-=(const UInt& v) {return setImpl(value-v.value);}
119  UInt& operator*=(int v) {return setImpl(value*v);}
120  UInt& operator*=(const UInt& v) {return setImpl(value*v.value);}
121  UInt& operator/=(int v) {return setImpl(value/v);}
122  UInt& operator/=(const UInt& v) {return setImpl(value/v.value);}
123 
124  // - - - Impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
125 
126  virtual UInt& setImpl(int, bool call_callbacks = true);
127  virtual UInt& setImpl(const char*, bool call_callbacks = true);
129 
130 private:
131  friend class UFloat;
132  friend class UDouble;
133  int value;
134 };
135 
136 
137 /* ==================================================== ===== ======= */
140 class UFloat : public UNumber {
141 public:
142  UCLASS(UFloat)
143 
144  UFloat(float v = 0.0) : value(v) {}
145  UFloat(const UFloat& v) : value(v.value) {}
146  UFloat(const UInt& v) : value(v.value) {}
147  //UFloat(const char*); ambigu
148  UFloat(const UStr&);
149  UFloat(const std::string&);
150 
151  operator float() const {return value;}
153 
154  friend std::ostream& operator<<(std::ostream&, const UFloat&);
156 
157  int intValue() const {return int(value);}
158  float floatValue() const {return value;}
159  double doubleValue() const {return double(value);}
160  UStr toString() const;
161 
162  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
163 
164  UFloat& operator=(float v) {return setImpl(v);}
165  UFloat& operator=(const UFloat& v) {return setImpl(v.value);}
166  UFloat& operator=(const UInt& v) {return setImpl(v.value);}
167  UFloat& operator=(const char* s) {return setImpl(s);}
168  UFloat& operator=(const UStr& s);
169  UFloat& operator=(const std::string& s);
170 
171  friend std::istream& operator>>(std::istream&, UFloat&);
173 
174  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
175 
176  bool operator==(float v) const {return value == v;}
177  bool operator==(double v) const {return value == v;}
178  bool operator==(const UFloat& v) const {return value == v.value;}
179 
180  bool operator!=(float v) const {return value != v;}
181  bool operator!=(double v) const {return value != v;}
182  bool operator!=(const UFloat& v) const {return value != v.value;}
183 
184  bool operator<(float v) const {return value < v;}
185  bool operator<(double v) const {return value < v;}
186  bool operator<(const UFloat& v) const {return value < v.value;}
187 
188  bool operator<=(float v) const {return value <= v;}
189  bool operator<=(double v) const {return value <= v;}
190  bool operator<=(const UFloat& v) const {return value <= v.value;}
191 
192  bool operator>(float v) const {return value > v;}
193  bool operator>(double v) const {return value > v;}
194  bool operator>(const UFloat& v) const {return value > v.value;}
195 
196  bool operator>=(float v) const {return value >= v;}
197  bool operator>=(double v) const {return value >= v;}
198  bool operator>=(const UFloat& v) const {return value >= v.value;}
199 
200  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
201 
202  UFloat& operator++() {return setImpl(value+1);}
203  UFloat operator++(int);
204  UFloat& operator--() {return setImpl(value-1);}
205  UFloat operator--(int);
206 
207  UFloat& operator+=(int v) {return setImpl(value+v);}
208  UFloat& operator+=(const UFloat& v) {return setImpl(value+v.value);}
209  UFloat& operator-=(int v) {return setImpl(value-v);}
210  UFloat& operator-=(const UFloat& v) {return setImpl(value-v.value);}
211  UFloat& operator*=(int v) {return setImpl(value*v);}
212  UFloat& operator*=(const UFloat& v) {return setImpl(value*v.value);}
213  UFloat& operator/=(int v) {return setImpl(value/v);}
214  UFloat& operator/=(const UFloat& v) {return setImpl(value/v.value);}
215 
216  // - - - Impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
217 
218  virtual UFloat& setImpl(float, bool call_callbacks = true);
219  virtual UFloat& setImpl(const char*, bool call_callbacks = true);
221 
222 private:
223  friend class UInt;
224  friend class UDouble;
225  float value;
226 };
227 
228 
229 /* ==================================================== ===== ======= */
232 class UDouble : public UNumber {
233 public:
234  UCLASS(UDouble)
235 
236  UDouble(double v = 0.0) : value(v) {}
237  UDouble(const UDouble& v) : value(v.value) {}
238  UDouble(const UFloat& v) : value(v.value) {}
239  UDouble(const UInt& v) : value(v.value) {}
240  UDouble(const UStr&);
241  UDouble(const std::string&);
242 
243  operator double() const {return value;}
245 
246  friend std::ostream& operator<<(std::ostream&, const UDouble&);
248 
249  int intValue() const {return int(value);}
250  float floatValue() const {return float(value);}
251  double doubleValue() const {return value;}
252  UStr toString() const;
253 
254  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
255 
256  UDouble& operator=(double v) {return setImpl(v);}
257  UDouble& operator=(const UDouble& v) {return setImpl(v.value);}
258  UDouble& operator=(const UFloat& v) {return setImpl(v.value);}
259  UDouble& operator=(const UInt& v) {return setImpl(v.value);}
260 
261  UDouble& operator=(const char* s) {return setImpl(s);}
262  UDouble& operator=(const UStr& s);
263  UDouble& operator=(const std::string& s);
264 
265  friend std::istream& operator>>(std::istream&, UDouble&);
267 
268  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
269 
270  bool operator==(float v) const {return value == v;}
271  bool operator==(double v) const {return value == v;}
272  bool operator==(const UDouble& v) const {return value == v.value;}
273 
274  bool operator!=(float v) const {return value != v;}
275  bool operator!=(double v) const {return value != v;}
276  bool operator!=(const UDouble& v) const {return value != v.value;}
277 
278  bool operator<(float v) const {return value < v;}
279  bool operator<(double v) const {return value < v;}
280  bool operator<(const UDouble& v) const {return value < v.value;}
281 
282  bool operator<=(float v) const {return value <= v;}
283  bool operator<=(double v) const {return value <= v;}
284  bool operator<=(const UDouble& v) const {return value <= v.value;}
285 
286  bool operator>(float v) const {return value > v;}
287  bool operator>(double v) const {return value > v;}
288  bool operator>(const UDouble& v) const {return value > v.value;}
289 
290  bool operator>=(float v) const {return value >= v;}
291  bool operator>=(double v) const {return value >= v;}
292  bool operator>=(const UDouble& v) const {return value >= v.value;}
293 
294  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
295 
296  UDouble& operator++() {return setImpl(value+1);}
297  UDouble operator++(int);
298  UDouble& operator--() {return setImpl(value-1);}
299  UDouble operator--(int);
300 
301  UDouble& operator+=(int v) {return setImpl(value+v);}
302  UDouble& operator+=(const UDouble& v) {return setImpl(value+v.value);}
303  UDouble& operator-=(int v) {return setImpl(value-v);}
304  UDouble& operator-=(const UDouble& v) {return setImpl(value-v.value);}
305  UDouble& operator*=(int v) {return setImpl(value*v);}
306  UDouble& operator*=(const UDouble& v) {return setImpl(value*v.value);}
307  UDouble& operator/=(int v) {return setImpl(value/v);}
308  UDouble& operator/=(const UDouble& v) {return setImpl(value/v.value);}
309 
310  // - - - Impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
311 
312  virtual UDouble& setImpl(double, bool call_callbacks = true);
313  virtual UDouble& setImpl(const char*, bool call_callbacks = true);
315 
316 private:
317  friend class UInt;
318  friend class UFloat;
319  double value;
320 };
321 
322 }
323 #endif
324 
ubit::UNumber
Active Number base class.
Definition: unumber.hpp:27
ubit::UNode
Base class of objects that can be added to the UBIT scene graph (SEE DETAILS!).
Definition: unode.hpp:38
ubit::UNumber::changed
virtual void changed(bool=true)
called when object&#39;s content is changed.
Definition: unumber.cpp:36
ubit::UNumber::onChange
virtual UNumber & onChange(UCall &)
adds callbacks that are activated when the objects&#39; value changes.
Definition: unumber.cpp:31
ubit::UCall
base class of callback objects for firing functions or methods.
Definition: ucall.hpp:144
ubit::UInt
Active Integer.
Definition: unumber.hpp:48
ubit
Definition: uhardfont.hpp:31
ubit::UDouble
Active Double.
Definition: unumber.hpp:232
ubit::UFloat
Active Float.
Definition: unumber.hpp:140
ubit::UStr
Ubit String.
Definition: ustr.hpp:72
Generated by   doxygen 1.8.12