acme
Foundational cross-platform layer of the ca2 framework
Loading...
Searching...
No Matches
_impl_pointer.h
1//
2// Created by camilo on 23/12/2022 01:30 <3ThomasBorregaardSorensen!!
3//
4#pragma once
5
6
7#include "acme/include/_forward_declaration.h"
8
9#include "acme/platform/platform.h"
10
11
12#if REFERENCING_DEBUGGING
13#include "acme/platform/reference_item.h"
14#include "acme/platform/reference_item_array.h"
15CLASS_DECL_ACME::critical_section * refdbg_cs();
16#endif
17
18
19// ::ca::null_class back link to operational system oswindow.h
20// operational system nullptr/void itself to a windowing service
21//
22// Curitiba, inha-metro-win-ubuntu-mountain-lion-macos 4 de novembro de 2012
23template < class T >
24inline pointer < T > ::pointer() :
25 m_p(nullptr),
26 m_psubparticle(nullptr)
27#if REFERENCING_DEBUGGING
28,m_preferer(nullptr)
29#endif
30{
31
32}
33
34
35template < class T >
36inline pointer < T > ::pointer(nullptr_t):
37 m_p(nullptr),
38 m_psubparticle(nullptr)
39#if REFERENCING_DEBUGGING
40,m_preferer(nullptr)
41#endif
42{
43
44}
45
46
47template < class T >
48template < typename T2 >
49inline pointer < T > ::pointer(place_t, T2 * p)
50{
51
52#if REFERENCING_DEBUGGING
53
54 critical_section_lock criticalsectionlock(refdbg_cs());
55
56#endif
57
58 if(::is_set(p))
59 {
60
61 auto pNew = dynamic_cast < T * > (p);
62
63 if(::is_null(pNew))
64 {
65
66 ::release(p);
67
68 m_p = nullptr;
69
70 m_psubparticle = nullptr;
71
72 throw_resource_exception("OBJECT * p is not of type T (pointer < T >).");
73
74 }
75 else
76 {
77
78 m_p = pNew;
79
80 m_psubparticle = m_p;
81
82#if REFERENCING_DEBUGGING
83
84 if (m_psubparticle->is_referencing_debugging_enabled())
85 {
86
87 if(m_psubparticle->m_prefererTransfer2)
88 {
89
90 m_preferer = m_psubparticle->m_prefererTransfer2;
91
92 m_psubparticle->m_prefererTransfer2 = nullptr;
93
94 }
95 else if(m_psubparticle->m_prefererLast2)
96 {
97
98 m_preferer = m_psubparticle->m_prefererLast2;
99
100 m_psubparticle->m_prefererLast2 = nullptr;
101
102 }
103 else
104 {
105
106 m_preferer = ::allocator::defer_push_referer(pNew, { this, __FUNCTION_FILE_LINE__ });
107
108 }
109
110 }
111 else
112 {
113
114 ::allocator::defer_erase_referer(pNew);
115
116 }
117
118#endif
119
120 }
121
122 }
123 else
124 {
125
126 m_p = nullptr;
127
128 m_psubparticle = nullptr;
129
130#if REFERENCING_DEBUGGING
131
132 m_preferer = nullptr;
133
134#endif
135
136
137 }
138
139}
140
141
142template < class T >
143template < typename ...Args >
144pointer < T >::pointer(allocate_t, Args &&... args)
145{
146
147 auto p = ___new T (::std::forward<Args>(args)...);
148
149//#if REFERENCING_DEBUGGING
150//
151// task_on_after_new_particle(p);
152//
153//#endif
154
155 m_p = dynamic_cast <T *> (p);
156
157 m_psubparticle = m_p;
158
159 if (::is_null(m_p))
160 {
161
162 ::release(p);
163
164 m_p = nullptr;
165
166 m_psubparticle = nullptr;
167
168 throw_resource_exception("OBJECT * p is not of type T (pointer < T >).");
169
170 }
171 else
172 {
173
174#if REFERENCING_DEBUGGING
175
176 if (m_psubparticle->is_referencing_debugging_enabled())
177 {
178
179 if(m_psubparticle->m_prefererTransfer2)
180 {
181
182 m_preferer = m_psubparticle->m_prefererTransfer2;
183
184 m_psubparticle->m_prefererTransfer2 = nullptr;
185
186 }
187 else if(m_psubparticle->m_prefererLast2)
188 {
189
190 m_preferer = m_psubparticle->m_prefererLast2;
191
192 m_psubparticle->m_prefererLast2 = nullptr;
193
194 }
195 else
196 {
197
198 m_preferer = ::allocator::defer_push_referer(m_p, { this, __FUNCTION_FILE_LINE__ });
199
200 }
201
202 }
203 else
204 {
205
206 ::allocator::defer_erase_referer(m_p);
207
208 }
209
210#endif
211
212 }
213
214}
215
216
217template < class T >
218inline pointer < T > ::pointer(const pointer & t)
219{
220
221#if REFERENCING_DEBUGGING
222
223 critical_section_lock criticalsectionlock(refdbg_cs());
224
225#endif
226
227 auto pNew = t.m_psubparticle;
228
229 if (::is_null(pNew))
230 {
231
232 m_p = nullptr;
233
234 m_psubparticle = nullptr;
235
236#if REFERENCING_DEBUGGING
237
238 m_preferer = nullptr;
239
240#endif
241
242 }
243 else
244 {
245
246#if REFERENCING_DEBUGGING
247
248 ::reference_referer * prefererNew = nullptr;
249
250 if(pNew->is_referencing_debugging_enabled())
251 {
252
253 //::allocator::defer_push_referer(pNew, { pNew, this, __FUNCTION_FILE_LINE__ });
254 prefererNew = ::allocator::defer_push_referer(pNew, { this, __FUNCTION_FILE_LINE__ });
255
256 }
257 else
258 {
259
260 ::allocator::defer_erase_referer(pNew);
261
262 }
263
264#endif
265
266 pNew->increment_reference_count();
267
268 m_psubparticle = pNew;
269
270 m_p = t.m_p;
271
272#if REFERENCING_DEBUGGING
273
274 m_preferer = prefererNew;
275
276#endif
277
278 }
279
280}
281
282
283template < class T >
284inline pointer < T > ::pointer(pointer && t) :
285m_p(t.m_p),
286m_psubparticle(t.m_psubparticle),
287m_estatus(t.m_estatus)
288#if REFERENCING_DEBUGGING
289
290,m_preferer(t.m_preferer)
291#endif
292{
293
294t.m_p = nullptr;
295
296t.m_psubparticle = nullptr;
297#if REFERENCING_DEBUGGING
298
299t.m_preferer = nullptr;
300#endif
301}
302
303
304
305//template < class T >
306//template < typename T2 >
307//inline pointer < T > ::pointer(const T2 * p) :
308// m_p((T *) p),
309// m_psubparticle(m_p)
310//{
311//
312// ::increment_reference_count(m_p);
313//
314//}
315
316
317
318template < class T >
319inline pointer < T > ::~pointer()
320{
321
322 release();
323
324}
325
326
327//template < class T >
328//inline T * pointer < T > ::operator ->()
329//{
330//
331// return is_null() ? nullptr : m_p;
332//
333//}
334//
335//
336//template < class T >
337//inline T * pointer < T > ::operator ->() const
338//{
339//
340// return is_null() ? nullptr : m_p;
341//
342//}
343
344
345//template < class T >
346//inline T & pointer < T > ::operator * ()
347//{
348//
349// return *m_p;
350//
351//}
352//
353//
354//template < class T >
355//inline T & pointer < T > ::operator * () const
356//{
357//
358// return *m_p;
359//
360//}
361//
362//
363//template < class T >
364//inline pointer < T > ::operator T * ()
365//{
366//
367// return is_null() ? nullptr : m_p;
368//
369//}
370//
371//
372//template < class T >
373//inline pointer < T > ::operator T * const () const
374//{
375//
376// return is_null() ? nullptr : m_p;
377//
378//}
379//
380//
381//template < class T >
382//inline T * pointer < T > ::get()
383//{
384//
385// return is_null() ? nullptr : m_p;
386//
387//}
388//
389//
390//template < class T >
391//inline const T * pointer < T > ::get() const
392//{
393//
394// return is_null() ? nullptr : m_p;
395//
396//}
397
398
399template < class T >
400inline bool pointer < T > ::is_set() const
401{
402
403 return !!m_p && !!m_psubparticle;
404
405}
406
407
408template < class T >
409inline bool pointer < T > ::is_null() const
410{
411
412 return !this->is_set();
413
414}
415
416
417
418
419template < class T >
420inline bool pointer < T > ::ok() const
421{
422
423 return ::is_set(m_p) && ::is_set(m_psubparticle) && m_psubparticle->_is_ok();
424
425}
426
427
428template < class T >
429inline bool pointer < T > ::nok() const
430{
431
432 return !this->ok();
433
434}
435
436
437template < class T >
438T* __dynamic_cast(const T* p)
439{
440
441 return (T*)p;
442
443}
444
445template < class T, typename T2 >
446T * __dynamic_cast(const T2 * p)
447{
448 return dynamic_cast <T*>((T2*)p);
449}
450
451
452
453//template < class T >
454//inline pointer < T >& pointer < T > ::reset(T * p)
455//{
456//
457// if (::is_null(p))
458// {
459//
460// release();
461//
462// }
463// else if(m_p != p)
464// {
465//
466// auto pparticleOld = m_psubparticle;
467//
468// p->increment_reference_count();
469//
470// m_p = p;
471//
472// m_psubparticle = p;
473//
474// if (::is_set(pparticleOld))
475// {
476//
477// ::release(pparticleOld);
478//
479// }
480//
481// }
482//
483// return *this;
484//
485//}
486
487
488template < class T >
489template < typename T2 >
490inline pointer < T > & pointer < T > ::reset (T2 * p)
491{
492
493 if (::is_null(p))
494 {
495
496 release();
497
498 }
499 else
500 {
501
502 auto pNew = dynamic_cast < T * >((non_const < T2 > *) p);
503
504 if (m_p == pNew)
505 {
506
507#if REFERENCING_DEBUGGING
508
509 ::allocator::defer_erase_referer(pNew);
510
511#endif
512
513 }
514 else
515 {
516
517 ::subparticle * pOld = nullptr;
518
519#if REFERENCING_DEBUGGING
520
521 ::reference_referer * prefererOld = nullptr;
522
523#endif
524
525 {
526
527#if REFERENCING_DEBUGGING
528
529 critical_section_lock criticalsectionlock(refdbg_cs());
530
531 prefererOld = m_preferer;
532
533#endif
534
535 pOld = m_p;
536
537 if (::is_set(pNew))
538 {
539
540#if REFERENCING_DEBUGGING
541
542 ::reference_referer * prefererNew = nullptr;
543
544 if (pNew->is_referencing_debugging_enabled())
545 {
546
547 //prefererNew = ::allocator::defer_push_referer(pNew, { pNew, this, __FUNCTION_FILE_LINE__ });
548
549 prefererNew = ::allocator::defer_push_referer(pNew, { this, __FUNCTION_FILE_LINE__ });
550
551 }
552 else
553 {
554
555 ::allocator::defer_erase_referer(pNew);
556
557 }
558
559#endif
560
561 pNew->increment_reference_count();
562
563 m_p = pNew;
564
565 m_psubparticle = pNew;
566
567#if REFERENCING_DEBUGGING
568
569 m_preferer = prefererNew;
570
571#endif
572
573 }
574 else
575 {
576
577 m_p = nullptr;
578
579 m_psubparticle = nullptr;
580
581#if REFERENCING_DEBUGGING
582
583 m_preferer = nullptr;
584
585#endif
586
587 }
588
589 }
590
591 if (::is_set(pOld))
592 {
593
594#if REFERENCING_DEBUGGING
595
596 if (pOld->is_referencing_debugging_enabled())
597 {
598
599 ::allocator::add_releaser(prefererOld);
600
601 }
602
603#endif
604
605 ::release(pOld);
606
607 }
608
609 }
610
611 }
612
613 return *this;
614
615}
616
617
618template < class T >
619template < typename T2 >
620inline pointer < T > & pointer < T > ::transfer(T2 * p)
621{
622
623 if (::is_null(p))
624 {
625
626 release();
627
628 }
629 else
630 {
631
632 auto pNew = dynamic_cast <T *>((non_const < T2 > *) p);
633
634 ::subparticle * pOld = nullptr;
635
636#if REFERENCING_DEBUGGING
637
638 ::reference_referer * prefererOld = nullptr;
639
640#endif
641
642 if (m_p != pNew)
643 {
644
645 {
646
647#if REFERENCING_DEBUGGING
648
649 critical_section_lock criticalsectionlock(refdbg_cs());
650
651#endif
652
653 pOld = m_p;
654
655#if REFERENCING_DEBUGGING
656
657 prefererOld = m_preferer;
658
659#endif
660
661 if (::is_set(pNew))
662 {
663
664#if REFERENCING_DEBUGGING
665
666 ::reference_referer * prefererNew = nullptr;
667
668 if (pNew->is_referencing_debugging_enabled())
669 {
670
671 if(pNew->m_prefererTransfer)
672 {
673
674 ::allocator::_push_referer(pNew->m_prefererTransfer);
675
676 }
677
678 prefererNew = ::allocator::defer_push_referer(pNew, { pNew, this, __FUNCTION_FILE_LINE__ });
679
680 }
681 else
682 {
683
684 ::allocator::defer_erase_referer(pNew);
685
686 }
687
688#endif
689
690 //pNew->increment_reference_count();
691
692 m_p = pNew;
693
694 m_psubparticle = pNew;
695
696#if REFERENCING_DEBUGGING
697
698 m_preferer = prefererNew;
699
700#endif
701
702 }
703 else
704 {
705
706 m_p = nullptr;
707
708 m_psubparticle = nullptr;
709
710#if REFERENCING_DEBUGGING
711
712 m_preferer = nullptr;
713
714#endif
715
716 }
717
718 }
719
720 if (::is_set(pOld))
721 {
722
723#if REFERENCING_DEBUGGING
724
725 if (pOld->is_referencing_debugging_enabled())
726 {
727
728 ::allocator::add_releaser(prefererOld);
729
730 }
731
732#endif
733
734 ::release(pOld);
735
736 }
737
738 }
739
740 }
741
742 return *this;
743
744}
745
746
747template < class T >
748inline pointer < T > & pointer < T > ::operator = (const pointer & t)
749{
750
751 if (m_p != t.m_p)
752 {
753
754 ::subparticle * pOld = nullptr;
755
756#if REFERENCING_DEBUGGING
757
758 ::reference_referer * prefererOld = nullptr;
759
760#endif
761
762 {
763
764#if REFERENCING_DEBUGGING
765
766 critical_section_lock criticalsectionlock(refdbg_cs());
767
768 prefererOld = m_preferer;
769
770#endif
771
772 pOld = m_psubparticle;
773
774 auto pNew = t.m_psubparticle;
775
776 if (::is_null(pNew))
777 {
778
779 m_p = nullptr;
780
781 m_psubparticle = nullptr;
782
783#if REFERENCING_DEBUGGING
784
785 m_preferer = nullptr;
786
787#endif
788
789 }
790 else
791 {
792
793#if REFERENCING_DEBUGGING
794
795 ::reference_referer * prefererNew = nullptr;
796
797 if (pNew->is_referencing_debugging_enabled())
798 {
799
800 //prefererNew = ::allocator::defer_push_referer(pNew, { pNew, this, __FUNCTION_FILE_LINE__ });
801
802 prefererNew = ::allocator::defer_push_referer(pNew, { this, __FUNCTION_FILE_LINE__ });
803
804 }
805 else
806 {
807
808 ::allocator::defer_erase_referer(pNew);
809
810 }
811
812#endif
813
814 pNew->increment_reference_count();
815
816 m_p = t.m_p;
817
818 m_psubparticle = pNew;
819
820#if REFERENCING_DEBUGGING
821
822 m_preferer = prefererNew;
823
824#endif
825
826 }
827
828 }
829
830 if (::is_set(pOld))
831 {
832
833#if REFERENCING_DEBUGGING
834
835 if (pOld->is_referencing_debugging_enabled())
836 {
837
838 ::allocator::add_releaser(prefererOld);
839
840 }
841
842#endif
843
844 ::release(pOld);
845
846 }
847
848 }
849
850 return *this;
851
852}
853
854
855template < class T >
856inline pointer < T > & pointer < T > ::operator = (pointer && t)
857{
858
859 if(m_p != t.m_p)
860 {
861
862 ::subparticle * pOld = nullptr;
863
864#if REFERENCING_DEBUGGING
865
866 ::reference_referer * prefererOld = nullptr;
867
868#endif
869
870 {
871
872#if REFERENCING_DEBUGGING
873
874 critical_section_lock criticalsectionlock(refdbg_cs());
875
876 prefererOld = m_preferer;
877
878#endif
879
880 pOld = m_psubparticle;
881
882 m_p = t.m_p;
883
884 m_psubparticle = t.m_psubparticle;
885
886#if REFERENCING_DEBUGGING
887
888 m_preferer = t.m_preferer;
889
890#endif
891
892 t.m_p = nullptr;
893
894 t.m_psubparticle = nullptr;
895
896#if REFERENCING_DEBUGGING
897
898 t.m_preferer = nullptr;
899
900#endif
901
902 }
903
904 if (::is_set(pOld))
905 {
906
907#if REFERENCING_DEBUGGING
908
909 if (pOld->is_referencing_debugging_enabled())
910 {
911
912 ::allocator::add_releaser(prefererOld);
913
914 }
915
916#endif
917
918 ::release(pOld);
919
920 }
921
922 }
923
924 return *this;
925
926}
927
928
929template < class T >
930template < typename T2 >
931inline ::pointer < T2 > pointer < T > ::defer_get_new(::particle* pparticle)
932{
933
934 if (this->is_null())
935 {
936
937 REFDBG_THIS(pparticle);
938
939 auto pNew = pparticle->create_newø < T2 >();
940
941 this->operator = (pNew);
942
943 }
944
945 return m_p;
946
947}
948
949
950//template < class T >
951//inline T * pointer < T > ::detach()
952//{
953//
954// auto p = m_p;
955//
956// m_p = nullptr;
957//
958// m_psubparticle = nullptr;
959//
960// m_preferer = nullptr;
961//
962// return p;
963//
964//}
965//
966//
967//template < class T >
968//inline ::subparticle * pointer < T > ::detach_particle()
969//{
970//
971// auto p = m_psubparticle;
972//
973// m_p = nullptr;
974//
975// m_psubparticle = nullptr;
976//
977// m_preferer = nullptr;
978//
979// return p;
980//
981//}
982
983
984// cut and paste with very good capabilities of RealVNC for MacOS in OVH.fr/eu/pt cloud from Windows client.
985// slashes with ABNT 2 keyboard and even c cedilha working with RealVNC
986template < class T >
987inline ::i64 pointer <T>::release()
988{
989
990 ::subparticle * pparticle = nullptr;
991
992 ::collection::count c = -1;
993
994 {
995
996#if REFERENCING_DEBUGGING
997
998 critical_section_lock criticalsectionlock(refdbg_cs());
999
1000#endif
1001
1002 //ASSERT(referer == m_referer);
1003
1004 //return ::release(m_psubparticle);
1005
1006#if REFERENCING_DEBUGGING
1007
1008 ::collection::index iSerial = -1;
1009
1010#endif
1011
1012 {
1013
1014 pparticle = m_psubparticle;
1015
1016#if REFERENCING_DEBUGGING
1017
1018 auto preferer = m_preferer;
1019
1020#endif
1021
1022 if (::is_null(m_p))
1023 {
1024
1025 return -1;
1026
1027 }
1028
1029 m_p = nullptr;
1030
1031 m_psubparticle = nullptr;
1032
1033#if REFERENCING_DEBUGGING
1034
1035 m_preferer = nullptr;
1036
1037 ::allocator::add_releaser(preferer);
1038
1039 if (::is_set(preferer))
1040 {
1041
1042 iSerial = preferer->m_iSerial;
1043
1044 }
1045#endif
1046 try
1047 {
1048
1049 c = pparticle->decrement_reference_count();
1050
1051 }
1052 catch (...)
1053 {
1054
1055 informationf("exception release pparticle->release() \n");
1056
1057 }
1058#if REFERENCING_DEBUGGING
1059
1060 if (::allocator::get_releaser() == preferer && preferer)
1061 {
1062
1063 ::output_debug_string("releaser stacked but not consumed");
1064
1065 }
1066#endif
1067 }
1068
1069 }
1070
1071 if (c == 0)
1072 {
1073
1074 try
1075 {
1076
1077 pparticle->delete_this();
1078
1079 }
1080 catch (...)
1081 {
1082
1083 }
1084
1085 }
1086 //if (preferer)
1087 //{
1088
1089 // ::output_debug_string("releaser stacked");
1090
1092
1093 //auto i = ::release(m_psubparticle);
1094
1095 //if (::allocator::get_releaser() == preferer && preferer)
1096 //{
1097
1098 // ::output_debug_string("releaser stacked but not consumed");
1099
1100 //}
1101
1102 return c;
1103
1104}
1105
1106
1107//template < class T >
1108//inline ::i64 pointer <T>::global_release()
1109//{
1110//
1111// //ASSERT(referer == m_referer);
1112//
1113// auto i = ::global_release(m_psubparticle);
1114//
1115// if (!m_psubparticle)
1116// {
1117//
1118// m_p = nullptr;
1119//
1120// m_preferer = nullptr;
1121//
1122// }
1123//
1124// return i;
1125//
1126//}
1127
1128
1129template < class T1, class T2 >
1130inline bool operator ==(const T1 * t1, const ::pointer<T2>& t2)
1131{
1132 auto p1 = dynamic_cast < T1 * > (t2.m_p);
1133 if(p1 != nullptr)
1134 {
1135 return p1 == t1;
1136 }
1137 auto p2 = dynamic_cast < T2 * > ((T1 *) t1);
1138 if(p2 != nullptr)
1139 {
1140 return p2 == t2.m_p;
1141 }
1142 return false;
1143}
1144
1145
1146template < class T1, class T2 >
1147inline bool operator ==(const ::pointer<T1>& t1, const T2 * t2)
1148{
1149 auto p1 = dynamic_cast < T1 * > ((T2 *) t2);
1150 if(p1 != nullptr)
1151 {
1152 return p1 == t1.m_p;
1153 }
1154 auto p2 = dynamic_cast < T2 * > (t1.m_p);
1155 if(p2 != nullptr)
1156 {
1157 return p2 == t2;
1158 }
1159 return false;
1160}
1161
1162
1163template < typename T >
1164inline bool operator ==(const ::pointer<T>& t1, const ::pointer<T> & t2)
1165{
1166 return t1.m_p == t2.m_p;
1167}
1168
1169
1170template < class T1, class T2 >
1171inline bool operator ==(const ::pointer<T1>& t1, const ::pointer<T2> & t2)
1172{
1173 auto p1 = dynamic_cast < T1 * > (t2.m_p);
1174 if(p1 != nullptr)
1175 {
1176 return p1 == t1.m_p;
1177 }
1178 auto p2 = dynamic_cast < T2 * > (t1.m_p);
1179 if(p2 != nullptr)
1180 {
1181 return p2 == t2.m_p;
1182 }
1183 return false;
1184}
1185
1186
1187template < class T1, class T2 >
1188inline bool operator ==(T1 * t1, const ::pointer<T2>& t2)
1189{
1190
1191 return operator == ((const T1 *) t1, t2);
1192
1193}
1194
1195
1196template < class T1, class T2 >
1197inline bool operator ==(const ::pointer<T1>& t1, T2 * t2)
1198{
1199
1200 return operator == (t1, (const T2 *) t2);
1201
1202}
1203
1204
1205//template < class T1, class T2 >
1206//inline bool operator !=(const T1 * t1, const ::pointer<T2>& t2)
1207//{
1208//
1209// return !operator == (t1, t2);
1210//
1211//}
1212//
1213//
1214//template < class T1, class T2 >
1215//inline bool operator !=(const ::pointer<T1>& t1, const T2 * t2)
1216//{
1217//
1218// return !operator == (t1, t2);
1219//
1220//}
1221//
1222//
1223//template < class T1, class T2 >
1224//inline bool operator !=(T1 * t1, const ::pointer<T2>& t2)
1225//{
1226//
1227// return !operator == ((const T1 *) t1, t2);
1228//
1229//}
1230//
1231//
1232//template < class T1, class T2 >
1233//inline bool operator !=(const ::pointer<T1>& t1, T2 * t2)
1234//{
1235// return !operator == (t1, (const T2 *) t2);
1236//}
1237//
1238//
1239//template < class T1, class T2 >
1240//inline bool operator !=(const ::pointer<T1>& t1, const ::pointer<T2> t2)
1241//{
1242//
1243// return !operator == (t1, t2);
1244//
1245//}
1246//
1247//
1248
1249
1250//template < typename TYPE >
1252//{
1253//
1254// return p.is_set();
1255//
1256//}
1257
1258
1259//template<typename TYPE>
1260//inline bool is_null(const ::pointer<TYPE>& p)
1261//{
1262//
1263// return ::is_null(p.m_p);
1264//
1265//}
1266
1267
1268//template < typename TYPE >
1269//inline ::pointer<TYPE>clone(const ::pointer<TYPE> & p)
1270//{
1271//
1272// if (!p)
1273// {
1274//
1275// return p;
1276//
1277// }
1278//
1279// auto pelement = p->clone();
1280//
1281// if(__pointer_is_null(pelement))
1282// {
1283//
1284// throw_exception(error_failed);
1285//
1286// }
1287//
1288// auto pNew = dynamic_cast < TYPE * > (pelement);
1289//
1290// if(__pointer_is_null(pNew))
1291// {
1292//
1293// throw_exception(error_wrong_type);
1294//
1295// }
1296//
1297// return ::pointer_transfer(pNew);
1298//
1299//}
1300
1301
1302//template < typename TYPE >
1303//inline ::pointer<TYPE>& clone(::pointer<TYPE> & p)
1304//{
1305//
1306// return p = ::clone((const ::pointer<TYPE>&) p);
1307//
1308//}
1309
1310
1311template < typename TYPE >
1312inline ::pointer<TYPE>& defer_clone(::pointer<TYPE> & p)
1313{
1314
1315 if (!p || p->reference_count() <= 1)
1316 {
1317
1318 return p;
1319
1320 }
1321
1322 return p = ::clone(p);
1323
1324}
1325
1326
1327template < typename TYPE >
1328pointer < TYPE > clone(TYPE * p)
1329{
1330
1331 if(__pointer_is_null(p))
1332 {
1333
1334 throw_exception(error_null_pointer);
1335
1336 }
1337
1338 auto pelement = p->clone();
1339
1340 auto pNew = dynamic_cast < TYPE * > (pelement);
1341
1342 if(__pointer_is_null(pNew))
1343 {
1344
1345 throw_exception(error_wrong_type);
1346
1347 }
1348
1349 return ::pointer_transfer(pNew);
1350
1351}
1352
1353
1354#include "acme/platform/lparam.h"
1355
1356
1357template < class T >
1358inline pointer < T >::pointer(lparam & lparam)
1359{
1360
1361 m_psubparticle = (::subparticle *)(::iptr)lparam.m_lparam;
1362
1363 m_p = dynamic_cast <T *>(m_psubparticle);
1364
1365#if REFERENCING_DEBUGGING
1366
1367 m_preferer = m_psubparticle->m_prefererTransfer2;
1368
1369 m_psubparticle->m_prefererTransfer2 = nullptr;
1370
1371#endif
1372
1373 if(::is_null(m_p) && ::is_set(m_psubparticle))
1374 {
1375
1376#if REFERENCING_DEBUGGING
1377
1378 if (::is_set(m_preferer))
1379 {
1380
1381 ::allocator::add_releaser(m_preferer);
1382
1383 m_preferer = nullptr;
1384
1385 }
1386
1387#endif
1388
1389 ::release(m_psubparticle);
1390
1391 }
1392
1393 lparam.m_lparam = 0;
1394
1395}
1396
1397
1398#include "acme/platform/wparam.h"
1399
1400
1401template<class T>
1402inline pointer<T>::pointer(wparam & wparam)
1403{
1404
1405 m_psubparticle = (::subparticle *)(::iptr)wparam.m_wparam;
1406
1407 m_p = dynamic_cast<T *>(m_psubparticle);
1408
1409#if REFERENCING_DEBUGGING
1410
1411 m_preferer = m_psubparticle->m_prefererTransfer2;
1412
1413 m_psubparticle->m_prefererTransfer2 = nullptr;
1414
1415#endif
1416
1417 if (::is_null(m_p) && ::is_set(m_psubparticle))
1418 {
1419
1420#if REFERENCING_DEBUGGING
1421
1422 if (::is_set(m_preferer))
1423 {
1424
1425 ::allocator::add_releaser(m_preferer);
1426
1427 m_preferer = nullptr;
1428 }
1429
1430#endif
1431
1432 ::release(m_psubparticle);
1433
1434 }
1435
1436 wparam.m_wparam = 0;
1437
1438}
1439
1440
1441template < class c_derived >
1442inline ::i64 increment_reference_count(c_derived * pca)
1443{
1444
1445 if (::is_null(pca))
1446 {
1447
1448 return -1;
1449
1450 }
1451
1452 return pca->increment_reference_count();
1453
1454}
1455
1456
1457template < class c_derived, typename SOURCE >
1458inline ::i64 increment_reference_count(c_derived * & pca, const SOURCE * psource)
1459{
1460
1461 c_derived * pderived = dynamic_cast <c_derived *>((SOURCE *)psource);
1462
1463 if (::is_null(pderived))
1464 {
1465
1466 throw_exception(error_wrong_type);
1467
1468 }
1469
1470 pca = pderived;
1471
1472 return increment_reference_count(pca);
1473
1474}
1475
1476
1477template < class c_derived, typename SOURCE >
1478inline ::i64 increment_reference_count(c_derived *& pderived, const ::pointer<SOURCE>& psource)
1479{
1480
1481 return increment_reference_count(pderived, psource.m_p);
1482
1483}
1484
1485
1486
1487template < typename TYPE >
1488inline ::i64 release(::pointer<TYPE>& pointer)
1489//inline ::i64 release(::pointer<TYPE>& pointer COMMA_REFERENCING_DEBUGGING_RELEASER_PARAMETERS_DEFINITION)
1490{
1491
1492 return release(pointer.m_p);
1493
1494}
1495
1496
1497template < typename TYPE >
1498inline ::i64 __finalize(::pointer<TYPE> pointer)
1499{
1500
1501if (!pointer) return -1;
1502
1503pointer->destroy();
1504
1505return release(pointer.m_p);
1506
1507}
1508
1509//
1510//template < class REFERENCE >
1511//inline ::i64 release(::pointer<REFERENCE>& preference)
1512//{
1513//
1514// return release(preference.m_p);
1515//
1516//}
1517
1518
1519template < class c_derived >
1520inline ::i64 ref_count(c_derived * pca)
1521{
1522
1523 if (pca == nullptr)
1524 {
1525
1526 return -1;
1527
1528 }
1529
1530 return pca->get_ref_count();
1531
1532}
1533
1534
1535//class CLASS_DECL_ACME global_particle :
1536// virtual public ::subparticle
1537//{
1538//public:
1539//
1540//
1541// global_particle * m_pglobalparticleNext;
1542//
1543// global_particle();
1544// ~global_particle() override;
1545//
1546//
1547//};
1548
1549
1550//template < typename TYPE >
1551//class global_pointer :
1552// public ::global_particle,
1553// public pointer <TYPE >
1554//{
1555//public:
1556//
1557//
1558// using pointer < TYPE >::pointer;
1559//
1560//
1561// using pointer < TYPE >::operator = ;
1562//
1563//};
1564
1565
1566
1567
1568
1569template < class T >
1570template < typename T2 >
1571inline pointer < T > & pointer < T >::defer_assign_to(T2 * & p)
1572{
1573
1574 if (!is_null())
1575 {
1576
1577 try
1578 {
1579
1580 p = dynamic_cast < T2 * >(m_p);
1581
1582 }
1583 catch (...)
1584 {
1585
1586 }
1587
1588 }
1589
1590 return *this;
1591
1592}
1593
1594
1595
1596template < class T >
1597template < typename OBJECT >
1598inline pointer < T > & pointer < T >::defer_create_new(OBJECT * pparticle)
1599{
1600
1601 if (is_null())
1602 {
1603
1604 create_new < T >(pparticle);
1605
1606 }
1607
1608 return *this;
1609
1610}
1611
1612
1613template < class T >
1614template < typename OBJECT >
1615inline pointer < T > & pointer < T >::create_new(OBJECT * pparticle)
1616{
1617
1618 auto p = allocateø T();
1619
1620 //p.set_referer();
1621
1622 if (p)
1623 {
1624
1625 p->initialize(pparticle);
1626
1627 }
1628
1629 return operator=(p);
1630
1631}
1632
1633
1634template<typename T>
1635inline bool is_found(const pointer < T >& p);
1636
1637
1638template<typename T>
1639inline bool not_found(const pointer < T >& p);
1640
1641
1642//template<typename TDST, typename TSRC>
1643//inline ::pointer<TDST>& clone(::pointer<TDST>dst, const ::pointer<TSRC>rc);
1644
1645
1646//template<typename T>
1647//inline pointer < T > clone(const pointer < T >& t);
1648
1649
1650template<class POINTER_TYPE>
1651inline auto& __typed(::pointer<POINTER_TYPE>* pp) { return *pp->operator POINTER_TYPE * (); }
1652
1653
1654template<class POINTER_TYPE>
1655inline auto& __typed(::pointer<POINTER_TYPE>& p) { return *p; }
1656
1657
1658template<typename T>
1659void __destroy_and_release(pointer < T >& p)
1660{
1661
1662 if (::is_null(p))
1663 {
1664
1665 return;
1666
1667 }
1668
1669 try
1670 {
1671
1672 p->destroy();
1673
1674 }
1675 catch (...)
1676 {
1677
1678 }
1679
1680 p.release();
1681
1682}
1683
1684
1685//template < class T >
1686//template < typename T2 >
1687//inline pointer < T > ::pointer(const pointer < T2 > & t)
1688//{
1689//
1690// if (::is_null(t.m_p))
1691// {
1692//
1693// m_p = nullptr;
1694//
1695// m_psubparticle = nullptr;
1696//
1697//#if REFERENCING_DEBUGGING
1698//
1699// m_preferer = nullptr;
1700//#endif
1701// }
1702// else
1703// {
1704//
1705// auto pNew = dynamic_cast <T *>(t.m_p);
1706//
1707// if (::is_null(pNew))
1708// {
1709//
1710// m_p = nullptr;
1711//
1712// m_psubparticle = nullptr;
1713//#if REFERENCING_DEBUGGING
1714//
1715// m_preferer = nullptr;
1716//#endif
1717// }
1718// else
1719// {
1720//#if REFERENCING_DEBUGGING
1721//
1722// ::reference_referer * prefererNew = nullptr;
1723//
1724// if (pNew->is_referencing_debugging_enabled())
1725// {
1726//
1727// prefererNew = ::allocator::defer_get_referer(pNew, { this, __FUNCTION_FILE_LINE__ });
1728//
1729// }
1730//#endif
1731// pNew->increment_reference_count();
1732//
1733// m_p = pNew;
1734//
1735// m_psubparticle = pNew;
1736//#if REFERENCING_DEBUGGING
1737//
1738// m_preferer = prefererNew;
1739//#endif
1740//
1741// }
1742//
1743// }
1744//
1745//}
1746//
1747//
1748//template < class T >
1749//template < typename T2 >
1750//inline pointer < T > ::pointer(pointer < T2 > && t)
1751//{
1752//
1753// if (::is_null(t.m_p))
1754// {
1755//
1756// m_p = nullptr;
1757//
1758// m_psubparticle = nullptr;
1759//#if REFERENCING_DEBUGGING
1760//
1761// m_preferer = nullptr;
1762//#endif
1763//
1764// }
1765// else
1766// {
1767//
1768// auto pNew = dynamic_cast <T *>(t.m_p);
1769//
1770// if (::is_null(pNew))
1771// {
1772//
1773// m_p = nullptr;
1774//
1775// m_psubparticle = nullptr;
1776//#if REFERENCING_DEBUGGING
1777//
1778// m_preferer = nullptr;
1779//#endif
1780// }
1781// else
1782// {
1783//
1784// m_p = pNew;
1785//
1786// m_psubparticle = pNew;
1787//#if REFERENCING_DEBUGGING
1788//
1789// m_preferer = t.m_preferer;
1790//#endif
1791// t.m_p = nullptr;
1792//
1793// //t.m_preferer = nullptr;
1794//
1795// }
1796//
1797// }
1798//
1799//}
1800
1801template < class T >
1802template < typename T2 >
1803inline pointer < T >& pointer < T > ::operator = (const ::cast < T2 >& p)
1804{
1805
1806 return this->operator=(p.m_p);
1807
1808}
1809
1810template < class T >
1811template < typename T2 >
1812inline pointer < T >& pointer < T > ::operator = (const pointer < T2 > & t)
1813{
1814
1815 ::subparticle * pOld = nullptr;
1816
1817#if REFERENCING_DEBUGGING
1818
1819 ::reference_referer * prefererOld = nullptr;
1820
1821#endif
1822
1823 if (::is_null(t.m_p))
1824 {
1825
1826 release();
1827
1828 }
1829 else
1830 {
1831
1832 auto pNew = dynamic_cast <T *>(t.m_p);
1833
1834 if (pNew == m_p)
1835 {
1836
1837 return *this;
1838
1839 }
1840 else if (::is_null(pNew))
1841 {
1842
1843 release();
1844
1845 }
1846 else
1847 {
1848
1849#if REFERENCING_DEBUGGING
1850
1851 critical_section_lock criticalsectionlock(refdbg_cs());
1852
1853 prefererOld = m_preferer;
1854
1855#endif
1856
1857 pOld = m_psubparticle;
1858
1859#if REFERENCING_DEBUGGING
1860
1861 ::reference_referer * prefererNew = nullptr;
1862
1863 if (pNew->is_referencing_debugging_enabled())
1864 {
1865
1866 //prefererNew = ::allocator::defer_push_referer(pNew, { pNew, this, __FUNCTION_FILE_LINE__ });
1867 prefererNew = ::allocator::defer_push_referer(pNew, { this, __FUNCTION_FILE_LINE__ });
1868
1869 }
1870 else
1871 {
1872
1873 ::allocator::defer_erase_referer(pNew);
1874
1875 }
1876
1877
1878#endif
1879
1880 pNew->increment_reference_count();
1881
1882 m_p = pNew;
1883
1884 m_psubparticle = pNew;
1885
1886#if REFERENCING_DEBUGGING
1887
1888 m_preferer = prefererNew;
1889
1890#endif
1891
1892 }
1893
1894 }
1895
1896 if (::is_set(pOld))
1897 {
1898
1899#if REFERENCING_DEBUGGING
1900
1901 if (pOld->is_referencing_debugging_enabled())
1902 {
1903
1904 ::allocator::add_releaser(prefererOld);
1905
1906 }
1907
1908#endif
1909
1910 ::release(pOld);
1911
1912 }
1913
1914 return *this;
1915
1916}
1917
1918
1919template < class T >
1920template < typename T2 >
1921inline pointer < T >& pointer < T > ::operator = (pointer < T2 > && t)
1922{
1923
1924#if REFERENCING_DEBUGGING
1925
1926 ::reference_referer * prefererOld = nullptr;
1927
1928#endif
1929
1930 ::subparticle * pOld = nullptr;
1931
1932 if (::is_null(t.m_p))
1933 {
1934
1935 release();
1936
1937 }
1938 else
1939 {
1940
1941 auto pNew = dynamic_cast <T *>(t.m_p);
1942
1943 if (pNew == m_p)
1944 {
1945
1946 return *this;
1947
1948 }
1949 else if (::is_null(pNew))
1950 {
1951
1952 release();
1953
1954 }
1955 else
1956 {
1957
1958#if REFERENCING_DEBUGGING
1959
1960 critical_section_lock criticalsectionlock(refdbg_cs());
1961
1962 prefererOld = m_preferer;
1963
1964#endif
1965
1966 pOld = m_psubparticle;
1967
1968 m_psubparticle = pNew;
1969
1970 m_p = pNew;
1971
1972#if REFERENCING_DEBUGGING
1973
1974 m_preferer = t.m_preferer;
1975
1976 t.m_preferer = nullptr;
1977
1978#endif
1979
1980 t.m_p = nullptr;
1981
1982 }
1983
1984 }
1985
1986 if (::is_set(pOld))
1987 {
1988
1989#if REFERENCING_DEBUGGING
1990
1991 if (pOld->is_referencing_debugging_enabled())
1992 {
1993
1994 ::allocator::add_releaser(prefererOld);
1995
1996 }
1997
1998#endif
1999
2000 ::release(pOld);
2001
2002 }
2003
2004 return *this;
2005
2006}
2007
2008
2009//template < class T >
2010//template < typename T2 >
2011//inline pointer < T > & pointer < T > ::operator = (const pointer < T2 > & t)
2012//{
2013//
2014// auto pOld = m_psubparticle;
2015//
2016// if (pOld == t.m_psubparticle)
2017// {
2018//
2019// return *this;
2020//
2021// }
2022//#if REFERENCING_DEBUGGING
2023//
2024// auto prefererOld = m_preferer;
2025//#endif
2026// if (::is_null(t.m_p))
2027// {
2028//
2029// m_p = nullptr;
2030//
2031// m_psubparticle = nullptr;
2032//#if REFERENCING_DEBUGGING
2033//
2034// m_preferer = nullptr;
2035//#endif
2036// }
2037// else
2038// {
2039//
2040// auto pNew = dynamic_cast <T *>(t.m_p);
2041//
2042// if (pNew == m_p)
2043// {
2044//
2045// return *this;
2046//
2047// }
2048// else if (::is_null(pNew))
2049// {
2050//
2051// m_p = nullptr;
2052//
2053// m_psubparticle = nullptr;
2054//#if REFERENCING_DEBUGGING
2055//
2056// m_preferer = nullptr;
2057//#endif
2058// }
2059// else
2060// {
2061//#if REFERENCING_DEBUGGING
2062//
2063// ::reference_referer * prefererNew = nullptr;
2064//
2065// if (pNew->is_referencing_debugging_enabled())
2066// {
2067//
2068// prefererNew = ::allocator::defer_get_referer(pNew, { this, __FUNCTION_FILE_LINE__ });
2069//
2070// }
2071//
2072//#endif
2073//
2074// pNew->increment_reference_count();
2075//
2076// m_psubparticle = t.m_psubparticle;
2077//
2078// m_p = pNew;
2079//#if REFERENCING_DEBUGGING
2080//
2081// m_preferer = prefererNew;
2082//#endif
2083// }
2084//
2085// }
2086//
2087// if (::is_set(pOld))
2088// {
2089//#if REFERENCING_DEBUGGING
2090//
2091// if (pOld->is_referencing_debugging_enabled())
2092// {
2093//
2094// ::allocator::add_releaser(prefererOld);
2095//
2096// }
2097//#endif
2098// ::release(pOld);
2099//
2100// }
2101//
2102// return *this;
2103//
2104//}
2105
2106
2107//template < class T >
2108//template < typename T2 >
2109//inline pointer < T > & pointer < T > ::operator = (pointer < T2 > && t)
2110//{
2111//
2112// auto pOld = m_psubparticle;
2113//
2114// if (pOld == t.m_psubparticle)
2115// {
2116//
2117// return *this;
2118//
2119// }
2120//#if REFERENCING_DEBUGGING
2121//
2122// auto prefererOld = m_preferer;
2123//#endif
2124// if (::is_null(t.m_p))
2125// {
2126//
2127// m_p = nullptr;
2128//
2129// m_psubparticle = nullptr;
2130//#if REFERENCING_DEBUGGING
2131//
2132// m_preferer = nullptr;
2133//#endif
2134// }
2135// else
2136// {
2137//
2138// auto pNew = dynamic_cast <T *>(t.m_p);
2139//
2140// if (pNew == m_p)
2141// {
2142//
2143// return *this;
2144//
2145// }
2146// else if (::is_null(pNew))
2147// {
2148//
2149// m_p = nullptr;
2150//
2151// m_psubparticle = nullptr;
2152//#if REFERENCING_DEBUGGING
2153//
2154// m_preferer = nullptr;
2155//#endif
2156// }
2157// else
2158// {
2159//
2160// m_psubparticle = t.m_psubparticle;
2161//
2162// m_p = pNew;
2163//#if REFERENCING_DEBUGGING
2164//
2165// if (!pNew->is_referencing_debugging_enabled())
2166// {
2167//
2168// if (t.m_preferer)
2169// {
2170//
2171// throw "error_wrong_state: " __FUNCTION_FILE_LINE__;
2172//
2173// }
2174//
2175// }
2176//
2177// m_preferer = t.m_preferer;
2178//#endif
2179// t.m_p = nullptr;
2180//
2181// t.m_psubparticle = nullptr;
2182//#if REFERENCING_DEBUGGING
2183//
2184// t.m_preferer = nullptr;
2185//#endif
2186// }
2187//
2188// }
2189//
2190// if (::is_set(pOld))
2191// {
2192//#if REFERENCING_DEBUGGING
2193//
2194// if (pOld->is_referencing_debugging_enabled())
2195// {
2196//
2197// ::allocator::add_releaser(prefererOld);
2198//
2199// }
2200//#endif
2201// ::release(pOld);
2202//
2203// }
2204//
2205// return *this;
2206//
2207//}
2208
2209
2210//template < typename T >
2211//template < typename PARTICLE >
2212//inline pointer < T >& pointer<T> ::defer_create(PARTICLE* pparticle, ::factory::factory* pfactory)
2213//{
2214//
2215// if (is_null())
2216// {
2217//
2218// operator=(pparticle->template __call__create < T >(pfactory));
2219//
2220// }
2221//
2222// return *this;
2223//
2224//}
2225
2226
2227
2228//template < typename TYPE >
2229//inline ::pointer<TYPE> __call__create_new(::subparticle* pparticle)
2230//{
2231//
2232// if (::is_null(pparticle))
2233// {
2234//
2235// throw_exception(error_wrong_state);
2236//
2237// }
2238//
2239// auto p = allocateø TYPE();
2240//
2241// if (p)
2242// {
2243//
2244// p->initialize(pparticle);
2245//
2246// }
2247//
2248// return ::transfer(p);
2249//
2250//}
2251
2252
2253//template < typename TYPE >
2254//inline void construct_newø(::subparticle* pparticle, ::pointer<TYPE>& p)
2255//{
2256//
2257// p = allocateø TYPE();
2258//
2259// if (!p)
2260// {
2261//
2262// throw_exception(error_no_memory);
2263//
2264// }
2265//
2266// p->initialize(pparticle);
2267//
2268//}
2269
2270
2271template < typename TARGET, typename SOURCE >
2272inline void copy(::pointer < TARGET > & pTarget, const ::pointer < SOURCE > & pSource)
2273{
2274
2275 pTarget = pSource;
2276
2277}
2278
2279
2280//template < typename T >
2281//template < class T2 >
2282//inline pointer < T > & pointer < T >::operator = (::pointer<T2>&& t)
2283//{
2284//
2285// auto pOld = m_p;
2286//
2287// if (::is_set(t.m_p))
2288// {
2289//
2290// m_p = dynamic_cast <T *>(t.m_p);
2291//
2292// m_psubparticle = t.m_psubparticle;
2293//
2294// if (::is_set(m_p))
2295// {
2296//
2297// t.m_p = nullptr;
2298//
2299// t.m_psubparticle = nullptr;
2300//
2301// }
2302//
2303// }
2304// else
2305// {
2306//
2307// m_p = nullptr;
2308//
2309// m_psubparticle = nullptr;
2310//
2311// }
2312//
2313// ::release(pOld);
2314//
2315// return *this;
2316//
2317//}
2318
2319
2320//template < typename T >
2321//inline bool pointer < T > ::ok() const
2322//{
2323//
2324// return is_set() && m_psubparticle->_is_ok();
2325//
2326//}
2327
2328
2329template < typename T >
2330inline bool pointer < T > ::defer_destroy_and_release()
2331{
2332
2333 if (!this->is_set())
2334 {
2335
2336 return false;
2337
2338 }
2339
2340 m_psubparticle->destroy();
2341
2342 release();
2343
2344 return true;
2345
2346}
2347
2348
2350template < typename T >
2351inline ::i64 release(T *& p)
2352{
2353
2354 if (::is_null(p))
2355 {
2356
2357 return -1;
2358
2359 }
2360
2361 ::subparticle * pparticle = p;
2362
2363 try
2364 {
2365
2366 p = nullptr;
2367
2368 }
2369 catch (...)
2370 {
2371
2372 informationf("exception release p = nullptr; \n");
2373
2374 }
2375
2376 try
2377 {
2378
2379 return pparticle->release();
2380
2381 }
2382 catch (...)
2383 {
2384
2385 informationf("exception release pparticle->release() \n");
2386
2387 }
2388
2389 return -1;
2390
2391}
2392
2393
2395template < typename T >
2396inline ::i64 global_release(T *& p)
2397{
2398
2399 if (::is_null(p))
2400 {
2401
2402 return -1;
2403
2404 }
2405
2406 try
2407 {
2408
2409 auto i = p->release();
2410
2411 if (i <= 0)
2412 {
2413
2414 p = nullptr;
2415
2416 }
2417
2418 return i;
2419
2420 }
2421 catch (...)
2422 {
2423
2424 informationf("exception release pparticle->release() \n");
2425
2426 }
2427
2428 return -1;
2429
2430}
2431
2432
2433
2434
critical_section_lock
Definition critical_section.h:29
lparam
Definition lparam.h:9
particle
Definition particle.h:95
subparticle
Definition subparticle.h:78
wparam
Definition wparam.h:10
allocate_t
Definition _structures.h:7
place_t
Definition pointer.h:9