acme
Foundational cross-platform layer of the ca2 framework
Loading...
Searching...
No Matches
scalar.h
1// From template to class by camilo on 2022-11-17 04:35 ILoveYouThomasBorregaardSorensen!!
2#pragma once
3
4
5#include "acme/constant/scalar.h"
6
7
8
9//using real = ::f64;
10//using integer = ::i64;
11
12namespace number
13{
14 class CLASS_DECL_ACME number
15 {
16 public:
17
18 union
19 {
20
21 ::i8 m_i8;
22 ::u8 m_u8;
23 ::i16 m_i16;
24 ::u16 m_u16;
25 ::i32 m_i32;
26 ::u32 m_u32;
27 ::i64 m_hi;
28 ::u64 m_hn;
29
30 ::f32 m_f32;
31 ::f64 m_f64;
32
33 };
34
35 enum_number m_enumber;
36
37 number(enum_number enumber = e_number_none) { m_hi = 0; m_enumber = enumber; }
38 number(::i8 i) { m_i8 = i; m_enumber = e_number_char; }
39 number(::u8 u) { m_u8 = u; m_enumber = e_number_unsigned_char; }
40 number(::i16 i) { m_i16 = i; m_enumber = e_number_short; }
41 number(::u16 u) { m_u16 = u; m_enumber = e_number_unsigned_short; }
42 number(::i32 i) { m_i32 = i; m_enumber = e_number_int; }
43 number(::u32 u) { m_u32 = u; m_enumber = e_number_u32; }
44 number(::i64 i) { m_hi = i; m_enumber = e_number_i64; }
45 number(::u64 u) { m_hn = u; m_enumber = e_number_u64; }
46 number(::f32 f) { m_f32 = f; m_enumber = e_number_f32; }
47 number(::f64 d) { m_f64 = d; m_enumber = e_number_f64; }
48 //#ifdef __clang__
49 // number(long l) { m_hi = l; m_enumber = e_number_i64; }
50 //#endif
51
52
53 bool ok() const { return m_enumber != e_number_none; }
54 bool nok() const { return !ok(); }
55 bool is_f32() const { return m_enumber & 16; }
56 bool is_integer() const { return m_enumber & 6; }
57 bool is_signed() const { return m_enumber & 2; }
58 bool is_unsigned() const { return m_enumber & 4; }
59
60 template < typename T >
61 T get() const
62 {
63 switch (m_enumber)
64 {
65 case e_number_none:
66 return (T)0;
67 case e_number_char:
68 return (T)m_i8;
69 case e_number_unsigned_char:
70 return(T)m_u8;
71 case e_number_short:
72 return(T)m_i16;
73 case e_number_unsigned_short:
74 return (T)m_u16;
75 case e_number_int:
76 return(T)m_i32;
77 case e_number_u32:
78 return (T)m_u32;
79 case e_number_i64:
80 return(T)m_hi;
81 case e_number_u64:
82 return (T)m_hn;
83 case e_number_f32:
84 return (T)m_f32;
85 case e_number_f64:
86 return(T)m_f64;
87 };
88 return (T)0;
89 }
90
91
92 template < typename T >
93 void set(T t)
94 {
95 switch (m_enumber)
96 {
97 case e_number_none:
98 break;
99 case e_number_char:
100 m_i8 = (::i8) t;
101 break;
102 case e_number_unsigned_char:
103 m_u8 = (::u8) t;
104 break;
105 case e_number_short:
106 m_i16 = (::i16) t;
107 break;
108 case e_number_unsigned_short:
109 m_u16 = (::u16)t;
110 break;
111 case e_number_int:
112 m_i32 = (::i32)t;
113 break;
114 case e_number_u32:
115 m_u32 = (::u32)t;
116 break;
117 case e_number_i64:
118 m_hi = (::i64)t;
119 break;
120 case e_number_u64:
121 m_hn = (::u64)t;
122 break;
123 case e_number_f32:
124 m_f32 = (::f32)t;
125 break;
126 case e_number_f64:
127 m_f64 = (::f64)t;
128 break;
129 };
130
131 }
132
133 ::i8 get_char() const { return get < ::i8>(); }
134 ::u8 get_unsigned_char() const { return get < ::u8>(); }
135 ::i16 get_short() const { return get < ::i16>(); }
136 ::u16 get_unsigned_short() const { return get < ::u16>(); }
137 ::i32 get_int() const { return get < ::i32>(); }
138 ::u32 get_u32() const { return get < ::u32>(); }
139 ::i64 get_i64() const { return get < ::i64>(); }
140 ::u64 get_u64() const { return get < ::u64>(); }
141 ::f32 get_f32() const { return get < ::f32>(); }
142 ::f64 get_f64() const { return get < ::f64>(); }
143
144
145 ::number::number operator + (const number& number) const
146 {
147
148 ::number::number numberResult;
149
150 numberResult.m_enumber = maximum(m_enumber, number.m_enumber);
151
152 if (numberResult.is_f32())
153 {
154
155 numberResult.set(get_f64() + number.get_f64());
156
157 }
158 else if (numberResult.is_integer())
159 {
160
161 numberResult.set(get_i64() + number.get_i64());
162
163 }
164
165 return numberResult;
166
167 }
168
169
170 ::number::number operator - (const number& number) const
171 {
172
173 ::number::number numberResult;
174
175 numberResult.m_enumber = maximum(m_enumber, number.m_enumber);
176
177 if (numberResult.is_f32())
178 {
179
180 numberResult.set(get_f64() - number.get_f64());
181
182 }
183 else if (numberResult.is_integer())
184 {
185
186 numberResult.set(get_i64() - number.get_i64());
187
188 }
189
190 return numberResult;
191
192 }
193
194 ::number::number operator * (const number& number) const
195 {
196
197 ::number::number numberResult;
198
199 numberResult.m_enumber = maximum(m_enumber, number.m_enumber);
200
201 if (numberResult.is_f32())
202 {
203
204 numberResult.set(get_f64() * number.get_f64());
205
206 }
207 else if (numberResult.is_integer())
208 {
209
210 numberResult.set(get_i64() * number.get_i64());
211
212 }
213
214 return numberResult;
215
216 }
217
218
219 ::number::number operator / (const number& number) const
220 {
221
222 ::number::number numberResult;
223
224 numberResult.m_enumber = maximum(m_enumber, number.m_enumber);
225
226 if (numberResult.is_f32())
227 {
228
229 numberResult.set(get_f64() / number.get_f64());
230
231 }
232 else if (numberResult.is_integer())
233 {
234
235 numberResult.set(get_i64() / number.get_i64());
236
237 }
238
239 return numberResult;
240
241 }
242
243
244 bool operator == (const number& number) const
245 {
246
247 auto enumber = maximum(m_enumber, number.m_enumber);
248
249 if (enumber & 64) // ::f32
250 {
251
252 return get_f64() == number.get_f64();
253
254 }
255 else if (enumber & 6) // integer
256 {
257
258 return get_i64() == number.get_i64();
259
260 }
261
262 return false;
263
264 }
265
266 bool operator != (const number& number) const
267 {
268
269 auto enumber = maximum(m_enumber, number.m_enumber);
270
271 if (enumber & 64) // ::f32
272 {
273
274 return get_f64() != number.get_f64();
275
276 }
277 else if (enumber & 6) // integer
278 {
279
280 return get_i64() != number.get_i64();
281
282 }
283
284 return false;
285
286 }
287
288
289 bool operator < (const number& number) const
290 {
291
292 auto enumber = maximum(m_enumber, number.m_enumber);
293
294 if (enumber & 64) // ::f32
295 {
296
297 return get_f64() < number.get_f64();
298
299 }
300 else if (enumber & 6) // integer
301 {
302
303 return get_i64() < number.get_i64();
304
305 }
306
307 return false;
308
309 }
310
311
312 bool operator <= (const number& number) const
313 {
314
315 auto enumber = maximum(m_enumber, number.m_enumber);
316
317 if (enumber & 64) // ::f32
318 {
319
320 return get_f64() <= number.get_f64();
321
322 }
323 else if (enumber & 6) // integer
324 {
325
326 return get_i64() <= number.get_i64();
327
328 }
329
330 return false;
331
332 }
333
334
335 bool operator > (const number& number) const
336 {
337
338 auto enumber = maximum(m_enumber, number.m_enumber);
339
340 if (enumber & 64) // ::f32
341 {
342
343 return get_f64() > number.get_f64();
344
345 }
346 else if (enumber & 6) // integer
347 {
348
349 return get_i64() > number.get_i64();
350
351 }
352
353 return false;
354
355 }
356
357
358
359 bool operator >= (const number& number) const
360 {
361
362 auto enumber = maximum(m_enumber, number.m_enumber);
363
364 if (enumber & 64) // ::f32
365 {
366
367 return get_f64() >= number.get_f64();
368
369 }
370 else if (enumber & 6) // integer
371 {
372
373 return get_i64() >= number.get_i64();
374
375 }
376
377 return false;
378
379 }
380
381 };
382
383} // namespace number
384
385
386
387inline string get_default_real_scalar_format()
388{
389 return "%f";
390}
391
392inline string get_default_integer_scalar_format()
393{
394 return "%lld";
395}
396
397
398//inline string get_default_scalar_format < ::f64 >()
399//{
400// return "%d";
401//}
402//
403//template < >
404//inline string get_default_scalar_format < ::i64 >()
405//{
406// return "%lli";
407//}
408//
409//namespace str
410//{
411//
412// template < typename FORMATABLE >
413// inline string printf(const ::scoped_string & scopedstrFormat, const FORMATABLE & f)
414// {
415//
416// string str;
417//
418// str.formatf(strFormat,f);
419//
420// return str;
421//
422// }
423//
424//
425//} // namespace str
426
427
428
429#include "acme/prototype/prototype/atom.h"
430
431namespace number
432{
433 class CLASS_DECL_ACME scalar_source :
434 virtual public particle
435 {
436 public:
437
438
439 class CLASS_DECL_ACME listener :
440 virtual public particle
441 {
442 public:
443
444
445 virtual bool on_set_scalar(scalar_source * pscalar, enum_scalar escalar, ::number::number n, ::i32 iFlags);
446 // virtual bool on_set_integer_scalar(scalar_source* pscalar, enum_scalar escalar, ::integer i, ::i32 iFlags);
447
448
449 };
450
451
452
453 ::pointer_array < listener > m_scalarlistenera;
454 ::atom m_atomScalarSource;
455
456
457 scalar_source();
458
459
460 bool set_scalar(enum_scalar escalar,::number::number real,bool bForce = false,::i32 iFlags = e_scalar_none);
461 bool constrain_scalar(enum_scalar escalar, ::number::number& real);
462 void increment_scalar(enum_scalar escalar, ::number::number real);
463 ::f64 get_scalar_rate(enum_scalar escalar,::f64 dDefault = 0.0);
464 bool set_scalar_rate(enum_scalar escalar,::f64 dValue,::i32 iFlags);
465 bool contains_scalar(enum_scalar escalar, ::number::number real);
466
467 //bool set_integer_scalar(enum_scalar escalar, ::integer integer, bool bForce = false, ::i32 iFlags = e_scalar_none);
468 //bool constrain_integer_scalar(enum_scalar escalar, ::integer& integer);
469 //void increment_integer_scalar(enum_scalar escalar, ::integer iIncintegerrement);
470 //::f64 get_integer_scalar_rate(enum_scalar escalar, ::f64 dDefault = 0.0);
471 //bool set_integer_scalar_rate(enum_scalar escalar, ::f64 dValue, ::i32 iFlags);
472 //bool contains_integer_scalar(enum_scalar escalar, ::integer integer);
473
474
475 //virtual bool on_set_real_scalar(enum_scalar escalar, ::real real, ::i32 iFlags);
476 //virtual bool get_real_scalar_minimum(enum_scalar escalar, ::real& real);
477 //virtual bool get_real_scalar(enum_scalar escalar, ::real& real);
478 //virtual bool get_real_scalar_maximum(enum_scalar escalar, ::real& real);
479
480
481 virtual bool on_set_scalar(enum_scalar escalar, ::number::number integer, ::i32 iFlags);
482 virtual ::number::number get_scalar_minimum(enum_scalar escalar);
483 virtual ::number::number get_scalar(enum_scalar escalar);
484 virtual ::number::number get_scalar_maximum(enum_scalar escalar);
485
486
487
488 };
489
490
491
492
493
494 class CLASS_DECL_ACME scalar :
495 virtual public ::particle
496 {
497 public:
498
499
500
501 ::pointer < scalar_source > m_psource;
502 //string m_strFormat;
503 enum_scalar m_escalar;
504 //enum_number m_enumber;
505
506 scalar(scalar_source* psource = nullptr, enum_scalar ereal_scalar = e_scalar_none);
507
508 virtual ::f64 get_rate(::f64 dDefault = 0.0);
509
510 virtual bool set_rate(::f64 dRate, ::i32 iFlags);
511
512 //string Format(const ::scoped_string & scopedstrFormat);
513
514 //string to_string() { return Format(m_strFormat); }
515 bool is_null() const { return m_psource == nullptr || m_escalar == e_scalar_none; }
516 bool is_set() const { return !is_null(); }
517
518 void set(::number::number dValue);
519 ::number::number get() const;
520
521
522 scalar& operator = (::number::number dValue) { set(dValue); return *this; }
523 scalar & operator = (const ::number::scalar & scalar) { set(scalar.get()); return *this; }
524
525 number maximum();
526 number minimum();
527
528 //virtual string printf(const ::scoped_string & scopedstrFormat);
529
530 void increment(number number = 1) { set(get() + number); }
531 void decrement(number number = 1) { set(get() - number); }
532
533 scalar& operator ++(::i32) { increment(); return *this; }
534 scalar& operator --(::i32) { decrement(); return *this; }
535
536 };
537} // namespace number
538
539
540//class CLASS_DECL_ACME real_scalar :
541// virtual public scalar_base
542//{
543//public:
544//
545//
546// real_scalar(scalar_source * psource = nullptr,enum_scalar ereal_scalar = e_scalar_none,const ::scoped_string & scopedstrFormat = ::get_default_real_scalar_format());
547//
548//
549// void set(::real dValue);
550// ::real get();
551//
552//
553// ::f64 get_rate(::f64 dDefault = 0.0) override;
554// bool set_rate(::f64 dRate,::i32 iFlags) override;
555//
556//
557// ::real maximum();
558// ::real minimum();
559// operator ::real () { return get(); }
560//
561// real_scalar & operator = (::real dValue) { set(dValue); return *this; }
562//
563// virtual string printf(const ::scoped_string & scopedstrFormat);
564//
565// void increment(::real iValue = ::numeric_info<::real>::unitary()) { set(get() + iValue); }
566// void decrement(::real iValue = ::numeric_info<::real>::unitary()) { set(get() - iValue); }
567//
568// real_scalar & operator ++(::i32) { increment(); return *this; }
569// real_scalar & operator --(::i32) { decrement(); return *this; }
570//
571//
572//};
573//class CLASS_DECL_ACME integer_scalar :
574// virtual public scalar_base
575//{
576//public:
577//
578//
579// integer_scalar(scalar_source* psource = nullptr, enum_scalar einteger_scalar = e_scalar_none, const ::scoped_string & scopedstrFormat = ::get_default_integer_scalar_format());
580//
581//
582// void set(::integer dValue);
583// ::integer get();
584//
585// ::f64 get_rate(::f64 dDefault = 0.0) override;
586// bool set_rate(::f64 dRate, ::i32 iFlags) override;
587//
588//
589// ::integer maximum();
590// ::integer minimum();
591//
592//
593//
594// operator ::integer () { return get(); }
595//
596// integer_scalar& operator = (::integer dValue) { set(dValue); return *this; }
597//
598// virtual string printf(const ::scoped_string & scopedstrFormat);
599//
600// void increment(::integer iValue = ::numeric_info<::integer>::unitary()) { set(get() + iValue); }
601// void decrement(::integer iValue = ::numeric_info<::integer>::unitary()) { set(get() - iValue); }
602//
603// integer_scalar& operator ++(::i32) { increment(); return *this; }
604// integer_scalar& operator --(::i32) { decrement(); return *this; }
605//
606//
607//};
608//
609//
610//
613//
616//
617//
620//
621//
622//
number::atom
Definition scalar.cpp:237
number::number::number
Definition scalar.cpp:15
number::scalar_source::listener
Definition scalar.h:441
number::scalar_source
Definition scalar.h:435