00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
#ifndef _unumber_hh
00026
#define _unumber_hh
00027
00028
00029
00030
00031
00034 class UIntgBase {
00035
private:
00036
int value;
00037
00038
public:
00039
UIntgBase(
int v = 0) : value(v) {}
00040
UIntgBase(
const UIntgBase& v) : value(v.
value) {}
00041
UIntgBase(
const UFloatBase& v);
00042
UIntgBase(
const UStr& v);
00043
00044
00045
00046
int getValue()
const {
return value;}
00047
00048 virtual void changed(
bool update_now) {}
00050
00051
00052
00053
void set(
int);
00054
void set(
const UIntgBase&);
00055
void set(
const UFloatBase&);
00056
void set(
const UStr&);
00057
00058
UIntgBase& operator=(
int v) {set(v);
return *
this;}
00059
UIntgBase& operator=(
const UIntgBase& v) {set(v);
return *
this;}
00060
UIntgBase& operator=(
const UFloatBase& v) {set(v);
return *
this;}
00061
00062 UIntgBase& operator=(
const UStr& v) {set(v);
return *
this;}
00067
00068
00069
void incr(
int);
00070
void incr(
const UIntgBase&);
00071
void decr(
int);
00072
void decr(
const UIntgBase&);
00073
00074
UIntgBase& operator++() {incr(1);
return *
this;}
00075
UIntgBase& operator++(
int) {incr(1);
return *
this;}
00076
UIntgBase& operator--() {decr(1);
return *
this;}
00077
UIntgBase& operator--(
int) {decr(1);
return *
this;}
00078
00079
00080
00081
bool equals(
int v)
const {
return value == v;}
00082
bool equals(
const UIntgBase& v)
const {
return value == v.value;}
00083
bool equals(
const UFloatBase& v)
const;
00084
00085
friend bool operator==(
const UIntgBase& v1,
int v2)
00086 {
return v1.
equals(v2);}
00087
00088
friend bool operator==(
int v1,
const UIntgBase& v2)
00089 {
return v2.
equals(v1);}
00090
00091
friend bool operator==(
const UIntgBase& v1,
const UIntgBase& v2)
00092 {
return v1.
equals(v2);}
00093
00094
friend bool operator==(
const UIntgBase& v1,
const UFloatBase& v2)
00095 {
return v1.
equals(v2);}
00096
00097
friend bool operator==(
const UFloatBase& v1,
const UIntgBase& v2)
00098 {
return v2.
equals(v1);}
00099 };
00100
00101
00102
00103
00106 class UIntg:
public UIntgBase,
public UBrick {
00107
public:
00108
UIntg(
int v = 0) :
UIntgBase(v) {}
00109
UIntg(
const UIntg& v) :
UIntgBase(v) {}
00110
UIntg(
const UIntgBase& v) :
UIntgBase(v) {}
00111
UIntg(
const UFloatBase& v) :
UIntgBase(v) {}
00112
UIntg(
const UStr& v) :
UIntgBase(v) {}
00113
00114
virtual void changed(
bool update_now);
00116
00117
virtual void onChange(UCall&);
00119
00120
00121
00122
UIntg& operator=(
int v) {set(v);
return *
this;}
00123
UIntg& operator=(
const UIntg& v) {set(v);
return *
this;}
00124
UIntg& operator=(
const UIntgBase& v) {set(v);
return *
this;}
00125
UIntg& operator=(
const UFloatBase& v) {set(v);
return *
this;}
00126
00127 UIntg& operator=(
const UStr& v) {set(v);
return *
this;}
00131
00132
00133
UIntg& operator++() {incr(1);
return *
this;}
00134
UIntg& operator++(
int) {incr(1);
return *
this;}
00135
UIntg& operator--() {decr(1);
return *
this;}
00136
UIntg& operator--(
int) {decr(1);
return *
this;}
00137 };
00138
00139
00140
00141
00144 class UFloatBase {
00145
private:
00146
float value;
00147
00148
public:
00149
UFloatBase(
float v = 0.0) : value(v) {}
00150
UFloatBase(
const UFloatBase& v) : value(v.
getValue()) {}
00151
UFloatBase(
const UIntgBase& v) : value(v.
getValue()) {}
00152
UFloatBase(
const UStr& v);
00153
00154
00155
00156
float getValue()
const {
return value;}
00157
00158 virtual void changed(
bool update_now) {}
00160
00161
00162
00163
void set(
float);
00164
void set(
const UIntgBase&);
00165
void set(
const UFloatBase&);
00166
void set(
const UStr&);
00167
00168
UFloatBase& operator=(
float v) {set(v);
return *
this;}
00169
UFloatBase& operator=(
const UFloatBase& v) {set(v);
return *
this;}
00170
UFloatBase& operator=(
const UIntgBase& v) {set(v);
return *
this;}
00171 UFloatBase& operator=(
const UStr& v) {set(v);
return *
this;}
00175
00176
00177
void incr(
float);
00178
void incr(
const UFloatBase&);
00179
void decr(
float);
00180
void decr(
const UFloatBase&);
00181
00182
UFloatBase& operator++() {incr(1.);
return *
this;}
00183
UFloatBase& operator++(
int) {incr(1.);
return *
this;}
00184
UFloatBase& operator--() {decr(1.);
return *
this;}
00185
UFloatBase& operator--(
int) {decr(1.);
return *
this;}
00186
00187
00188
00189
bool equals(
float v)
const {
return value == v;}
00190
bool equals(
const UIntgBase& v)
const {
return value == v.getValue();}
00191
bool equals(
const UFloatBase& v)
const {
return value == v.getValue();}
00192
00193
friend bool operator==(
const UFloatBase& v1,
float v2)
00194 {
return v1.
equals(v2);}
00195
00196
friend bool operator==(
float v1,
const UFloatBase& v2)
00197 {
return v2.
equals(v1);}
00198
00199
friend bool operator==(
const UFloatBase& v1,
const UFloatBase& v2)
00200 {
return v1.
equals(v2);}
00201 };
00202
00203
00204
00205
00208 class UFloat:
public UFloatBase,
public UBrick {
00209
public:
00210
UFloat(
float v = 0.0) :
UFloatBase(v) {}
00211
UFloat(
const UFloat& v) :
UFloatBase(v) {}
00212
UFloat(
const UFloatBase& v) :
UFloatBase(v) {}
00213
UFloat(
const UIntgBase& v) :
UFloatBase(v) {}
00214
UFloat(
const UStr& v) :
UFloatBase(v) {}
00215
00216
virtual void changed(
bool update_now);
00218
00219
virtual void onChange(UCall&);
00221
00222
00223
00224
UFloat& operator=(
float v) {set(v);
return *
this;}
00225
UFloat& operator=(
const UFloat& v) {set(v);
return *
this;}
00226
UFloat& operator=(
const UFloatBase& v) {set(v);
return *
this;}
00227
UFloat& operator=(
const UIntgBase& v) {set(v);
return *
this;}
00228 UFloat& operator=(
const UStr& v) {set(v);
return *
this;}
00232
00233
00234
UFloat& operator++() {incr(1.);
return *
this;}
00235
UFloat& operator++(
int) {incr(1.);
return *
this;}
00236
UFloat& operator--() {decr(1.);
return *
this;}
00237
UFloat& operator--(
int) {decr(1.);
return *
this;}
00238 };
00239
00240
00241
#endif
00242
00243