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