SEScalar.h
1/* Distributed under the Apache License, Version 2.0.
2See accompanying NOTICE file for details.*/
3
4#pragma once
5#include "cdm/properties/SEProperty.h"
6
7#define ZERO_APPROX 1e-10
8
9class CDM_DECL NoUnit
10{
11public:
12 NoUnit() {}
13 virtual ~NoUnit() {}
14
15 static const NoUnit unitless;
16};
17
18class CDM_DECL SEScalar : public SEProperty
19{
20 friend class PBProperty;//friend the serialization class
21protected:
22 double m_value;
23
24 bool m_isnan=true;
25 bool m_isinf=false;
26 bool m_readOnly=false;
27
28public:
29 SEScalar();
30 virtual ~SEScalar();
31
36 virtual void Invalidate();
37 virtual void ForceInvalidate();
38
43 bool Set(const SEScalar& s);
44 bool Force(const SEScalar& s);
45
51 void Copy(const SEScalar& s);
52
53 virtual bool IsValid() const;
54 bool IsInfinity() const { return m_isinf; }
55
56 bool IsPositive() const;
57 bool IsNegative() const;
58 bool IsZero(double limit = ZERO_APPROX) const;
59
60 void SetReadOnly(bool b);
61 bool IsReadOnly() const;
62
63 double GetValue() const;
64 void SetValue(double d);
65 void ForceValue(double d);
66
67 double Increment(const SEScalar& s);
68 double IncrementValue(double d);
69 double ForceIncrementValue(double d);
70
71 double Multiply(const SEScalar& s);
72 double MultiplyValue(double d);
73
74 void Average(int cnt);
75
76 bool Equals(const SEScalar& to) const;
77
78 virtual std::string ToString() const;
79 virtual void ToString(std::ostream &str) const;
80
81 static double dNaN();
82 static bool IsNumber(double d);
83 static bool IsZero(double value, double limit);
84 static bool IsValue(double target, double value);
85};
86
87inline std::ostream& operator<< (std::ostream& out, const SEScalar* s)
88{
89 if (s == nullptr)
90 out << SEScalar::dNaN() << std::flush;
91 else
92 (*s).ToString(out);
93 return out;
94}
95inline std::ostream& operator<< (std::ostream& out, const SEScalar& s)
96{
97 s.ToString(out);
98 return out;
99}
100
101template <typename Enum>
102class CDM_DECL SEScalarEnum : public SEScalar
103{
104public:
105 SEScalarEnum() : SEScalar() { Invalidate(); }
106 virtual ~SEScalarEnum() { Invalidate(); }
107
108 virtual void Invalidate() override
109 {
111 m_enum = (Enum)-1;
112 }
113 virtual void ForceInvalidate() override
114 {
116 m_enum = (Enum)-1;
117 }
118
119 void Set(const SEScalarEnum<Enum>& s)
120 {
121 SEScalar::Set(s);
122 m_enum = s.m_enum;
123 }
125 {
126 SEScalar::Set(s);
127 m_enum = s.m_enum;
128 }
129
130 Enum GetEnum() const { return m_enum; }
131 //void SetEnum(Enum e)
132 //{
133 // m_enum = e;
134 // SetValue((double)e);
135 //}
136 void operator=(const Enum& e)
137 {
138 m_enum = e;
139 SetValue((double)e);
140 }
141 bool operator==(const Enum& e)
142 {
143 return m_enum == e;
144 }
145 bool operator!=(const Enum& e)
146 {
147 return m_enum != e;
148 }
149
150private:
152
155 using SEScalar::IsZero;
156
157 using SEScalar::SetValue;
159
163
164 using SEScalar::Multiply;
166
167 using SEScalar::Average;
168
169protected:
170 Enum m_enum;
171};
172
178class CDM_DECL SEUnitScalar : public SEScalar
179{
180 friend class PBProperty;//friend the serialization class
182public:
183
185 virtual ~SEUnitScalar() {}
186
187 virtual bool IsValid() const = 0;
188 virtual void Invalidate() = 0;
189 virtual void ForceInvalidate() = 0;
190 virtual bool HasUnit() const = 0;
191 virtual const CCompoundUnit* GetUnit() const = 0;
192
193 virtual bool Set(const SEScalar& s) = 0;
194 virtual bool Force(const SEScalar& s) = 0;
195 virtual void Copy(const SEScalar& s) = 0;
196 virtual double GetValue(const CCompoundUnit& unit) const = 0;
197 virtual void SetValue(double d, const CCompoundUnit& unit) = 0;
198 virtual void ForceValue(double d, const CCompoundUnit& unit) = 0;
199 virtual double IncrementValue(double d, const CCompoundUnit& unit) = 0;
200 virtual double ForceIncrementValue(double d, const CCompoundUnit& unit) = 0;
201 virtual double MultiplyValue(double d, const CCompoundUnit& unit) = 0;
202
203protected:
204 virtual const CCompoundUnit* GetCompoundUnit(const std::string& unit) const = 0;
205};
206
207template <typename Unit>
209{
210 friend class PBProperty;//friend the serialization class
211public:
213 virtual ~SEScalarQuantity();
214
215 virtual void Invalidate() override;
216 virtual void ForceInvalidate() override;
217 virtual bool IsValid() const override;
218
219protected:
220
221 // We need to support the SEUnitScalar interface, but make these protected
222 // If you want access in a generic unit way, us an SEGenericScalar wrapper
223 bool Set(const SEScalar& s) override;
224 void Copy(const SEScalar& s) override;
225 bool Force(const SEScalar& s) override;
226
227 virtual double GetValue(const CCompoundUnit& unit) const override;
228 virtual void SetValue(double d, const CCompoundUnit& unit) override;
229 virtual void ForceValue(double d, const CCompoundUnit& unit) override;
230 virtual double IncrementValue(double d, const CCompoundUnit& unit) override;
231 virtual double ForceIncrementValue(double d, const CCompoundUnit& unit) override;
232 virtual double MultiplyValue(double d, const CCompoundUnit& unit) override;
233
234 virtual const CCompoundUnit* GetCompoundUnit(const std::string& unit) const override;
235
236public:
237
238 virtual bool Set(const SEScalarQuantity<Unit>& s);
239 virtual void Copy(const SEScalarQuantity<Unit>& s);
240 virtual bool Force(const SEScalarQuantity<Unit>& s);
241
242 bool HasUnit() const override;
243 const Unit* GetUnit() const override;
244
245 double GetValue() const = delete;// Must provide a unit
246 virtual double GetValue(const Unit& unit) const;
247
248 void SetValue(double d) = delete;// Must provide a unit
249 virtual void SetValue(double d, const Unit& unit);
250
251 void ForceValue(double d) = delete;// Must provide a unit
252 virtual void ForceValue(double d, const Unit& unit);
253
254 double Increment(const SEScalar& s) = delete;// Must provide a unit
255 virtual double Increment(const SEScalarQuantity& s);
256
257 double IncrementValue(double d) = delete;// Must provide a unit
258 virtual double IncrementValue(double d, const Unit& unit);
259
260 double ForceIncrementValue(double d) = delete;// Must provide a unit
261 virtual double ForceIncrementValue(double d, const Unit& unit);
262
263 double MultiplyValue(double d) = delete;// Must provide a unit
264 virtual double MultiplyValue(double d, const Unit& unit);
265
266 double Multiply(const SEScalar& s) = delete;// Must provide a unit
267 virtual double Multiply(const SEScalarQuantity& s);
268
269 bool Equals(const SEScalar& to) const = delete;// Must provide a unit
270 virtual bool Equals(const SEScalarQuantity<Unit>& to) const;
271
272 std::string ToString() const override;
273 void ToString(std::ostream &str) const override;
274
275protected:
276 const Unit* m_unit=nullptr;
277};
278
279
280// I created this class for use in connecting DataRequests to SEScalars for the PhysiologyEngineTrack class
286class CDM_DECL SEGenericScalar : public Loggable
287{
288 friend class PBProperty;//friend the serialization class
289public:
290 SEGenericScalar(Logger* logger);
291 virtual ~SEGenericScalar() {};
292
293 virtual bool HasScalar() const;
294 virtual void SetScalar(const SEScalar& s);
295
296 virtual bool IsValid() const;
297 virtual bool IsInfinity() const;
298
299 virtual bool HasUnit() const;
300 virtual const CCompoundUnit* GetUnit() const;
301 virtual bool IsValidUnit(const CCompoundUnit& unit) const;
302 virtual const CCompoundUnit* GetCompoundUnit(const std::string& unit) const;
303
304 virtual double GetValue() const;
305 virtual double GetValue(const CCompoundUnit& unit) const;
306
307 std::string GetString() const;
308
309protected:
310
313};
314
315inline void Override(const SEScalar& from, SEScalar& to)
316{
317 bool b = to.IsReadOnly();
318 to.SetReadOnly(false);
319 to.Set(from);
320 to.SetReadOnly(b);
321}
322template<class Unit>
323inline void Override(const SEScalarQuantity<Unit>& from, SEScalarQuantity<Unit>& to)
324{
325 bool b = to.IsReadOnly();
326 to.SetReadOnly(false);
327 to.Set(from);
328 to.SetReadOnly(b);
329}
330
331inline void ValueOverride(SEScalar& s, double value)
332{
333 bool b = s.IsReadOnly();
334 s.SetReadOnly(false);
335 s.SetValue(value);
336 s.SetReadOnly(b);
337}
338template<class Unit>
339inline void ValueOverride(SEScalarQuantity<Unit>& s, double value, const Unit& unit)
340{
341 bool b = s.IsReadOnly();
342 s.SetReadOnly(false);
343 s.SetValue(value, unit);
344 s.SetReadOnly(b);
345}
346
347inline void IncrementOverride(SEScalar& s, double value)
348{
349 bool b = s.IsReadOnly();
350 s.SetReadOnly(false);
351 s.IncrementValue(value);
352 s.SetReadOnly(b);
353}
354template<class Unit>
355inline void IncrementOverride(SEScalarQuantity<Unit>& s, double value, const Unit& unit)
356{
357 bool b = s.IsReadOnly();
358 s.SetReadOnly(false);
359 s.IncrementValue(value, unit);
360 s.SetReadOnly(b);
361}
362
363#define DEFINE_SCALAR_PTR(name, type) \
364 public: \
365 bool Has##name() const \
366 { \
367 return m_##name==nullptr?false:m_##name->IsValid(); \
368 } \
369 SEScalar##type& Get##name() \
370 { \
371 if(m_##name==nullptr) \
372 m_##name = new SE##type(); \
373 return *m_##name; \
374 } \
375 double Get##name() const \
376 { \
377 if (m_##name == nullptr) \
378 return SEScalar::dNaN(); \
379 return m_##name->GetValue(); \
380 } \
381 protected: \
382 SEScalar##type m_##name;
383
384#define DEFINE_UNIT_SCALAR_PTR(name, type) \
385 public: \
386 bool Has##name() const \
387 { \
388 return m_##name==nullptr?false:m_##name->IsValid(); \
389 } \
390 SEScalar##type& Get##name() \
391 { \
392 if(m_##name==nullptr) \
393 m_##name = new SE##type(); \
394 return *m_##name; \
395 } \
396 double Get##name(const type##Unit& unit) const \
397 { \
398 if (m_##name == nullptr) \
399 return SEScalar::dNaN(); \
400 return m_##name->GetValue(unit); \
401 } \
402 protected: \
403 SEScalar##type m_##name;
404
405#define DEFINE_SCALAR(name, type) \
406 public: \
407 bool Has##name() const { return m_##name.IsValid(); } \
408 SEScalar##type& Get##name() { return m_##name; } \
409 double Get##name() const { return m_##name.GetValue(); } \
410 protected: \
411 SEScalar##type m_##name;
412
413#define DEFINE_UNIT_SCALAR(name, type) \
414 public: \
415 bool Has##name() const { return m_##name.IsValid(); } \
416 SEScalar##type& Get##name() { return m_##name; } \
417 double Get##name(const type##Unit& unit) const { return m_##name.GetValue(unit); } \
418 protected: \
419 SEScalar##type m_##name;
Definition: CompoundUnit.h:40
Definition: Logger.h:23
Definition: Logger.h:71
Definition: SEScalar.h:10
static const NoUnit unitless
Definition: SEScalar.h:15
virtual ~NoUnit()
Definition: SEScalar.h:13
NoUnit()
Definition: SEScalar.h:12
Definition: PBProperties.h:86
static void Copy(const SECurve &src, SECurve &dst)
Definition: PBProperties.cpp:81
If you want to querry what a scalar is and don't know what scalar type you have...
Definition: SEScalar.h:287
const SEScalar * m_Scalar
Definition: SEScalar.h:311
const SEUnitScalar * m_UnitScalar
Definition: SEScalar.h:312
virtual ~SEGenericScalar()
Definition: SEScalar.h:291
Definition: SEProperty.h:8
Definition: SEScalar.h:103
bool operator==(const Enum &e)
Definition: SEScalar.h:141
Enum m_enum
Definition: SEScalar.h:170
bool operator!=(const Enum &e)
Definition: SEScalar.h:145
void operator=(const Enum &e)
Definition: SEScalar.h:136
void Set(const SEScalarEnum< Enum > &s)
Definition: SEScalar.h:119
Enum GetEnum() const
Definition: SEScalar.h:130
void Copy(const SEScalarEnum< Enum > &s)
Definition: SEScalar.h:124
virtual void ForceInvalidate() override
Definition: SEScalar.h:113
SEScalarEnum()
Definition: SEScalar.h:105
virtual ~SEScalarEnum()
Definition: SEScalar.h:106
virtual void Invalidate() override
Definition: SEScalar.h:108
Definition: SEScalar.h:19
double MultiplyValue(double d)
Definition: SEScalar.cpp:210
double Multiply(const SEScalar &s)
Definition: SEScalar.cpp:201
double ForceIncrementValue(double d)
Definition: SEScalar.cpp:190
bool IsInfinity() const
Definition: SEScalar.h:54
bool Set(const SEScalar &s)
Definition: SEScalar.cpp:41
virtual void ForceInvalidate()
Definition: SEScalar.cpp:94
static double dNaN()
Definition: SEScalar.cpp:10
void Average(int cnt)
Definition: SEScalar.cpp:221
double IncrementValue(double d)
Definition: SEScalar.cpp:179
void SetReadOnly(bool b)
Definition: SEScalar.cpp:129
void ForceValue(double d)
Definition: SEScalar.cpp:158
void SetValue(double d)
Definition: SEScalar.cpp:145
virtual std::string ToString() const
Definition: SEScalar.cpp:241
bool IsReadOnly() const
Definition: SEScalar.cpp:133
virtual void Invalidate()
Definition: SEScalar.cpp:85
bool IsPositive() const
Definition: SEScalar.cpp:115
double m_value
Definition: SEScalar.h:22
bool IsZero(double limit=ZERO_APPROX) const
Definition: SEScalar.cpp:108
bool IsNegative() const
Definition: SEScalar.cpp:122
double Increment(const SEScalar &s)
Definition: SEScalar.cpp:170
Definition: SEScalar.h:209
bool Force(const SEScalar &s) override
Definition: SEScalar.cpp:341
double IncrementValue(double d)=delete
double ForceIncrementValue(double d)=delete
virtual double ForceIncrementValue(double d, const CCompoundUnit &unit) override
Definition: SEScalar.cpp:490
double GetValue() const =delete
virtual void ForceValue(double d, const CCompoundUnit &unit) override
Definition: SEScalar.cpp:438
virtual void Invalidate() override
Definition: SEScalar.cpp:275
virtual bool IsValid() const override
Definition: SEScalar.cpp:289
void SetValue(double d)=delete
virtual void ForceInvalidate() override
Definition: SEScalar.cpp:282
const Unit * GetUnit() const override
Definition: SEScalar.cpp:394
virtual double IncrementValue(double d, const CCompoundUnit &unit) override
Definition: SEScalar.cpp:469
double MultiplyValue(double d)=delete
double Multiply(const SEScalar &s)=delete
void ForceValue(double d)=delete
const Unit * m_unit
Definition: SEScalar.h:276
bool HasUnit() const override
Definition: SEScalar.cpp:389
virtual const CCompoundUnit * GetCompoundUnit(const std::string &unit) const override
Definition: SEScalar.cpp:547
bool Set(const SEScalar &s) override
Definition: SEScalar.cpp:299
SEScalarQuantity()
Definition: SEScalar.h:212
std::string ToString() const override
Definition: SEScalar.cpp:553
void Copy(const SEScalar &s) override
Definition: SEScalar.cpp:326
double Increment(const SEScalar &s)=delete
virtual void SetValue(double d, const CCompoundUnit &unit) override
Definition: SEScalar.cpp:430
virtual double MultiplyValue(double d, const CCompoundUnit &unit) override
Definition: SEScalar.cpp:521
virtual ~SEScalarQuantity()
Definition: SEScalar.cpp:269
bool Equals(const SEScalar &to) const =delete
An interface to be used for gaining access to a scalar with any unit type
Definition: SEScalar.h:179
SEUnitScalar()
Definition: SEScalar.h:184
virtual double ForceIncrementValue(double d, const CCompoundUnit &unit)=0
friend SEGenericScalar
Definition: SEScalar.h:181
virtual double MultiplyValue(double d, const CCompoundUnit &unit)=0
virtual ~SEUnitScalar()
Definition: SEScalar.h:185
virtual bool Set(const SEScalar &s)=0
virtual void Invalidate()=0
virtual void SetValue(double d, const CCompoundUnit &unit)=0
virtual bool HasUnit() const =0
virtual double GetValue(const CCompoundUnit &unit) const =0
virtual void Copy(const SEScalar &s)=0
virtual bool Force(const SEScalar &s)=0
virtual const CCompoundUnit * GetUnit() const =0
virtual double IncrementValue(double d, const CCompoundUnit &unit)=0
virtual void ForceInvalidate()=0
virtual void ForceValue(double d, const CCompoundUnit &unit)=0
virtual bool IsValid() const =0
virtual const CCompoundUnit * GetCompoundUnit(const std::string &unit) const =0

Distributed under the Apache License, Version 2.0.

See accompanying NOTICE file for details.