acme
Foundational cross-platform layer of the ca2 framework
Loading...
Searching...
No Matches
_impl_payload.h
1//
2// Created by camilo on 23/12/2022 01:48 <3ThomasBorregaardSorensen!!
3//
4#pragma once
5
6
7
8//inline ::property & payload::operator[] (const ::scoped_string & scopedstr) { return get_property(scopedstr); }
9//inline ::payload payload::operator[] (const ::scoped_string & scopedstr) const { return find_property(scopedstr); }
10
11
12//inline ::property & operator[] (const ::scoped_string & scopedstr) { return get_property(::atom(str)); }
13//inline ::payload operator[] (const ::scoped_string & scopedstr) const { return find_property(::atom(str)); }
14
15
16//inline ::property & payload::operator[] (::iptr i) { return get_property(i); }
17//inline ::payload payload::operator[] (::iptr i) const { return find_property(i); }
18
19
20//inline ::payload payload::operator + (const ::scoped_string & scopedstr) const { return ::transfer(*this + ::scoped_string(str)); }
21//inline ::payload payload::operator + (const ::inline_number_string & inline_number_string) const { return ::transfer(*this + ::scoped_string(inline_number_string)); }
22
23
24//inline ::payload & payload::operator += (const ::scoped_string & scopedstr) { return *this = (*this + scopedstr); }
25//inline ::payload & payload::operator += (const ::scoped_string & scopedstr) { return *this += ::scoped_string(str); }
26//inline ::payload & payload::operator += (const ::inline_number_string & inline_number_string) { return *this = (*this + inline_number_string); }
27
28template < prototype_enum ENUM >
29payload & payload::operator = (ENUM e) { this->operator = ((const ::atom &) e); return *this; }
30
31
32template < character_count n >
33payload & payload::operator = (const ::i8(&cha)[n])
34{
35
36 return this->operator = (::string(cha));
37
38}
39
40
41inline ::string payload::as_string() const
42{
43
44 return this->as_string(nullptr);
45
46}
47
48
49inline class payload & payload::operator = (const ::scoped_string & scopedstr)
50{
51
52 set_string(scopedstr);
53
54 return *this;
55
56}
57
58
59inline class payload & payload::operator = (const ::string & str)
60{
61
62 set_string(str);
63
64 return *this;
65
66}
67
68
69inline class payload & payload::operator = (::string && str)
70{
71
72 set_string(::transfer(str));
73
74 return *this;
75
76}
77
78
79inline class payload & payload::operator = (::const_ansi_range ansirange)
80{
81
82 set_string(ansirange);
83
84 return *this;
85
86}
87
88
89inline class payload & payload::operator = (const inline_number_string & inlinenumberstring)
90{
91
92 set_string(inlinenumberstring);
93
94 return *this;
95
96}
97
98
99
100template < typename BLOCK_TYPE >
101payload::payload(const ::raw_block < BLOCK_TYPE > & rawblock) :
102 payload(e_type_new)
103{
104
105 //m_etype = e_type_new;
106 operator = (rawblock.block());
107
108}
109
110
111
112
113
114//inline void payload::set_string(const ::scoped_string & scopedstr, character_count size)
115//{
116//
117// if (get_type() == e_type_pstring)
118// {
119//
120// m_pstr->assign(scopedstr, size);
121//
122// }
123// else if (get_type() == e_type_payload_pointer)
124// {
125//
126// m_ppayload->set_string(scopedstr, size);
127//
128// }
129// else if (get_type() == e_type_property)
130// {
131//
132// m_pproperty->set_string(scopedstr, size);
133//
134// }
135// else
136// {
137//
138// set_type(e_type_string, false);
139//
140// m_str.assign(scopedstr, size);
141//
142// }
143//
144//}
145
146
147//inline void payload::set_string(const ::scoped_string & scopedstr)
148//{
149//
150// if(get_type() == e_type_pstring)
151// {
152//
153// *m_pstr = str;
154//
155// }
156// else if(get_type() == e_type_payload_pointer)
157// {
158//
159// *m_ppayload = str;
160//
161// }
162// else if (get_type() == e_type_property)
163// {
164//
165// ((payload&)*m_pproperty) = str;
166//
167// }
168// else
169// {
170//
171// set_type(e_type_string,false);
172//
173// m_str = str;
174//
175// }
176//
177//}
178
179
180//inline void payload::set_string(const ::inline_number_string & inlinenumberstring)
181//{
182//
183// if (get_type() == e_type_pstring)
184// {
185//
186// m_pstr->assign(inlinenumberstring);
187//
188// }
189// else if (get_type() == e_type_payload_pointer)
190// {
191//
192// m_ppayload->set_string(inlinenumberstring);
193//
194// }
195// else if (get_type() == e_type_property)
196// {
197//
198// m_pproperty->set_string(inlinenumberstring);
199//
200// }
201// else
202// {
203//
204// set_type(e_type_string, false);
205//
206// m_str.assign(inlinenumberstring);
207//
208// }
209//
210//}
211
212
213class CLASS_DECL_ACME payload_object :
214 virtual public particle
215{
216public:
217
218 payload m_payload;
219
220};
221
222
223
224//class CLASS_DECL_ACME pack :
225// public payload
226//{
227//public:
228//
229//
230// using payload::payload;
231//
232//
233// template < typename TYPE >
234// pack(const ::pointer<TYPE>& p) { set_pointer(p); }
235// pack(const ::std::initializer_list < pack >& list_base);
236//
237//};
238
239
240inline payload __visible(payload varOptions, bool bVisible = true);
241
242inline payload __visible(bool bVisible) { return __visible(::e_type_new, bVisible); }
243
244
245
246
247
248template < prototype_integral INTEGRAL >
249inline ::payload payload::operator - (INTEGRAL i) const
250{
251 return ((INTEGRAL)*this) - i;
252}
253
254
255template < prototype_floating FLOATING >
256inline ::payload payload::operator - (FLOATING f) const
257{
258 return ((FLOATING)*this) - f;
259}
260
261
262template < prototype_integral INTEGRAL >
263inline ::payload payload::operator + (INTEGRAL i) const
264{
265 return ((INTEGRAL)*this) + i;
266}
267
268
269template < prototype_floating FLOATING >
270inline ::payload payload::operator + (FLOATING f) const
271{
272 return ((FLOATING)*this) + f;
273}
274
275
276template < prototype_integral INTEGRAL >
277inline ::payload payload::operator / (INTEGRAL i) const
278{
279 return ((INTEGRAL)*this) / i;
280}
281
282
283template < prototype_floating FLOATING >
284inline ::payload payload::operator / (FLOATING f) const
285{
286 return ((FLOATING)*this) / f;
287}
288
289
290template < prototype_integral INTEGRAL >
291inline ::payload payload::operator * (INTEGRAL i) const
292{
293 return ((INTEGRAL)*this) * i;
294}
295
296
297template < prototype_floating FLOATING >
298inline ::payload payload::operator * (FLOATING f) const
299{
300 return ((FLOATING)*this) * f;
301}
302
303
304#include "__payload_cast.h"
305
306
307template < prototype_integral INTEGRAL, prototype_payload PAYLOAD >
308inline ::payload operator - (INTEGRAL i, const PAYLOAD & payload)
309{
310 return i - ((INTEGRAL)payload_cast(payload));
311}
312
313
314template < prototype_floating FLOATING, prototype_payload PAYLOAD >
315inline ::payload operator - (FLOATING i, const PAYLOAD & payload)
316{
317 return i - ((FLOATING)payload_cast(payload));
318}
319
320
321template < prototype_integral INTEGRAL, prototype_payload PAYLOAD >
322inline ::payload operator + (INTEGRAL i, const PAYLOAD & payload)
323{
324 return i + ((INTEGRAL)payload_cast(payload));
325}
326
327
328template < prototype_floating FLOATING, prototype_payload PAYLOAD >
329inline ::payload operator + (FLOATING i, const PAYLOAD & payload)
330{
331 return i + ((FLOATING)payload_cast(payload));
332}
333
334
335template < prototype_integral INTEGRAL, prototype_payload PAYLOAD >
336inline ::payload operator / (INTEGRAL i, const PAYLOAD & payload)
337{
338 return i / ((INTEGRAL)payload_cast(payload));
339}
340
341
342template < prototype_floating FLOATING, prototype_payload PAYLOAD >
343inline ::payload operator / (FLOATING i, const PAYLOAD & payload)
344{
345 return i / ((FLOATING)payload_cast(payload));
346}
347
348
349template < prototype_integral INTEGRAL, prototype_payload PAYLOAD >
350inline ::payload operator * (INTEGRAL i, const PAYLOAD & payload)
351{
352 return i * ((INTEGRAL)payload_cast(payload));
353}
354
355
356template < prototype_floating FLOATING, prototype_payload PAYLOAD >
357inline ::payload operator * (FLOATING i, const PAYLOAD & payload)
358{
359 return i * ((FLOATING)payload_cast(payload));
360}
361
362
363
364template < prototype_integral INTEGRAL >
365inline ::payload & payload::operator -= (INTEGRAL i)
366{
367 return *this = ((INTEGRAL)payload_cast(*this)) - i;
368}
369
370
371template < prototype_floating FLOATING >
372inline ::payload & payload::operator -= (FLOATING f)
373{
374 return *this = ((FLOATING)payload_cast(*this)) - f;
375}
376
377
378template < prototype_integral INTEGRAL >
379inline ::payload & payload::operator += (INTEGRAL i)
380{
381 return *this = ((INTEGRAL)(payload_cast(*this))) + i;
382}
383
384
385template < prototype_floating FLOATING >
386inline ::payload & payload::operator += (FLOATING f)
387{
388 return *this = ((FLOATING)payload_cast(*this)) + f;
389}
390
391
392template < prototype_integral INTEGRAL >
393inline ::payload & payload::operator /= (INTEGRAL i)
394{
395 return *this = ((INTEGRAL)payload_cast(*this)) / i;
396}
397
398
399template < prototype_floating FLOATING >
400inline ::payload & payload::operator /= (FLOATING f)
401{
402 return *this = ((FLOATING)payload_cast(*this)) / f;
403}
404
405
406template < prototype_integral INTEGRAL >
407inline ::payload & payload::operator *= (INTEGRAL i)
408{
409 return *this = ((INTEGRAL)payload_cast(*this)) * i;
410}
411
412
413template < prototype_floating FLOATING >
414inline ::payload & payload::operator *= (FLOATING f)
415{
416 return *this = ((FLOATING)payload_cast(*this)) * f;
417}
418
419
420
421
422
423
424
425//template < prototype_payload PAYLOAD >
426//inline bool strictly_equal(const ::scoped_string & scopedstr, const PAYLOAD & payload);
427//template < prototype_payload PAYLOAD >
428//inline bool strictly_equal(const ::scoped_string & scopedstr, const PAYLOAD & payload);
429//template < prototype_payload PAYLOAD >
430//inline bool strictly_equal(::f64 d, const PAYLOAD & payload);
431//template < prototype_payload PAYLOAD >
432//inline bool strictly_equal(::i32 i, const PAYLOAD & payload);
433//template < prototype_payload PAYLOAD >
434//inline bool strictly_equal(bool b, const PAYLOAD & payload);
435
436
437template < prototype_payload PAYLOAD >
438inline bool strictly_different(const ::scoped_string & scopedstr, const PAYLOAD & payload);
439template < prototype_payload PAYLOAD >
440inline bool strictly_different(const ::scoped_string & scopedstr, const PAYLOAD & payload);
441template < prototype_payload PAYLOAD >
442inline bool strictly_different(::f64 d, const PAYLOAD & payload);
443template < prototype_payload PAYLOAD >
444inline bool strictly_different(::i32 i, const PAYLOAD & payload);
445template < prototype_payload PAYLOAD >
446inline bool strictly_different(bool b, const PAYLOAD & payload);
447
448
449inline ::payload_reference __reference(payload & payload)
450{
451
452 return payload;
453
454}
455
456
457
458//#include "payload_reference.h"
459//
460//
461//template < typename TYPE >
462//TYPE & payload::reference(TYPE & t)
463//{
464//
465// return t = payload_reference(*this);
466//
467//}
468//
469
470CLASS_DECL_ACME::string as_string(const ::payload & payload);
471
472
473inline payload & copy(payload & payload, const class time & time)
474{
475
476 payload.set_type(e_type_time);
477
478 payload.m_time = time;
479
480 return payload;
481
482}
483
484
485//template < typename TYPE_CHAR >
486//inline string_base < TYPE_CHAR >::string_base(const ::payload & payload) :
487// string_base(payload.string())
488//{
489//
490//
491//}
492
493
494template < prototype_subparticle T >
495inline ::pointer < T > payload::cast(T * pDefault)
496{
497
498 //if (m_etype == e_type_payload_pointer && m_ppayload != nullptr)
499 //{
500
501 // return m_ppayload->cast < T >(pDefault);
502
503 //}
504 //else if (m_etype == e_type_property && m_pproperty != nullptr)
505 //{
506
507 // return m_pproperty->object().cast < T >(pDefault);
508
509 //}
510
511 auto psubparticle = get_subparticle();
512
513 if (!psubparticle)
514 {
515
516 return pDefault;
517
518 }
519
520 auto p = dynamic_cast<T*>(psubparticle);
521
522 if (!psubparticle)
523 {
524
525 return pDefault;
526
527 }
528
529 return p;
530
531}
532
533
534template < prototype_subparticle T >
535inline T * payload::cast()
536{
537
538 auto psubparticle = get_subparticle();
539
540 if (!psubparticle)
541 {
542
543 return nullptr;
544
545 }
546
547 auto p = dynamic_cast<T*>(psubparticle);
548
549 if (!psubparticle)
550 {
551
552 return nullptr;
553
554 }
555
556 return p;
557
558}
559
560
561template < prototype_subparticle T >
562inline T * payload::cast() const
563{
564
565 return ((::payload*)this)->cast < T >();
566
567}
568
569
570template < prototype_subparticle T >
571inline ::pointer < T > payload::as_pointer()
572{
573
574 auto psubparticle = get_subparticle();
575
576 if (!psubparticle)
577 {
578
579 return nullptr;
580
581 }
582
583 ::pointer < T > p = psubparticle;
584
585 if (!p)
586 {
587
588 return nullptr;
589
590 }
591
592 return ::transfer(p);
593
594}
595
596
597template < prototype_subparticle T >
598inline ::pointer < T > payload::as_pointer() const
599{
600
601 return ::transfer(((::payload*)this)->as_pointer < T >());
602
603}
604
605
606//template < class T >
607//inline T & payload::get_cast(T * pDefault)
608//{
609//
610// //if (m_etype == e_type_payload_pointer && m_ppayload != nullptr)
611// //{
612//
613// // return m_ppayload->get_cast <T>(pDefault);
614//
615// //}
616//
617// //if (m_etype == e_type_property && m_pproperty != nullptr)
618// //{
619//
620// // return m_pproperty->payload().get_cast <T>(pDefault);
621//
622// //}
623//
624// if (m_etype != e_type_element)
625// {
626//
627// return defer_create_type < T >(pDefault);
628//
629// }
630//
631// auto p = cast < T >();
632//
633// if (!p)
634// {
635//
636// return defer_create_type < T >(pDefault);
637//
638// }
639//
640// return *p;
641//
642//}
643
644
645//template < class T >
646//inline pointer < T > payload::cast()
647//{
648//
649// //if (m_etype == e_type_payload_pointer && m_ppayload != nullptr)
650// //{
651//
652// // return m_ppayload->cast < T >();
653//
654// //}
655//
656// //if (m_etype == e_type_property && m_pproperty != nullptr)
657// //{
658//
659// // return m_pproperty->cast < T >();
660//
661// //}
662//
663//
664// return get_subparticle();
665//
666//}
667
668
669
670template < typename T >
671inline pointer < T > payload::pointer() const
672{
673
674 auto pproperty = find_pointer < T >();
675
676 if (!pproperty)
677 {
678
679 return nullptr;
680
681 }
682
683 return pproperty->template cast < T >();
684
685}
686
687
688inline ::payload __visible(::payload varOptions, bool bVisible)
689{
690
691 varOptions["visible"] = bVisible;
692
693 return varOptions;
694
695}
696
697
698
699//inline ::payload operator + (::payload payload, const ::procedure & procedure)
700//{
701//
702// if (payload.get_type() != e_type_property_set)
703// {
704//
705// payload["message"] = payload;
706//
707// }
708//
709// payload["routine"] = procedure.m_p;
710//
711// return payload;
712//
713//}
714
715
716
717
718inline void assign(bool & b, const payload & payload)
719{
720
721 b = payload.get_bool();
722
723}
724
725
726inline void assign(::block & block, const ::payload & r)
727{
728
729 block.operator=(r.as_block());
730
731}
732
733
734#if defined(__APPLE__) || defined(__ANDROID__) || defined(RASPBERRYPIOS) || defined(WINDOWS)
735
736
737inline void assign(long & l, const payload & payload)
738{
739
740 l = payload.get_long();
741
742}
743
744
745inline void assign(ulong & ul, const payload & payload)
746{
747
748 ul = payload.get_unsigned_long();
749
750}
751
752
753#endif // defined(__APPLE__) || defined(__ANDROID__) || defined(RASPBERRYPIOS) || defined(WINDOWS)
754
755
756namespace file
757{
758
759
760 // inline path::path(const ::payload & payload,e_path epath): path(payload.get_file_path(),epath){}
761 // inline path::path(const property & property,e_path epath, ::i32 iDir): path(property.get_file_path(),epath, iDir) {}
762 //inline path & path::operator = (const ::payload & payload) { return operator = (payload.get_string()); }
763 //inline path & path::operator += (const ::payload & payload) { return operator += (payload.get_string()); }
764 //inline path & path::operator = (const property & property) { return operator = ((const ::payload &)property); }
765 //inline path & path::operator += (const property & property) { return operator += ((const ::payload &)property); }
766 //inline path path::operator + (const ::atom & atom) const { return operator + (::string(atom)); }
767 //inline path path::operator / (const ::atom & atom) const { return operator /(::file::path(atom)); }
768 //inline path path::operator * (const property & property) const { return operator *(::file::path(property)); }
769 //inline path & path::operator *= (const property & property) { return operator *=(::file::path(property)); }
770 inline path path::folder() const { return { ::file_path_folder(c_str()), m_epath }; }
771// inline path path::sibling(const path& path) const { return { ::file_path_folder(c_str()) + ::string("/") + ::sz::trim_left_path_sep(path.c_str()), m_epath }; }
772 inline path path::sibling(const ::scoped_string & scopedstr) const { return { ::file_path_folder(c_str()) + ::string("/") + ::sz::trim_left_path_sep(scopedstr.begin()), m_epath }; }
773// inline path path::sibling(const ::ansi_string & str) const { return this->sibling((const ::scoped_string &)str); }
774
775 inline ::const_ansi_range path::all_extensions() const
776 {
777
778 auto p = this->rear_find('/');
779
780 if (::is_null(p))
781 {
782
783 p = this->begin();
784
785 }
786
787 auto range = subrange(p);
788
789 p = range.find_skip_or_end('.');
790
791 return { p, this->end() };
792
793 }
794
795
796 inline ::const_ansi_range path::final_extension() const
797 {
798
799 auto rangeName = this->name();
800
801 auto last_dot = rangeName.rear_find('.');
802
803 if (!last_dot)
804 {
805
806 return {};
807
808 }
809
810 return { last_dot + 1, rangeName.end() };
811
812 }
813 //inline bool path::operator == (const ::payload & payload) const { return operator == (payload.file_path()); }
814 //inline bool path::operator != (const ::payload & payload) const { return operator != (payload.file_path()); }
815
816
817} // namespace file
818
819
820
821
822
823//template < typename TYPE_CHAR >
824//string_base < TYPE_CHAR > & string_base < TYPE_CHAR >::operator +=(const ::payload & payload)
825//{
826//
827// return append(payload);
828//
829//}
830//
831//template < typename TYPE_CHAR >
832//string_base < TYPE_CHAR > string_base < TYPE_CHAR >::operator +(const ::payload & payload) const
833//{
834//
835// string_base < TYPE_CHAR > ansistr(*this);
836//
837// ansistr += payload;
838//
839// return ansistr;
840//
841//}
842
843
844//template < typename TYPE_CHAR >
845//string_base < TYPE_CHAR > string_base < TYPE_CHAR >::operator +(const ::property & property) const
846//{
847//
848// string_base < TYPE_CHAR > ansistr(*this);
849//
850// ansistr += property;
851//
852// return ansistr;
853//
854//}
855
856
858//inline payload payload::operator +(const ::payload & payload) const
859//{
860//
861// return ::transfer(addition(payload));
862//
863//}
864
865
866//template < prototype_payload PAYLOAD >
867inline payload payload::operator -(const ::payload & payload) const
868{
869
870 return ::transfer(subtraction(payload));
871
872}
873
874
875//template < prototype_payload PAYLOAD >
876inline payload payload::operator *(const payload & payload) const
877
878{
879
880 return ::transfer(multiplication(payload));
881
882}
883
885inline payload payload:: operator /(const ::payload & payload) const
886{
887
888 return ::transfer(division(payload));
889
890}
891
892
894//inline payload & payload::operator +=(const ::payload & payload)
895//{
896//
897// return add(payload);
898//
899//}
900
901
902inline payload & payload::operator -=(const ::payload & payload)
903{
904
905 return subtract(payload);
906
907}
908
909
910//template < prototype_payload PAYLOAD >
911inline payload & payload::operator *=(const ::payload & payload)
912{
913
914 return multiply(payload);
915
916}
917
918
919//template < prototype_payload PAYLOAD >
920inline payload & payload::operator /=(const ::payload & payload)
921{
922
923 return divide(payload);
924
925}
926
927
928template < typename CHAR_TYPE >
929inline ::string_base < CHAR_TYPE > & copy(::string_base < CHAR_TYPE > & string, const ::payload & payload)
930{
931
932 string = payload.as_string();
933
934 return string;
935
936}
937
938
939template < prototype_integral INTEGRAL >
940inline INTEGRAL & copy(INTEGRAL & integral, const ::payload & payload)
941{
942
943 return integral = payload.as(integral);
944
945}
946
947
948inline ::f32 & copy(::f32 & f, const ::payload & payload)
949{
950
951 return f = payload.as_f32();
952
953}
954
955
956inline ::f64 & copy(::f64 & f, const ::payload & payload)
957{
958
959 return f = payload.as_f64();
960
961}
962
963
964template < prototype_number NUMBER >
965inline ::payload & copy(::payload & payload, const NUMBER & number)
966{
967
968 return payload = number;
969
970}
971
972
973template < typename CHAR_TYPE >
974inline ::payload & copy(::payload & payload, const ::string_base < CHAR_TYPE > & string)
975{
976
977 return payload = string;
978
979}
980
981
982inline ::payload & copy(::payload & payload1, const ::payload & payload2)
983{
984
985 return payload1 = payload2;
986
987}
988
989
990//inline ::string operator +(const ::scoped_string & scopedstr, const ::payload & payload)
991//{
992//
993// return ::transfer(str + payload.as_string());
994//
995//}
996
997
998//inline ::string operator +(const ::scoped_string & scopedstr, const ::payload & payload)
999//{
1000//
1001// return ::string(scopedstr) + ::string(payload);
1002//
1003//}
1004
1005
1006//template < prototype_character CHARACTER >
1007//inline ::string_base < CHARACTER > & operator +=(::string_base < CHARACTER > & str, const ::payload & payload)
1008//{
1009//
1010// return str.operator += ((::string) payload);
1011//
1012//}
1013//
1014//
1015//template < ::collection::count c >
1016//inline ::string operator +(const ::i8(&sz)[c], const ::payload & payload)
1017//{
1018//
1019// return ::transfer(::string(sz) + payload);
1020//
1021//}
1022//
1023//
1024//inline ::file::path operator + (const ::file::path & path, const ::payload& payload)
1025//{
1026//
1027// return path + payload.as_file_path();
1028//
1029//}
1030
1031
1032//inline ::file::path operator / (const ::file::path& path, const ::payload& payload)
1033//{
1034//
1035// return path / payload.file_path();
1036//
1037//}
1038
1039
1040//inline ::file::path & operator += (::file::path& path, const ::payload& payload)
1041//{
1042//
1043// return path += payload.file_path();
1044//
1045//}
1046
1047
1048//inline ::file::path & operator /= ( ::file::path& path, const ::payload& payload)
1049//{
1050//
1051// return path /= payload.file_path();
1052//
1053//}
1054
1055
1056//template < typename ITERATOR_TYPE >
1057//inline string_base < ITERATOR_TYPE >::string_base(const ::payload & payload) :
1058// string(payload.as_string())
1059//{
1060//
1061//
1062//}
1063
1064
1065//template < typename ITERATOR_TYPE >
1066//inline string_base < ITERATOR_TYPE > & string_base < ITERATOR_TYPE >::operator = (const ::payload & payload)
1067//{
1068//
1069// assign_range(payload.as_string());
1070//
1071// return *this;
1072//
1073//}
1074
1075
1076// template < typename ITERATOR_TYPE >
1077// string_base < ITERATOR_TYPE > & string_base < ITERATOR_TYPE >::operator += (const ::payload & payload)
1078// {
1079//
1080// return append(payload);
1081//
1082// }
1083
1084
1085template < typename ITERATOR_TYPE >
1086string_base < ITERATOR_TYPE > & string_base < ITERATOR_TYPE >::append(const ::payload & payload)
1087{
1088
1089 if (payload.m_etype == e_type_string)
1090 {
1091
1092 return append(payload.m_str);
1093
1094 }
1095 else
1096 {
1097
1098 return append(payload.as_string());
1099
1100 }
1101
1102}
1103
1104
1105namespace file
1106{
1107
1108
1109 inline path::path(const ::payload & payload) :
1110 path(payload.as_file_path())
1111 {
1112
1113 }
1114
1115
1116} // namespace file
1117
1118
1119
1120
1121
1122
1123//template < typename ITERATOR_TYPE >
1124//inline scoped_string_base < ITERATOR_TYPE >::scoped_string_base(const ::payload & payload) :
1125// m_str(no_initialize_t{}), RANGE(no_initialize_t{})
1126//{
1127//
1128// m_str = payload.as_string();
1129//
1130// RANGE::operator = (m_str);
1131//
1132//}
1133
1134
1135//template < >
1136//inline scoped_string_base < const_char_pointer >::scoped_string_base(const ::payload & payload) :
1137// m_str(no_initialize_t{}), RANGE(no_initialize_t{})
1138//{
1139//
1140// if (payload.has_string_reference())
1141// {
1142//
1143// BASE_RANGE::operator = (payload.string_reference());
1144//
1145// }
1146// else
1147// {
1148//
1149// m_str = payload.as_string();
1150//
1151// BASE_RANGE::operator = (m_str);
1152//
1153// }
1154//
1155//}
1156
1157
1158
1159//template < prototype_character_range RANGE, prototype_payload PAYLOAD >
1160//::string operator + (const RANGE & range, const PAYLOAD & payload)
1161//{
1162//
1163// string str(range);
1164//
1165// str.append(payload.get_string());
1166//
1167// return str;
1168//
1169//}
1170
1171
1172
1173
1174
1175
1176template < typename PRIMITIVE >
1177payload& payload::__assign_primitive(PRIMITIVE& member, enum_type etype, PRIMITIVE prototype)
1178{
1179
1180 if (__assign_to_held_pointer_member(prototype))
1181 {
1182
1183
1184 }
1185 //else if (get_type() == e_type_payload_pointer)
1186 //{
1187
1188 // *m_ppayload = prototype;
1189
1190 //}
1191 //else if (get_type() == e_type_property)
1192 //{
1193
1194 // m_pproperty->object() = prototype;
1195
1196 //}
1197 else
1198 {
1199
1200 set_type(etype, false);
1201
1202 member = prototype;
1203
1204 }
1205
1206 return *this;
1207
1208}
1209
1210
1211
file::path
Definition path.h:52
payload_cast
Definition __payload_cast.h:13
payload_object
Definition _impl_payload.h:215
payload
Definition payload.h:54
payload::operator/
payload operator/(const ::payload &payload) const
template < prototype_payload PAYLOAD >
Definition _impl_payload.h:885
time
Definition aaa_time.h:13
file
Definition filesystem.h:16
block
Definition block.h:46