acme
Foundational cross-platform layer of the ca2 framework
Loading...
Searching...
No Matches
payload.h
1#pragma once
2
3
4#include "type.h"
5#include "acme/prototype/datetime/earth_time.h"
6#include "acme/prototype/datetime/file_time.h"
7#include "acme/prototype/time/time/posix_time.h"
8#include "acme/graphics/draw2d/color.h"
9#include "pointer.h"
10#include "acme/memory/memory.h"
11#include "acme/memory/raw_block.h"
12#include "acme/platform/procedure.h"
13#include "acme/prototype/collection/numeric_array.h"
14#include "acme/filesystem/filesystem/path_object.h"
15#include "acme/filesystem/filesystem/path_array.h"
16//#include "acme/prototype/datetime/file_time.h"
17#include "acme/prototype/string/sz.h"
18#include "acme/prototype/prototype/make_particle.h"
19#include "acme/prototype/string/character_range.h"
20
21inline payload & copy(payload & payload, const class time & time);
22
23
24enum para_return
25{
26 e_fail = I32_MINIMUM,
27 s_success = 0
28};
29
30//class future;
31//class function_arg;
32
33bool is_return_ok(para_return eret);
34
35template < typename ENUM >
36ENUM enum_default()
37{
38
39 return (ENUM)0;
40
41}
42
43struct payload_all_t
44{
45
46 //::u8 m_ua[32]; // it would work at 4-byte alignment?
47 ::u8 m_ua[40];
48
49};
50
51
52class CLASS_DECL_ACME payload :
53 public memory_quantum
54{
55public:
56
57
58 using PRIMITIVE_PAYLOAD_TAG = PRIMITIVE_PAYLOAD_TAG_TYPE;
59 payload * refdbg_this() const { return (payload*)this; }
60
61 enum_type m_etype;
62
63
64 union
65 {
66
67 void * m_pvoid;
68 para_return m_parareturn;
69 atom m_atomPayload;
70 //type m_type;
71 bool m_b;
72 bool * m_pb;
73 ::i8 m_i8;
74 ::u8 m_u8;
75 ::i16 m_i16;
76 ::u16 m_u16;
77 ::i32 m_i32;
78#if defined(__APPLE__) || defined(__ANDROID__) || defined(RASPBERRYPIOS)
79 //long m_l;
80 //ulong m_ul;
81#endif
82 ::u32 m_u32;
83 ::i64 m_i64;
84 ::u64 m_u64;
85 ::i8 * m_pi8;
86 ::u8 * m_pu8;
87 ::i16 * m_pi16;
88 ::u16 * m_pu16;
89 ::i32 * m_pi32;
90 ::u32 * m_pu32;
91 ::i64 * m_pi64;
92 ::u64 * m_pu64;
93 ::string * m_pstr;
94 ::f32 m_f32;
95 ::f32 * m_pf32;
96 ::f64 m_f64;
97 ::f64 * m_pf64;
98 //payload * m_ppayload;
99 ::earth::time m_earthtime;
100 file_time m_filetime;
101 atom * m_patom;
102 //::property * m_pproperty;
103 //integral_nanosecond m_integralnanosecond;
104 //integral_nanosecond * m_pintegralnanosecond;
105 //integral_microsecond m_integralmicrosecond;
106 //integral_microsecond * m_pintegralmicrosecond;
107 //integral_millisecond m_integralmillisecond;
108 //integral_millisecond * m_pintegralmillisecond;
109 //integral_second m_integralsecond;
110 //integral_second * m_pintegralsecond;
111 //integral_minute m_integralminute;
112 //integral_minute * m_pintegralminute;
113 //integral_hour m_integralhour;
114 //integral_hour * m_pintegralhour;
115 //integral_day m_integralday;
116 //integral_day * m_pintegralday;
117 //floating_nanosecond m_floatingnanosecond;
118 //floating_nanosecond * m_pfloatingnanosecond;
119 //floating_microsecond m_floatingmicrosecond;
120 //floating_microsecond * m_pfloatingmicrosecond;
121 //floating_millisecond m_floatingmillisecond;
122 //floating_millisecond * m_pfloatingmillisecond;
123 //floating_second m_floatingsecond;
124 //floating_second * m_pfloatingsecond;
125 //floating_minute m_floatingminute;
126 //floating_minute * m_pfloatingminute;
127 //floating_hour m_floatinghour;
128 //floating_hour * m_pfloatinghour;
129 //floating_day m_floatingday;
130 //floating_day * m_pfloatingday;
131 class time m_time;
132 class time * m_ptime;
133 //::e_status m_estatus;
134 //::e_command m_ecommand;
135 //::e_check m_echeck;
136 //::e_flag m_eflag;
137 ::color::color m_color;
138 ::color::hls m_hls;
139
140
141 ::subparticle * m_p;
142 ::string_array * m_pstra;
143 ::i32_array * m_pia;
144 ::payload_array * m_ppayloada;
145 ::property_set * m_ppropertyset;
146 ::i64_array * m_plonglonga;
147 ::f32_array * m_pf32a;
148 ::f64_array * m_pf64a;
149 ::memory * m_pmemory;
150 ::file::path_object * m_ppath;
151 payload_all_t m_payloadall;
152 ::string m_str;
153 ::range < const ::ansi_character * > m_ansirange;
154 ::function_common_base * m_pfunctioncommonbase;
155
156 };
157
158
159#if REFERENCING_DEBUGGING
160
161
162 ::reference_referer * m_preferer;
163
164
165#endif
166
167
168 payload();
169 payload(no_initialize_t) {}
170 payload(enum_type etype);
171 payload(nullptr_t);
172 payload(const ::payload & payload);
173 //template < typename ITERATOR_TYPE, ::i32 t_size >
174 //payload(const const_string_range_static_array < ITERATOR_TYPE, t_size >& a) :
175 // payload(::string(a))
176 //{ }
177 payload(::payload && payload) :
178 m_etype(payload.m_etype)
179 {
180 m_payloadall = payload.m_payloadall;
181#if REFERENCING_DEBUGGING
182 m_preferer = payload.m_preferer;
183 payload.m_preferer = nullptr;
184#endif
185 payload.m_etype = e_type_new;
186 payload.m_payloadall = {};
187 }
188 template < bool_type BOOL > payload(BOOL b) : m_etype(e_type_bool) {m_b = b;}
189 template < same_as < ::i8 > CHAR > payload(CHAR c) : m_etype(e_type_i8) {m_i8 = c;}
190 //template < i8_type I8 > payload(I8 i) : m_etype(e_type_i8) {m_i8 = i;}
191 template < same_as < ::u8 > UNSIGNED_CHAR > payload(UNSIGNED_CHAR uch) : m_etype(e_type_u8) {m_u8 = uch;}
192 template < same_as < ::i16 > SHORT > payload(SHORT sh) : m_etype(e_type_i16) {m_i16 = sh;}
193 template < same_as < ::u16 > UNSIGNED_SHORT > payload(UNSIGNED_SHORT ush) : m_etype(e_type_u16) {m_u16 = ush;}
194 template < same_as < ::i32 > INT > payload(INT i) : m_etype(e_type_i32) {m_i32 = i;}
195 template < same_as < ::u32 > UNSIGNED_INT > payload(UNSIGNED_INT ui) : m_etype(e_type_u32) {m_u32 = ui;}
196 template < same_as < ::i64 > LONG_LONG > payload(LONG_LONG ll) : m_etype(e_type_i64) {m_i64 = ll;}
197 template < same_as < ::u64 > UNSIGNED_LONG_LONG > payload(UNSIGNED_LONG_LONG ull) : m_etype(e_type_u64) {m_u64 = ull;}
198 template < same_as < ::f32 > FLOAT > payload(FLOAT f) : m_etype(e_type_f32) {m_f32 = f;}
199 template < same_as < ::f64 > DOUBLE > payload(DOUBLE d) : m_etype(e_type_f64) {m_f64 = d;}
200#ifdef __APPLE__
201#ifdef OS64BIT
202 payload(long l);
203#endif
204#endif
205 payload(::i32 * pi);
206 payload(::u32 * pu);
207 payload(::i64 * pi);
208 payload(::u64 * pu);
209 payload(::f32 * pf);
210 payload(::f64 * pd);
211 payload(bool * pb);
212 payload(::string * pstr);
213 //payload(::payload * ppayload);
214 //payload(::property * pproperty);
215 payload(::subparticle * pparticle);
216 payload(class ::time * ptime);
217 template < prototype_character_range CHARACTER_RANGE >
218 payload(const CHARACTER_RANGE & range);
219 //template < ::collection::count count >
220 //payload(const ::ansi_character(&sz)[count]) : payload((const_char_pointer )sz, count) {}
221 template < prototype_integral INTEGRAL >
222 payload(const_char_pointer begin, INTEGRAL count) : payload(begin, begin + count) {}
223 payload(const_char_pointer begin, const_char_pointer end);
224 payload(const_char_pointer psz);
225 payload(const ::scoped_string & scopedstr);
226 //payload(const ::platform::type & type);
227 payload(const ::atom & atom);
228 payload(const ::earth::time & time);
229 payload(const ::color::color & color);
230 payload(const ::color::hls & hls);
231 payload(const ::subparticle & particle);
232 payload(const ::file::path & path);
233 payload(const ::string_array_base & stra);
234 payload(const ::i32_array_base & ia);
235 payload(const ::i64_array_base & lla);
236 payload(const ::f32_array_base & f32a);
237 payload(const ::f64_array_base & f64a);
238 payload(const ::payload_array & payloada);
239 payload(const ::property_set & set);
240 //payload(const ::property & property);
241 payload(const class time & time);
242
243 // payload(const ::block & block)
244 // {
245 // m_etype = e_type_new;
246 // operator = (block);
247 // }
248
249 template < class T >
250 payload(const ::pointer < T > & p)
251 {
252
253 m_etype = e_type_new;
254
255 _set_element(p.m_psubparticle);
256
257 }
258
259 //template < class T >
260 //payload(const pointer < T > & p)
261 //{
262 // m_etype = e_type_new;
263 // //operator = (p.m_p);
264 // _set_element((T *)p.m_p);
265 //}
266
267 //template < class T >
268 //payload(const pointer < T >& resultpointer)
269 //{
270 // m_etype = e_type_new;
271
272 // operator = (resultpointer);
273
274 //}
275
276
277 template < typename BLOCK_TYPE >
278 payload(const ::raw_block < BLOCK_TYPE > & rawblock) ;
279
280
281 payload(const ::inline_number_string& a);
282
283
284 // template < prototype_character CHARACTER2, character_count sizeMaximumLength >
285 // payload(const ::inline_string < CHARACTER2, sizeMaximumLength > & inlinestring) :
286 // payload(::string(inlinestring))
287 // {
288 // }
289
290 //template < typename ENUM >
291 //payload(const ::enumeration < ENUM > & eflag)
292 //{
293 // m_etype = e_type_new;
294 // operator = (eflag);
295 //}
296
297 //template < a_enum ENUM >
298 //payload(const ENUM & eenum)
299 //{
300 // m_etype = e_type_new;
301 // operator = (eenum);
302 //}
303
304 // template < typename T >
305 // payload(const T & t)
306 // {
307 // m_etype = e_type_new;
308 // operator = (t);
309 // }
310
311 template < prototype_enum ENUM >
312 payload(ENUM e) :
313 m_etype(e_type_atom),
314 m_atomPayload(e)
315 {
316
317 }
318
319 ~payload();
320
321
322 void clear_data() { m_etype = e_type_null; }
323
324
325 void set_type(enum_type enum_type, bool bConvert = true);
326 enum_type get_type() const;
327 atom::enum_type atom_type() const;
328
329
330 //void set_type(const ::platform::type & type);
331
332
333 template < typename T >
334 void set_pointer(const ::pointer < T > & p)
335 {
336
337 operator[](::platform::type(p)) = p;
338
339 }
340
341 template < typename T >
342 bool has_pointer() const
343 {
344
345 return has_property(::platform::type(::type<T>()));
346
347 }
348
349 template < typename T >
350 ::property * find_pointer() const
351 {
352
353 return _find_property(::platform::type(::type<T>()));
354
355 }
356
357 template < typename TYPE >
358 ::pointer < TYPE > pointer() const;
359
360 //bool get_type(::platform::type & type) const;
361
362 ::i64 payload_release();
363
364 ::i64 logical_release();
365
366 void _set_element(::subparticle * pelement);
367
368 bool is_element() const { return m_etype >= e_type_element && m_etype < e_type_last_element; }
369
370 bool is_element_set() const { return is_element() && ::is_set(m_p); }
371
372 bool is_element_null() const { return is_element() && ::is_null(m_p); }
373
374 bool is_numeric() const;
375
376
377 bool has_reference_of_type(enum_type etype) const;
378
379
380 inline bool is_number() const
381 {
382
383 return is_numeric();
384
385 }
386
387 bool target_constrained_assign(const ::payload & payload);
388
389
390 bool get_bool() const;
391
392 template < typename ENUM >
393 ENUM e(ENUM edefault = enum_default < ENUM >()) const { return (ENUM)(::i64)(edefault); }
394
395//#define DECL_VAR_FLAG(ENUMTYPE) \
396//inline payload(::enum_ ## ENUMTYPE e ## ENUMTYPE) { m_etype = ::e_type_enum_ ## ENUMTYPE; m_e ## ENUMTYPE = e ## ENUMTYPE; } \
397//inline ::enum_ ## ENUMTYPE e ## ENUMTYPE(::enum_ ## ENUMTYPE e ## ENUMTYPE ## Default = enum_default < ::enum_ ## ENUMTYPE >()) const { return e < ::enum_ ## ENUMTYPE >(e ## ENUMTYPE ## Default); } \
398//::enum_ ## ENUMTYPE & as_e ## ENUMTYPE (); \
399//inline payload & operator = (::enum_ ## ENUMTYPE e ## ENUMTYPE) { release(); if(m_etype != ::e_type_enum_ ## ENUMTYPE) m_etype = ::e_type_enum_ ## ENUMTYPE; m_e ## ENUMTYPE = e ## ENUMTYPE; return *this; } \
400//inline bool operator == (::enum_ ## ENUMTYPE e ## ENUMTYPE) const { return m_etype == ::e_type_enum_ ## ENUMTYPE && m_e ## ENUMTYPE == e ## ENUMTYPE; }
401//#undef DECL_VAR_FLAG
402//
403
404
405//#define DECL_VAR_ENUM(ENUMTYPE) \
406// inline explicit payload(const ::e_ ## ENUMTYPE & e) { m_etype = ::e_type_enum_ ## ENUMTYPE; m_e ## ENUMTYPE = e; } \
407// inline explicit payload(::enum_ ## ENUMTYPE e) { m_etype = ::e_type_enum_ ## ENUMTYPE; m_e ## ENUMTYPE = e; } \
408// inline ::e_ ## ENUMTYPE e ## ENUMTYPE(::enum_ ## ENUMTYPE eDefault = enum_default < ::enum_ ## ENUMTYPE >()) const { return e < ::enum_ ## ENUMTYPE >(eDefault); } \
409// inline operator ::e_ ## ENUMTYPE () const { return ::e_ ## ENUMTYPE(); } \
410// ::e_ ## ENUMTYPE & e_ ## ENUMTYPE ## _reference(); \
411// inline payload & operator = (const ::e_ ## ENUMTYPE & e) &{ set_type(::e_type_enum_ ## ENUMTYPE, false); m_e ## ENUMTYPE = e; return *this; } \
412// inline payload & operator = (::enum_ ## ENUMTYPE e) { set_type(::e_type_enum_ ## ENUMTYPE, false); m_e ## ENUMTYPE = e; return *this; } \
413// inline bool equals_enum (::e_ ## ENUMTYPE e) const { return m_etype == ::e_type_enum_ ## ENUMTYPE && m_e ## ENUMTYPE == e; }
414// DECL_VAR_ENUM(status);
415// DECL_VAR_ENUM(command);
416// DECL_VAR_ENUM(check);
417//#undef DECL_VAR_ENUM
418
419
420#define IMPLEMENT_PAYLOAD_ENUMERATION(ENUMTYPE) \
421 inline payload(const ::e_ ## ENUMTYPE & e) : m_etype(e_type_atom),m_atomPayload(e) { } \
422 inline ::e_ ## ENUMTYPE as_e ## ENUMTYPE() const { return as_atom().as_e ## ENUMTYPE(); } \
423 inline ::e_ ## ENUMTYPE & e ## ENUMTYPE ## _reference() { return atom_reference().e ## ENUMTYPE ## _reference(); }
424 IMPLEMENT_PAYLOAD_ENUMERATION(status);
425 IMPLEMENT_PAYLOAD_ENUMERATION(command);
426 IMPLEMENT_PAYLOAD_ENUMERATION(check);
427#undef IMPLEMENT_PAYLOAD_ENUMERATION
428
429
430 template < prototype_enum ENUM >
431 bool operator ==(ENUM e) const
432 {
433
434 if (m_etype == e_type_atom)
435 {
436
437 return m_atomPayload == e;
438
439 }
440 else if (m_etype == e_type_patom)
441 {
442
443 return *m_patom == e;
444
445 }
446
447 return operator == (::as_i64(e));
448
449 }
450
451
452 //inline ::second & as_secs() { if (get_type() != e_type_secs)set_type(e_type_secs); return m_secs; }
453 //inline class ::time & as_millis() { if (get_type() != e_type_millis)set_type(e_type_millis); return m_millis; }
454 //inline ::microsecond & as_micros() { if (get_type() != e_type_micros)set_type(e_type_micros); return m_micros; }
455 //inline ::nanosecond & as_nanos() { if (get_type() != e_type_nanos)set_type(e_type_nanos); return m_nanos; }
456
457 void as(::string & str) const;
458 void as(::memory_base & memory) const;
459
460
461#if defined(__APPLE__) || defined(__ANDROID__) || defined(RASPBERRYPIOS) || defined(WINDOWS)
462 long get_long(long lDefault = 0) const;
463 ulong get_unsigned_long(ulong ulDefault = 0) const;
464#endif
465
466 ::i8 & as(::i8 & i) const { return i = as_i8(); }
467 ::u8 & as(::u8 & u) const { return u = as_u8(); }
468 ::i16 & as(::i16 & i) const { return i = as_i16(); }
469 ::u16 & as(::u16 & u) const { return u = as_u16(); }
470 ::i32 & as(::i32 & i) const { return i = as_i32(); }
471 ::u32 & as(::u32 & u) const { return u = as_u32(); }
472 ::i64 & as(::i64 & i) const { return i = as_i64(); }
473 ::u64 & as(::u64 & u) const { return u = as_u64(); }
474 ::f32 & as(::f32 & f) const { return f = as_f32(); }
475 ::f64 & as(::f64 & f) const { return f = as_f64(); }
476
477
478 ::i8 as_i8(::i8 iDefault = 0) const;
479 ::u8 as_u8(::u8 uDefault = 0) const;
480 ::i16 as_i16(::i16 iDefault = 0) const;
481 ::u16 as_u16(::u16 uDefault = 0) const;
482 ::i32 as_i32(::i32 iDefault = 0) const;
483 ::u32 as_u32(::u32 uiDefault = 0) const;
484 ::i64 as_i64(::i64 iDefault = 0) const;
485 ::u64 as_u64(::u64 uiDefault = 0) const;
486 ::f32 as_f32(::f32 fDefault = 0) const;
487 ::f64 as_f64(::f64 fDefault = 0) const;
488
489
490 inline ::iptr as_iptr(::iptr iDefault = 0) const;
491 inline ::uptr as_uptr(::uptr uiDefault = 0) const;
492
493 ::file::path as_file_path() const;
494 ::url::url as_url() const;
495 ::file_time as_file_time() const;
496 ::earth::time as_earth_time() const;
497 ::color::color as_color(const ::color::color & colorDefault = ::color::color()) const;
498 ::color::hls as_hls(const ::color::hls & hlsDefault = ::color::hls()) const;
499 ::block as_block() const;
500
501
502 ::procedure get_procedure() const;
503
504
505 ::posix_time as_posix_time(::i64 iDefault = 0) const
506 {
507
508 return { posix_time_t{}, this->as_i64() };
509
510 }
511
512
513 ::posix_time as_time(const class ::time & timeDefault) const;
514
515 ::string as_string(const ::scoped_string & scopedstrOnNull) const;
516 ::string as_string() const;
517 ::string get_recursive_string() const;
518 ::atom as_atom() const;
519 ::atom as_atom(const ::atom & idDefault) const;
520
521 ::memory as_memory() const;
522 ::string_array_base as_string_array() const;
523 ::i32_array_base as_int_array() const;
524 ::i64_array_base as_i64_array() const;
525 ::f32_array_base as_f32_array() const;
526 ::f64_array_base as_f64_array() const;
527 ::payload_array_base as_payload_array() const;
528 ::property_set as_property_set() const;
529 class ::time as_time() const;
530 //::property as_property() const;
531
532
533 bool is_scalar() const;
534 bool is_array() const;
535 bool is_floating() const;
536 bool is_integer() const;
537 bool is_natural() const;
538 bool is_boolean() const;
539 bool is_f64() const;
540 bool is_time() const;
541 bool is_text() const;
542 bool is_fairly_convertible_to_text() const;
543 bool has_string_reference() const;
544
545 bool ok() const;
546 bool failed() const;
547
548
549 enum_type integer_type() const;
550 enum_type left_hand_integer_type() const;
551
552 enum_type floating_type() const;
553 enum_type left_hand_floating_type() const;
554
555
556 payload dereference();
557
558
559
560
561
562 //::comparison::var_strict strictly_compare() const;
563
564 //void set_string(const ::const_ansi_range & ansirange);
565 void set_string(const ::scoped_string & scopedstr);
566 //void set_string(::string && str);
567 void set_id(const ::atom & atom);
568 void unset();
569 void unset(const ::scoped_string & scopedstrPropertySetKey);
570
571 bool is_set() const;
572 bool is_new() const;
573 bool is_null() const;
574 bool is_new_or_null() const;
575 bool is_empty() const;
576 bool has_character() const;
577
578 bool is_false() const;
579 bool is_bool_false() const;
580 bool is_set_false() const;
581 bool is_true() const;
582 bool is_true_or_empty() const;
583
584 //bool is_property_true(const ::atom & atom, bool bDefault = false) const;
585
586 bool casts_to(::enum_type etype) const;
587
588
590 bool has_property(const ::atom & atom) const;
591 bool is_property_true_or_empty(const ::atom & atom) const;
592 bool is_property_true(const ::atom & atom) const;
593 bool is_property_false(const ::atom & atom) const;
594
595
596 bool begins(const ::scoped_string & scopedstrPrefix) const;
597 bool ends(const ::scoped_string & scopedstrSuffix) const;
598 bool case_insensitive_begins(const ::scoped_string & scopedstrPrefix) const;
599 bool case_insensitive_ends(const ::scoped_string & scopedstrSuffix) const;
600
601 bool begins_eat(const ::scoped_string & scopedstrPrefix);
602 bool ends_eat(const ::scoped_string & scopedstrSuffix);
603 bool case_insensitive_begins_eat(const ::scoped_string & scopedstrPrefix);
604 bool case_insensitive_ends_eat(const ::scoped_string & scopedstrSuffix);
605
606 payload get_topic(const ::atom & atom) const;
607 //payload defer_get(const ::atom & atom) const;
608
609 payload & operator ++(::i32);
610
611 //payload operator +(const ::payload & payload) const;
612 payload operator -(const ::payload & payload) const;
613 payload operator *(const ::payload & payload) const;
614 payload operator /(const ::payload & payload) const;
615
616 //payload & operator +=(const ::payload & payload);
617 payload & operator -=(const ::payload & payload);
618 payload & operator *=(const ::payload & payload);
619 payload & operator /=(const ::payload & payload);
620
621
622 payload addition(const ::payload & payload) const;
623 payload subtraction(const ::payload & payload) const;
624 payload multiplication(const ::payload & payload) const;
625 payload division(const ::payload & payload) const;
626
627 payload & add(const ::payload & payload);
628 payload & subtract(const ::payload & payload);
629 payload & multiply(const ::payload & payload);
630 payload & divide(const ::payload & payload);
631
632 bool operator !() const
633 {
634
635 return !as_bool();
636
637 }
638
639
640 bool as_bool() const;
641
642 operator bool() const { return this->as_bool(); }
643
644 operator ::i8() const { return this->as_i8(); }
645 operator ::u8() const { return this->as_u8(); }
646 operator ::i16() const { return this->as_i16(); }
647 operator ::u16() const { return this->as_u16(); }
648 operator ::i32() const { return this->as_i32(); }
649 operator ::u32() const { return this->as_u32(); }
650 operator ::i64()const { return this->as_i64(); }
651 operator ::u64() const { return this->as_u64(); }
652
653
654
655 operator ::f32() const { return this->as_f32(); }
656 operator ::f64() const { return this->as_f64(); }
657 //operator ::string() const;
658 //::memory memory() const;
659 //operator ::file::path() const { return this->as_file_path(); }
660
661
662 //operator ::string() const { return this->as_string(); }
663 //operator ::file::path() const { return this->file_path(); }
664
665 operator ::file_time() const { return this->as_file_time(); }
666 operator ::earth::time() const { return this->as_earth_time(); }
667 operator ::color::color() const { return this->as_color(); }
668 operator ::color::hls() const { return this->as_hls(); }
669 operator ::block() const { return this->as_block(); }
670
671 ::string & string_reference();
672
673 ::memory & memory_reference();
674
675
676 ::atom & atom_reference();
677
678
679 ::string_array & string_array_reference();
680 ::i32_array & i32_array_reference();
681 ::i64_array & i64_array_reference();
682 ::f32_array & f32_array_reference();
683 ::f64_array & f64_array_reference();
684 ::payload_array & payload_array_reference();
685 class ::time & time_reference();
686 ::property_set & property_set_reference();
687 //::property & property_reference();
688
689 ::file::path & file_path_reference();
690
691 ::file_time & file_time_reference();
692 ::earth::time & earth_time_reference();
693 ::color::color & color_reference();
694 ::color::hls & color_hls_reference();
695
696 const ::string_array & string_array_reference() const;
697 const ::i32_array & i32_array_reference() const;
698 const ::i64_array & i64_array_reference() const;
699 const ::f32_array & f32_array_reference() const;
700 const ::f64_array & f64_array_reference() const;
701 const ::payload_array & payload_array_reference() const;
702 const class time & time_reference() const;
703 const ::property_set & property_set_reference() const;
704 const ::property & property_reference() const;
705
706
707
708
709 const ::file::path & file_path_reference() const;
710 const ::file_time & file_time_reference() const;
711 const ::earth::time & earth_time_reference() const;
712 const ::color::color & color_reference() const;
713 const ::color::hls & color_hls_reference() const;
714
715
716 //operator ::enum_check &();
717
718
719 bool & bool_reference();
720#if defined(__APPLE__) || defined(__ANDROID__) || defined(RASPBERRYPIOS) || defined(WINDOWS)
721 long & long_reference();
722 ulong & unsigned_long_reference();
723#endif
724 ::i8 & i8_reference();
725 ::u8 & u8_reference();
726 ::i16 & i16_reference();
727 ::u16 & u16_reference();
728 ::i32 & i32_reference();
729 ::u32 & u32_reference();
730 ::i64 & i64_reference();
731 ::u64 & u64_reference();
732 ::f32 & f32_reference();
733 ::f64 & f64_reference();
734
735
736 template < prototype_signed SIGNED >
737 inline SIGNED & reference()
738 {
739
740 if constexpr(sizeof(SIGNED) == 8)
741 {
742
743 return (SIGNED&) this->i64_reference();
744
745 }
746 else if constexpr(sizeof(SIGNED) == 4)
747 {
748
749 return (SIGNED&) this->i32_reference();
750
751 }
752 else if constexpr(sizeof(SIGNED) == 2)
753 {
754
755 return (SIGNED&) this->i16_reference();
756
757 }
758 else if constexpr(sizeof(SIGNED) == 1)
759 {
760
761 return (SIGNED&) this->i8_reference();
762
763 }
764 else
765 {
766
767 throw "todo";
768
769 }
770
771
772 }
773
774
775 template < prototype_unsigned UNSIGNED >
776 inline UNSIGNED & reference()
777 {
778
779 if constexpr(sizeof(UNSIGNED) == 8)
780 {
781
782 return (UNSIGNED&) this->u64_reference();
783
784 }
785 else if constexpr(sizeof(UNSIGNED) == 4)
786 {
787
788 return (UNSIGNED&) this->u32_reference();
789
790 }
791 else if constexpr(sizeof(UNSIGNED) == 2)
792 {
793
794 return (UNSIGNED&) this->u16_reference();
795
796 }
797 else if constexpr(sizeof(UNSIGNED) == 1)
798 {
799
800 return (UNSIGNED&) this->u8_reference();
801
802 }
803 else
804 {
805
806 throw "todo";
807
808 }
809
810
811 }
812
813
814 template < prototype_const CONST_TYPE >
815 CONST_TYPE & reference() const
816 {
817
818 return (CONST_TYPE &) ((::payload*)this)->reference<non_const<CONST_TYPE>>();
819
820 }
821
822
823 template < prototype_non_const NON_CONST_TYPE >
824 NON_CONST_TYPE * raw_pointer()
825 {
826
827 return &reference<NON_CONST_TYPE>();
828
829 }
830
831
832 template < prototype_const CONST_TYPE >
833 CONST_TYPE * raw_pointer() const
834 {
835
836 return &reference<CONST_TYPE>();
837
838 }
839
840
841 character_count length() const;
842
843
844 template < typename TYPE >
845 inline payload & operator = (const ::pointer<TYPE> & pointer)
846 {
847
848 _set_element(pointer.m_psubparticle);
849
850 return *this;
851
852 }
853
854
855 template < prototype_function FUNCTION >
856 inline payload & operator = (const FUNCTION & function)
857 {
858
859 _set_element(function.m_p);
860
861 return *this;
862
863 }
864
865
866 inline payload & operator = (nullptr_t){ set_type(e_type_null, false); return *this; }
867
868 inline payload & operator = (::subparticle * pelement)
869 {
870
871 _set_element(pelement);
872
873 return *this;
874
875 }
876
877
878
879 payload & operator = (::memory * pmemory);
880
881 template < typename PREDICATE >
882 void predicate_each(PREDICATE predicate)
883 {
884
885 auto c = array_get_count();
886
887 for (auto i = 0; i < c; i++)
888 {
889
890 predicate(at(i));
891
892 }
893
894 }
895
896
897 void payload_increment_reference_count();
898
899 ::i32 & _as(::i32 & i) const
900 {
901
902 i = as_i32();
903
904 return i;
905
906 }
907
908 ::string & _as(::string & str) const
909 {
910
911 str = as_string();
912
913 return str;
914
915 }
916
917 payload & operator = (const ::subparticle & o);
918
919 payload & operator = (const ::file::path & path);
920
921 //template < typename ENUM >
922 //payload& operator = (const enumeration < ENUM > & eflag)
923 //{
924 // return operator =(eflag.m_eenum);
925 //}
926
927 //template < a_enum ENUM >
928 //payload & operator = (const ENUM & eenum)
929 //{
930 // return operator =((::i64) eenum);
931 //}
932
933 payload & operator |= (const ::file::e_flag & eflag);
934
935 //payload& operator = (const ::e_status & estatus)
936 //{
937 // return operator =(estatus.m_estatus);
938 //}
939
940 //payload & operator = (const payload & eret);
941
942 payload & operator = (para_return & eret);
943#ifdef WINDOWS
944#elif defined(__APPLE__) || defined(__ANDROID__) || defined(RASPBERRYPIOS)
945 payload & operator = (long l);
946#endif
947
948
949 payload & assign_bool (bool b) { return __assign_primitive( m_b , e_type_bool , b ); }
950
951#define NUMBER_TYPE_OPERATION(NUMBER_TYPE, NUMBER_NAME, NUMBER_SHORT_NAME, UPPER_CASE_NAME) \
952payload & assign_## NUMBER_NAME (NUMBER_TYPE NUMBER_SHORT_NAME) { return __assign_primitive(m_## NUMBER_SHORT_NAME , e_type_## NUMBER_NAME, NUMBER_SHORT_NAME ); }
953 DO_FOR_NUMBER_TYPES(NUMBER_TYPE_OPERATION)
954#undef NUMBER_TYPE_OPERATION
955 //payload & assign_char (::i8 ch) { return __assign_primitive( m_i8 , e_type_i8 , i ); }
956 //payload & assign_unsigned_char (::u8 uch) { return __assign_primitive(m_u8 , e_type_u8 , u ); }
957 //payload & assign_short (::i16 sh) { return __assign_primitive( m_i16 , e_type_i16 , i ); }
958 //payload & assign_unsigned_short (::u16 ush) { return __assign_primitive(m_u16 , e_type_u16 , u ); }
959 //payload & assign_int (::i32 i) { return __assign_primitive( m_i32 , e_type_i32 , i ); }
960 //payload & assign_u32 (::u32 u) { return __assign_primitive( m_u32 , e_type_u32 , u ); }
961 //payload & assign_i64 (::i64 ll) { return __assign_primitive( m_i64 , e_type_i64 , i ); }
962 //payload & assign_u64 (::u64 ull) { return __assign_primitive( m_u64 , e_type_u64 , u ); }
963 //payload & assign_f32 (::f32 f) { return __assign_primitive( m_f32 , e_type_f32 , f ); }
964 //payload & assign_f64 (::f64 d) { return __assign_primitive( m_f64 , e_type_f64 , f ); }
965
966
967 payload & assign_pbool (bool * pb) { return __assign_primitive_pointer(m_pb , e_type_pbool , pb); }
968 payload & assign_pi8 (::i8 * pi) { return __assign_primitive_pointer(m_pi8 , e_type_pi8 , pi); }
969 payload & assign_pu8 (::u8 * pu) { return __assign_primitive_pointer(m_pu8 , e_type_pu8 , pu); }
970 payload & assign_pi16 (::i16 * pi) { return __assign_primitive_pointer(m_pi16 , e_type_pi16 , pi); }
971 payload & assign_pu16 (::u16 * pu) { return __assign_primitive_pointer(m_pu16 , e_type_pu16 , pu); }
972 payload & assign_pi32 (::i32 * pi) { return __assign_primitive_pointer(m_pi32 , e_type_pi32 , pi); }
973 payload & assign_pu32 (::u32 * pu) { return __assign_primitive_pointer(m_pu32 , e_type_pu32 , pu); }
974 payload & assign_pi64 (::i64 * pll) { return __assign_primitive_pointer(m_pi64 , e_type_pi64 , pll); }
975 payload & assign_pu64 (::u64 * pull) { return __assign_primitive_pointer(m_pu64 , e_type_pu64 , pull); }
976 payload & assign_pf32 (::f32 * pf) { return __assign_primitive_pointer(m_pf32 , e_type_pf32 , pf); }
977 payload & assign_pf64 (::f64 * pf) { return __assign_primitive_pointer(m_pf64 , e_type_pf64 , pf); }
978
979protected:
980
981
982 template < typename PRIMITIVE >
983 bool __assign_to_held_pointer_member(PRIMITIVE prototype)
984 {
985
986 if(get_type() == e_type_pbool)
987 {
988
989 *m_pb = (bool) prototype;
990
991 }
992 else if(get_type() == e_type_pu8)
993 {
994
995 *m_pu8 = (::u8) prototype;
996
997 }
998 else if(get_type() == e_type_pi8)
999 {
1000
1001 *m_pi8 = (::i8) prototype;
1002
1003 }
1004 else if(get_type() == e_type_pu16)
1005 {
1006
1007 *m_pu16 = (::u16) prototype;
1008
1009 }
1010 else if(get_type() == e_type_pi16)
1011 {
1012
1013 *m_pi16 = (::i16) prototype;
1014
1015 }
1016 else if(get_type() == e_type_pu32)
1017 {
1018
1019 *m_pu32 = (::u32) prototype;
1020
1021 }
1022 else if(get_type() == e_type_pi32)
1023 {
1024
1025 *m_pi32 = (::i32) prototype;
1026
1027 }
1028 else if(get_type() == e_type_pu64)
1029 {
1030
1031 *m_pu64 = (::u64) prototype;
1032
1033 }
1034 else if(get_type() == e_type_pi64)
1035 {
1036
1037 *m_pi64 = (::i64) prototype;
1038
1039 }
1040 else if(get_type() == e_type_pf32)
1041 {
1042
1043 *m_pf32 = (::f32) prototype;
1044
1045 }
1046 else if(get_type() == e_type_pf64)
1047 {
1048
1049 *m_pf64 = (::f64) prototype;
1050
1051 }
1052 else
1053 {
1054
1055 return false;
1056
1057 }
1058
1059 return true;
1060
1061 }
1062
1063
1064 template < typename PRIMITIVE >
1065 payload& __assign_primitive(PRIMITIVE& member, enum_type etype, PRIMITIVE prototype);
1066
1067
1068 template < typename PRIMITIVE >
1069 payload & __assign_primitive_pointer(PRIMITIVE * & member, enum_type etype, PRIMITIVE * pprimitive)
1070 {
1071
1072 set_type(etype, false);
1073
1074 member = pprimitive;
1075
1076 return *this;
1077
1078 }
1079
1080
1081public:
1082 template < bool_type BOOL > payload & operator=(BOOL b) { return assign_bool(b); }
1083#define NUMBER_TYPE_OPERATION(NUMBER_TYPE, NUMBER_NAME, NUMBER_SHORT_NAME, UPPER_CASE_NAME) \
1084template < same_as < NUMBER_TYPE > UPPER_CASE_NAME > payload & operator = (UPPER_CASE_NAME NUMBER_SHORT_NAME) \
1085{return assign_## NUMBER_NAME(NUMBER_SHORT_NAME);}
1086 DO_FOR_NUMBER_TYPES(NUMBER_TYPE_OPERATION)
1087#undef NUMBER_TYPE_OPERATION
1088
1089 //template < char_type CHAR > payload & operator=(CHAR c) { return assign_char(c); }
1090 //template < i8_type I8 > payload & operator=(I8 i) { return assign_char(i); }
1091 //template < same_as < ::u8 > U8 > payload & operator=(U8 u) { return assign_unsigned_char(u); }
1092 //template < same_as < ::i16 > I16 > payload & operator=(I16 i) { return assign_short(i); }
1093 //template < same_as < ::u16 > U16 > payload & operator=(U16 u) { return assign_unsigned_short(u); }
1094 //template < same_as < ::i32 > I32 > payload & operator=(I32 i) { return assign_int(i); }
1095 //template < same_as < ::u32 > U32 > payload & operator=(U32 u) { return assign_u32(u); }
1096 //template < same_as < ::i64 > I64 > payload & operator=(I64 i) { return assign_i64(i); }
1097 //template < same_as < ::u64 > U64 > payload & operator=(U64 u) { return assign_u64(u); }
1098 //template < same_as < ::f32 > F32 > payload & operator=(F32 f) { return assign_f32(f); }
1099 //template < same_as < ::f64 > F64 > payload & operator=(F64 f) { return assign_f64(f); }
1100
1101
1102 payload & assign_pointer(::i8 * pi) { return assign_pi8(pi); }
1103 payload & assign_pointer(::u8 * pu) { return assign_pu8(pu); }
1104 payload & assign_pointer(::i16 * pi) { return assign_pi16(pi); }
1105 payload & assign_pointer(::u16 * pu) { return assign_pu16(pu); }
1106 payload & assign_pointer(::i32 * pi) { return assign_pi32(pi); }
1107 payload & assign_pointer(::u32 * pu) { return assign_pu32(pu); }
1108 payload & assign_pointer(::i64 * pi) { return assign_pi64(pi); }
1109 payload & assign_pointer(::u64 * pu) { return assign_pu64(pu); }
1110 payload & assign_pointer(::f32 * pf) { return assign_pf32(pf); }
1111 payload & assign_pointer(::f64 * pf) { return assign_pf64(pf); }
1112
1113#ifdef WINDOWS
1114 payload & operator = (long l);
1115#endif
1116 payload & operator = (const ::earth::time & time);
1117 payload & operator = (const ::color::color & color);
1118 payload & operator = (const ::color::hls & color);
1119 inline payload & operator = (const ::string & str);
1120 inline payload & operator = (const ::scoped_string & scopedstr);
1121 inline payload & operator = (::string && str);
1122 inline payload & operator = (::const_ansi_range ansirange);
1123 inline payload & operator = (const ::inline_number_string & str);
1124 payload & operator = (::string * pstr);
1125 //payload & operator = (::payload * pvar);
1126 //payload & operator = (const ::payload * pvar);
1127 payload & operator = (const ::wide_character * pcsz);
1128 payload& operator = (const ::ansi_character* pcsz);
1129
1130 payload & operator = (const ::property & prop);
1131 //payload & operator = (const ::property * pproperty);
1132
1133 //template < prototype_character CHARACTER, ::i32 t_size >
1134 //payload & operator = (const const_string_range_static_array< const CHARACTER *, t_size > & a)
1135 //{
1136
1137 // return this->operator=(::string(a));
1138
1139 //}
1140 payload & operator = (const ::payload & payload);
1141 payload & operator = (const ::i32_array_base & ia);
1142 payload & operator = (const ::string_array_base & stra);
1143 payload & operator = (const ::i64_array_base & longlonga);
1144 payload & operator = (const ::f32_array_base & f32a);
1145 payload & operator = (const ::f64_array_base & f64a);
1146 payload & operator = (const ::memory & memory);
1147 payload & operator = (const ::payload_array & payloada);
1148 payload & operator = (const ::property_set & propset);
1149 payload & operator = (const ::atom & atom);
1150 payload & operator = (::atom * pid);
1151 template < prototype_enum ENUM >
1152 payload & operator = (ENUM e);
1153 //payload & operator = (const ::second & second);
1154 //payload & operator = (class ::second * ptime);
1155 //payload & operator = (const class time & time);
1156 //payload & operator = (class ::time * pmillis);
1157 //payload & operator = (const ::microsecond & microsecond);
1158 //payload & operator = (class ::microsecond * pmicros);
1159 //payload & operator = (const ::nanosecond & nanosecond);
1160 //payload & operator = (class ::nanosecond * pnanos);
1161 payload & operator = (const class time & time);
1162 payload & operator = (class ::time * ptime);
1163 payload & operator = (const ::block & block);
1164
1165 template < class ARRAY >
1166 void get_array(ARRAY & array) const
1167 {
1168
1169 auto count = this->array_get_count();
1170
1171 for (::i32 i = 0; i < count; i++)
1172 {
1173
1174 ::payload payloadItem = at(i);
1175
1176 typename ARRAY::BASE_TYPE typeNewItem;
1177
1178 ::assign(typeNewItem, payloadItem);
1179
1180 array.add(typeNewItem);
1181
1182 }
1183
1184 }
1185
1186 //template < class T >
1187 //payload & operator = (const pointer< T > & p)
1188 //{
1189
1190 // return this->operator = (p.m_p);
1191
1192 //}
1193
1194 //template < class T >
1195 //payload & operator = (const ::pointer < T > & p)
1196 //{
1197
1198 // return this->operator = (p.m_p);
1199
1200 //}
1201 //template < class T >
1202 //payload & operator = (const pointer < T > & resultpointer)
1203 //{
1204
1205 // if (!resultpointer)
1206 // {
1207 //
1208 // return operator=(resultpointer.m_estatus);
1209
1210 // }
1211 // else
1212 // {
1213 //
1214 // return operator = (resultpointer.m_p);
1215
1216 // }
1217
1218 //}
1219
1220 template < an_object T >
1221 payload & assign_copy(const T & t)
1222 {
1223
1224 ::copy(*this, t);
1225
1226 return *this;
1227
1228 }
1229
1230
1231 template < class T >
1232 payload & operator = (const raw_block < T > & rawblock)
1233 {
1234
1235 return this->operator = (rawblock.block());
1236
1237 }
1238
1239 template < character_count n >
1240 payload & operator = (const ::i8(&cha)[n]);
1241
1242
1243 //template < prototype_subparticle T >
1244 //T * cast();
1245
1246 template < prototype_subparticle T >
1247 ::pointer < T > cast(T* pDefault);
1248
1249 template < class T >
1250 T & defer_create_type(T * pdefault = nullptr)
1251 {
1252
1253 ::pointer< T > p = pdefault;
1254
1255 if (!p)
1256 {
1257
1258 p = allocateø T();
1259
1260 operator =(p);
1261
1262 }
1263
1264 return *p;
1265
1266 }
1267
1268
1269 template < typename T >
1270 T & as_type();
1271
1272
1273 //template < class T >
1274 //::ptr< T > cast(T * pDefault) const
1275 //{
1276 // return ((payload *)this)->cast < T >(pDefault);
1277 //}
1278
1279
1280 //template < class T >
1281 //::pointer< T > cast();
1282
1283 ::subparticle * as_subparticle()
1284 {
1285 if (m_etype == e_type_element) { return m_p; }
1286 return cast < ::subparticle >();
1287 }
1288
1289 ::subparticle * as_subparticle() const { return ((payload *)this)->as_subparticle(); }
1290
1291 template < prototype_subparticle T >
1292 T* cast() const;
1293
1294 template < prototype_subparticle T >
1295 T* cast();
1296
1297 template < prototype_subparticle T >
1298 ::pointer < T > as_pointer() const;
1299
1300 template < prototype_subparticle T >
1301 ::pointer < T > as_pointer();
1302
1303 ::subparticle * get_subparticle();
1304
1305 // bool strictly_equal(const payload & payload) const;
1306 // bool strictly_equal(const ::scoped_string & scopedstr) const;
1307 // bool strictly_equal(const ::scoped_string & scopedstr) const;
1308 // bool strictly_equal(::f64 d) const;
1309 // bool strictly_equal(::i32 i) const;
1310 // bool strictly_equal(bool b) const;
1311 //
1312 // bool strictly_different(const payload & payload) const;
1313 // bool strictly_different(const ::scoped_string & scopedstr) const;
1314 // bool strictly_different(const ::scoped_string & scopedstr) const;
1315 // bool strictly_different(::f64 d) const;
1316 // bool strictly_different(::i32 i) const;
1317 // bool strictly_different(bool b) const;
1318
1319 //friend bool CLASS_DECL_ACME strict_equal(const ::scoped_string & scopedstr,const payload & payload);
1320 //friend bool CLASS_DECL_ACME strict_equal(const ::scoped_string & scopedstr,const payload & payload);
1321 //friend bool CLASS_DECL_ACME strict_equal(::f64 d,const payload & payload);
1322 //friend bool CLASS_DECL_ACME strict_equal(::i32 i,const payload & payload);
1323 //friend bool CLASS_DECL_ACME strict_equal(bool b,const payload & payload);
1324
1325 //friend bool CLASS_DECL_ACME strict_different(const ::scoped_string & scopedstr,const payload & payload);
1326 //friend bool CLASS_DECL_ACME strict_different(const ::scoped_string & scopedstr,const payload & payload);
1327 //friend bool CLASS_DECL_ACME strict_different(::f64 d,const payload & payload);
1328 //friend bool CLASS_DECL_ACME strict_different(::i32 i,const payload & payload);
1329 //friend bool CLASS_DECL_ACME strict_different(bool b,const payload & payload);
1330
1331 //bool equals(const payload & payload) const;
1332 //bool equals(const ::scoped_string & scopedstr) const;
1333
1334 bool case_insensitive_equals(const payload & payload) const;
1335
1336 ::std::strong_ordering order_payload(const payload & payload) const;
1337
1338 ::std::strong_ordering case_insensitive_order(const ::payload & payload) const;
1339
1340
1341 bool equals_payload(const ::payload & payload) const;
1342 bool equals_signed(::i64 i) const;
1343 bool equals_unsigned(::u64 u) const;
1344 bool equals_scoped_string(const ::scoped_string & scopedstr) const;
1345
1346
1347 template < prototype_character CHARACTER >
1348 bool operator == (const CHARACTER * psz) const { return equals_scoped_string(psz); }
1349 template < prototype_character CHARACTER >
1350 bool operator == (const character_range < const CHARACTER * > & range) const { return equals_scoped_string(range); }
1351 template < prototype_character CHARACTER >
1352 bool operator == (const scoped_string_base < const CHARACTER * > & scoped_string) const { return equals_scoped_string(scoped_string); }
1353 template < prototype_character CHARACTER >
1354 bool operator == (const string_base < const CHARACTER * > & string) const { return equals_scoped_string(string); }
1355 template < prototype_character CHARACTER >
1356 bool operator == (const string_range < const CHARACTER * > & string_range) const { return equals_scoped_string(string_range); }
1357 //bool operator == (const ::scoped_string & scopedstr) const;
1358 template < prototype_signed SIGNED >
1359 bool operator == (SIGNED i) const { return equals_signed(i); }
1360 template < prototype_unsigned UNSIGNED >
1361 bool operator == (UNSIGNED u) const { return equals_unsigned(u); }
1362 //bool operator == (::i32 i) const;
1363 //bool operator == (bool b) const;
1364
1365 //bool operator != (const payload & payload) const;
1366 //bool operator != (const ::scoped_string & scopedstr) const;
1367 //bool operator != (const ::scoped_string & scopedstr) const;
1368 //bool operator != (::i64 i) const;
1369 //bool operator != (::i32 i) const;
1370 //bool operator != (bool b) const;
1371
1372 ::std::strong_ordering operator <=> (const payload & payload) const;
1373 ::std::strong_ordering operator <=> (const ::string & str) const;
1374 ::std::strong_ordering operator <=> (const ::scoped_string & scopedstr) const;
1375 ::std::strong_ordering operator <=> (::i64 i) const;
1376 ::std::strong_ordering operator <=> (::i32 i) const;
1377 ::std::strong_ordering operator <=> (bool b) const;
1378
1379 //bool operator <= (const payload & payload) const;
1380 //bool operator <= (const ::scoped_string & scopedstr) const;
1381 //bool operator <= (const ::scoped_string & scopedstr) const;
1382 //bool operator <= (::i64 i) const;
1383 //bool operator <= (::i32 i) const;
1384 //bool operator <= (bool b) const;
1385
1386 //bool operator >= (const payload & payload) const;
1387 //bool operator >= (const ::scoped_string & scopedstr) const;
1388 //bool operator >= (const ::scoped_string & scopedstr) const;
1389 //bool operator >= (::i64 i) const;
1390 //bool operator >= (::i32 i) const;
1391 //bool operator >= (bool b) const;
1392
1393 //bool operator > (const payload & payload) const;
1394 //bool operator > (const ::scoped_string & scopedstr) const;
1395 //bool operator > (const ::scoped_string & scopedstr) const;
1396 //bool operator > (::i64 i) const;
1397 //bool operator > (::i32 i) const;
1398 //bool operator > (bool b) const;
1399
1400
1401 ::string implode(const ::scoped_string & scopedstrGlue) const;
1402 payload explode(const ::scoped_string & scopedstrGlue,bool bAddEmpty = true) const;
1403
1404 payload first() const;
1405 payload last() const;
1406 payload first();
1407 payload last();
1408 ::collection::count get_count() const;
1409
1410
1411 ::payload at(::collection::index i);
1412 inline ::payload at(::collection::index i) const { return ((::payload *)this)->at(i); }
1413
1414
1415 ::collection::count array_get_count() const;
1416 ::collection::index array_get_upper_bound() const;
1417 bool array_contains(const ::scoped_string & scopedstr, ::collection::index find = 0, ::collection::count count = -1) const;
1418 bool case_insensitive_array_contains(const ::scoped_string & scopedstr, ::collection::index find = 0, ::collection::count count = -1) const;
1419 bool array_is_empty() const { return array_get_count() <= 0; }
1420
1421
1422 ::collection::index index_of(const ::atom & atom) const;
1423 //::property * find_property_index(::iptr i) const;
1424 //::property & get_property_index(::iptr i);
1425 //::property * find_property(const ::scoped_string & scopedstr) const;
1426 //::property & get_property(const ::scoped_string & scopedstr);
1427 ::payload find_property(const ::atom & atom) const; // { return atom.is_text() ? find_property_text_key((const ::scoped_string &)atom.m_str) : find_property_index(atom.m_i32); }
1428 ::property * _find_property(const ::atom & atom) const;
1429 ::property & get_property(const ::atom & atom); // { return atom.is_text() ? get_property_text_key((const ::scoped_string &)atom.m_str) : get_property_index(atom.m_i32); }
1430
1431 ::payload find_property_by_text(const ::scoped_string & scopedstr) const;
1432
1433 ::payload find_property_by_name(const ::scoped_string &scopedstr) const;
1434
1435
1436
1437 //::payload operator[] (const ::atom & atom);
1438 //::payload operator[] (const ::atom & atom) const;
1439 template < prototype_integral INTEGRAL >
1440 inline ::payload operator[] (INTEGRAL i) { return at(i); }
1441 template < prototype_integral INTEGRAL >
1442 inline ::payload operator[] (INTEGRAL i) const { return at(i); }
1443
1444 template < prototype_character CHARACTER >
1445 inline ::property & operator[] (const CHARACTER * psz) { return get_property(psz); }
1446 template < prototype_character CHARACTER >
1447 inline ::payload operator[] (const CHARACTER * psz) const { return find_property_by_name(psz); }
1448
1449 template < prototype_character_range RANGE >
1450 inline ::property & operator[] (const RANGE & range) { return get_property(range); }
1451 template < prototype_character_range RANGE >
1452 inline ::payload operator[](const RANGE &range) const
1453 {
1454 return find_property_by_name(range);
1455 }
1456
1457 template < has_as_string HAS_AS_STRING >
1458 inline ::property & operator[] (const HAS_AS_STRING & has_as_string)
1459 requires (!prototype_character_range<HAS_AS_STRING>)
1460 { return get_property(has_as_string.as_string()); }
1461 template < has_as_string HAS_AS_STRING >
1462 inline ::payload operator[] (const HAS_AS_STRING & has_as_string) const
1463 requires (!prototype_character_range<HAS_AS_STRING>)
1464 {
1465 return find_property_by_name(has_as_string.as_string());
1466 }
1467
1468 template < has_get_string HAS_GET_STRING >
1469 inline ::property & operator[] (const HAS_GET_STRING & has_get_string)
1470 requires (!prototype_character_range<HAS_GET_STRING> && has_as_string<HAS_GET_STRING>)
1471 { return get_property(has_get_string.get_string()); }
1472 template < has_get_string HAS_GET_STRING >
1473 inline ::payload operator[] (const HAS_GET_STRING & has_get_string) const
1474 requires (!prototype_character_range<HAS_GET_STRING>&& has_as_string<HAS_GET_STRING>)
1475 {
1476 return find_property_by_name(has_get_string.get_string());
1477 }
1478
1479
1480 //inline ::property & operator[] (::iptr i);
1481 //inline ::payload operator[] (::iptr i) const;
1482
1483//#if OSBIT == 64
1484//
1485// inline ::property & operator[] (::i32 i) { return get_property(::atom(i)); }
1486// inline ::payload operator[] (::i32 i) const { return find_property(::atom(i)); }
1487//
1488//#endif
1489
1490
1491 ::payload equals_ci_get(const ::scoped_string & scopedstrCompare,::payload varOnEqual,payload varOnDifferent) const;
1492 ::payload equals_ci_get(const ::scoped_string & scopedstrCompare,::payload varOnEqual) const;
1493
1494 template < prototype_integral INTEGRAL >
1495 ::payload operator - (INTEGRAL i) const;
1496 template < prototype_floating FLOATING >
1497 ::payload operator - (FLOATING f) const;
1498
1499
1500 template < prototype_integral INTEGRAL >
1501 ::payload operator + (INTEGRAL i) const;
1502 template < prototype_floating FLOATING >
1503 ::payload operator + (FLOATING f) const;
1504
1505 //::payload operator + (const ::scoped_string & scopedstr) const;
1506 //::payload operator + (const ::scoped_string & scopedstr) const;
1507 //::payload operator + (const ::inline_number_string & inline_number_string) const;
1508
1509 template < prototype_integral INTEGRAL >
1510 ::payload operator / (INTEGRAL i) const;
1511 template < prototype_floating FLOATING >
1512 ::payload operator / (FLOATING f) const;
1513
1514 template < prototype_integral INTEGRAL >
1515 ::payload operator * (INTEGRAL i) const;
1516 template < prototype_floating FLOATING >
1517 ::payload operator * (FLOATING d) const;
1518
1519 ::std::strong_ordering str_compare(const ::property & prop) const;
1520
1521
1522
1523 template < prototype_integral INTEGRAL >
1524 ::payload & operator -= (INTEGRAL i);
1525 template < prototype_floating FLOATING >
1526 ::payload & operator -= (FLOATING f);
1527
1528
1529 template < prototype_integral INTEGRAL >
1530 ::payload & operator += (INTEGRAL i);
1531 template < prototype_floating FLOATING >
1532 ::payload & operator += (FLOATING f);
1533
1534 //::payload & operator += (const ::scoped_string & scopedstr);
1535 //::payload & operator += (const ::scoped_string & scopedstr);
1536 //::payload & operator += (const ::inline_number_string & inline_number_string);
1537 //template < character_count n >
1538 //::payload & operator += (const ::ansi_character (&cha)[n]) { return *this += ::scoped_string(cha);}
1539
1540 //template < typename ITERATOR_TYPE, ::i32 t_size >
1541 //::payload & operator += (const const_string_range_static_array < ITERATOR_TYPE, t_size > & a) { return *this += ::string(a);}
1542
1543 template < prototype_integral INTEGRAL >
1544 ::payload & operator /= (INTEGRAL i);
1545 template < prototype_floating FLOATING >
1546 ::payload & operator /= (FLOATING f);
1547
1548 template < prototype_integral INTEGRAL >
1549 ::payload & operator *= (INTEGRAL i);
1550 template < prototype_floating FLOATING >
1551 ::payload & operator *= (FLOATING d);
1552
1553
1554 void consume_number(::ansi_range & range);
1555 //void consume_number((::ansi_range & range);
1556 void consume_identifier(::ansi_range & range);
1557 //void consume_identifier((::ansi_range & range);
1558 void parse_network_payload(::ansi_range & range);
1559 //void parse_network_payload((::ansi_range & range);
1560 const_char_pointer parse_network_payload(const ::scoped_string & scopedstrNetworkPayload);
1561 ::enum_type find_network_payload_child(::ansi_range & range, const payload & payload);
1562 //::enum_type find_network_payload_child((::ansi_range & range, const payload & payload);
1563 ::enum_type find_network_payload_id(::ansi_range & range, const payload & payload);
1564 bool parse_network_payload_step(::ansi_range & range);
1565 // bool parse_network_payload_step(const_char_pointer & pszJson, const ::ansi_character * pszEnd);
1566
1567 ::string & get_network_payload(::string & str, bool bNewLine = true) const;
1568 ::string get_network_payload(bool bNewLine = true) const;
1569
1570
1571
1572 //
1573 // DECLARE_AXIS_FIXED_ALLOC(payload)
1574
1575 void null();
1576
1577
1578
1579 void _001Add(const ::string_array_base & stra);
1580
1581
1582 void defer_run_payload();
1583
1584 void receive_response(const payload & payload);
1585
1586
1587};
1588
1589
1590#include "acme/prototype/collection/__payload_array.h"
1591
1592
1593#include "__payload_reference.h"
1594#include "acme/prototype/collection/property_set.h"
1595#include "acme/prototype/prototype/url.h"
1596
1597
1598
1599//
1600//namespace str
1601//{
1602
1603
1604 //inline CLASS_DECL_ACME void from(::string & str, const payload & payload)
1605 //{
1606
1607 // str = payload;
1608
1609 //}
1610
1611//
1612//} // namespace str
1613
1614
1615//CLASS_DECL_ACME void var_skip_number(const_char_pointer & psz);
1616CLASS_DECL_ACME void payload_skip_number(::ansi_range & range);
1617//CLASS_DECL_ACME void var_skip_identifier(const_char_pointer & psz);
1618CLASS_DECL_ACME void payload_skip_identifier(::ansi_range & range);
1619//CLASS_DECL_ACME void var_skip_network_payload(const_char_pointer & pszJson);
1620CLASS_DECL_ACME void payload_skip_network_payload(::ansi_range & range);
1621
1622
1623
1624
1625//#if defined(__APPLE__) || defined(__ANDROID__) || defined(RASPBERRYPIOS) || defined(WINDOWS)
1626//
1627//
1628//inline payload::operator long &()
1629//{
1630//
1631// set_type(e_type_i64);
1632//
1633// return (long &) m_i64;
1634//
1635//}
1636//
1637//
1638//inline payload::operator ulong &()
1639//{
1640//
1641// set_type(e_type_u64);
1642//
1643// return (ulong &) m_u64;
1644//
1645//}
1646//
1647//
1648//#endif
1649
1650
1651// returns 0 for unknown conversions
1652//inline payload::operator ::i8() const
1653//{
1654// return ::i8();
1655//}
1656
1657// returns 0 for unknown conversions
1658//inline payload::operator ::u8() const
1659//{
1660// return ::u8();
1661//}
1662
1663
1664// returns 0 for unknown conversions
1665//inline payload::operator ::i16() const
1666//{
1667// return ::i16();
1668//}
1669
1670// returns 0 for unknown conversions
1671//inline payload::operator ::u16() const
1672//{
1673// return ::u16();
1674//}
1675
1676
1677
1678// returns 0 for unknown conversions
1679//inline payload::operator ::i32() const
1680//{
1681// return ::i32();
1682//}
1683
1684// returns 0 for unknown conversions
1685//inline payload::operator ::u32() const
1686//{
1687// return ::u32();
1688//}
1689
1690
1691// returns 0 for unknown conversions
1692//inline payload::operator ::i64()const
1693//{
1694// return i64;
1695//}
1696
1697// returns 0 for unknown conversions
1698//inline payload::operator ::u64() const
1699//{
1700// return u64;
1701//}
1702
1703
1704
1705
1706
1707// returns 0.0 for unknown conversions?
1708//inline payload::operator ::f32() const
1709//{
1710//
1711// return get_f32();
1712//
1713//}
1714
1715
1716// returns 0.0 for unknown conversions?
1717//inline payload::operator ::f64() const
1718//{
1719//
1720// return get_f64();
1721//
1722//}
1723
1724
1725// returns 0.0 for unknown conversions?
1726//inline payload::operator void() const
1727//{
1728//
1729// return estatus();
1730//
1731//}
1732
1733
1734//inline payload::operator class time() const
1735//{
1736//
1737// return time();
1738//
1739//}
1740//
1741//
1742//inline payload::operator class second() const
1743//{
1744//
1745// return second();
1746//
1747//}
1748
1749
1750//inline payload::operator class ::time() const
1751//{
1752//
1753// return class ::time();
1754//
1755//}
1756//
1757//
1758//inline payload::operator class microsecond() const
1759//{
1760//
1761// return microsecond();
1762//
1763//}
1764//
1765//
1766//inline payload::operator class nanosecond() const
1767//{
1768//
1769// return nanosecond();
1770//
1771//}
1772
1773
1774inline iptr payload::as_iptr(::iptr iDefault) const
1775{
1776
1777#if defined(OS64BIT)
1778
1779 return as_i64(iDefault);
1780
1781#else
1782
1783 return as_i32(iDefault);
1784
1785#endif
1786
1787}
1788
1789
1790inline uptr payload::as_uptr(::uptr uiDefault) const
1791{
1792
1793#ifdef OS64BIT
1794
1795 return as_u64(uiDefault);
1796
1797#else
1798
1799 return as_u32(uiDefault);
1800
1801#endif
1802
1803}
1804
1805
1806#ifdef WINDOWS
1807
1808//#elif defined(__APPLE__) || defined(RASBPIAN)
1809#elif defined(RASBPIAN)
1810
1811inline payload::operator long() const
1812{
1813
1814 return as_i64();
1815
1816}
1817
1818
1819
1820// returns 0 for unknown conversions
1821inline payload::operator ulong() const
1822{
1823#if LONG_IS_32BIT
1824 return as_u32();
1825#else
1826 return as_u64();
1827#endif
1828}
1829
1830
1831//#elif defined(__ANDROID__)
1832//
1833//inline payload::operator long() const
1834//{
1835//
1836// return ::i32();
1837//
1838//}
1839
1840#endif
1841
1842
1843//inline ::string & payload::string_reference(const ::scoped_string & scopedstrOnNull)
1844//{
1845//
1846// set_type(e_type_string, true);
1847//
1848// return m_str;
1849//
1850//}
1851
1852
1853inline ::payload __visible(::payload varOptions, bool bVisible);
1854
1855inline payload __visible(bool bVisible = true);
1856
1857
1858//template < prototype_character_range RANGE, prototype_payload PAYLOAD >
1859//::string operator + (const RANGE & range, const PAYLOAD & has_as_string);
1860
1861
1862template < prototype_payload PAYLOAD1, prototype_payload PAYLOAD2 >
1863inline PAYLOAD1 operator +(const PAYLOAD1 & payload1, const PAYLOAD2 & payload2)
1864{
1865
1866 auto payload = payload1;
1867
1868 payload.addition(payload2);
1869
1870 return ::transfer(payload);
1871
1872}
1873
1874
1875template < prototype_payload PAYLOAD1, prototype_payload PAYLOAD2 >
1876inline PAYLOAD1 & operator +=(PAYLOAD1 & payload1, const PAYLOAD2 & payload2)
1877{
1878
1879 return payload1.add(payload2);
1880
1881}
1882
1883
1884template < prototype_payload PAYLOAD, character_pointer CHARACTER_POINTER >
1885inline ::string operator +(const PAYLOAD & payload, CHARACTER_POINTER psz)
1886{
1887
1888 ::string str(payload);
1889
1890 str.append(psz);
1891
1892 return ::transfer(str);
1893
1894}
1895
1896
1897template < prototype_payload PAYLOAD, prototype_character CHARACTER >
1898inline PAYLOAD & operator +=(PAYLOAD & payload, const CHARACTER * psz)
1899{
1900
1901 payload = ::string(payload.as_string() + psz);
1902
1903 return payload;
1904
1905}
1906
1907
1908//template < prototype_character CHARACTER, prototype_payload PAYLOAD >
1909//inline ::string operator +(const CHARACTER * psz, const PAYLOAD & payload)
1910//{
1911//
1912// ::string str(psz);
1913//
1914// str.append(payload.get_string());
1915//
1916// return ::transfer(str);
1917//
1918//}
1919
1920
1921CLASS_DECL_ACME void copy(::string & str, const ::payload & payload);
1922CLASS_DECL_ACME void copy(::payload & payload, const ::i32 & i);
1923CLASS_DECL_ACME void copy(::payload & payload, const ::scoped_string & scopedstr);
1924
1925
1926template < prototype_payload PAYLOAD1, prototype_payload PAYLOAD2 >
1927inline bool operator == (const PAYLOAD1 & payload1, const PAYLOAD2 & payload2)
1928{
1929
1930 return payload1.equals_payload(payload2);
1931
1932}
1933
1934
1935
1936
1937
1938template < prototype_character_range CHARACTER_RANGE >
1939payload::payload(const CHARACTER_RANGE& range) :
1940 payload(no_initialize_t{})
1941{
1942
1943 m_etype = e_type_string;
1944 zero(m_str);
1945 m_str = range;
1946
1947}
1948
1949
1950template < prototype_character CHARACTER, prototype_payload PAYLOAD >
1951inline ::file::path operator / (
1952 const ::range < const CHARACTER * > & range,
1953 const PAYLOAD & payload)
1954{
1955
1956 return ::file::path(range) / payload.as_file_path();
1957
1958}
1959
1960
atom
Definition atom.h:237
color::color
Definition color.h:162
color::hls
Definition color.h:104
CHARACTER
earth::time
Definition earth_time.h:33
file::path_object
Definition path_object.h:15
file::path
Definition path.h:52
function_common_base
Definition function.h:147
function
Definition _template_forward_declaration.h:297
memory_base
Definition memory_base.h:92
memory
Definition memory.h:33
particle
Definition particle.h:95
payload_array_base
Definition __payload_array.h:13
payload
Definition payload.h:54
payload::has_property
bool has_property(const ::atom &atom) const
property * defer_get_property(const ::atom & atom) const;
Definition [.cpp:5773
payload::is_set_false
bool is_set_false() const
Definition [.cpp:7006
payload::is_false
bool is_false() const
Definition [.cpp:6817
payload::find_property_by_text
::payload find_property_by_text(const ::scoped_string &scopedstr) const
Definition payload.cpp:6191
payload::index_of
::collection::index index_of(const ::atom &atom) const
Definition payload.cpp:6542
payload::find_property_by_name
::payload find_property_by_name(const ::scoped_string &scopedstr) const
Definition payload.cpp:6228
platform::type
Definition type.h:584
property_set
Definition property_set.h:512
property
Definition property.h:81
range
Definition range.h:223
status
Definition status.h:15
string_range
Definition string_range.h:13
subparticle
Definition subparticle.h:78
time
Definition aaa_time.h:13
url::url
Definition url.h:435
has_as_string
Definition _initial_concepts.h:462
has_get_string
Definition _initial_concepts.h:470
prototype_character_range
Definition _initial_concepts.h:367
PRIMITIVE_PAYLOAD_TAG_TYPE
Definition _forward_declaration.h:1313
no_initialize_t
Definition _tags.h:5
payload_all_t
Definition payload.h:44
posix_time_t
Definition posix_time.h:5
posix_time
Definition posix_time.h:8