acme
Foundational cross-platform layer of the ca2 framework
Loading...
Searching...
No Matches
pointer.h
1#pragma once
2
3
4//#include "acme/prototype/prototype/subparticle.h"
5#include "acme/prototype/prototype/pointer.h"
6#include "acme/platform/reference_referer.h"
7
8
9struct place_t {};
10
11//struct transfer_t {};
12
13
14//CLASS_DECL_ACME ::factory::factory * get_system_factory();
15
16
17//#if REFERENCING_DEBUGGING
18//
19//
20//CLASS_DECL_ACME::subparticle * task_get_top_track();
21//CLASS_DECL_ACME void task_on_new_particle(::subparticle * pparticle);
22//CLASS_DECL_ACME void task_on_after_new_particle(::subparticle * pparticle);
23//
24//
25//#endif
26
27
28#define TEMPLATE_TYPE typename __TEMPLATE_TYPE__ = nullptr_t
29#define TEMPLATE_ARG __TEMPLATE_TYPE__ t = nullptr
30
31template < class c_derived >
32inline ::i64 increment_reference_count(c_derived * pca);
33
34class subparticle;
35
36// ::ca::null_class back link to operational system oswindow.h
37// operational system nullptr/void itself to a windowing service
38//
39// Curitiba, inha-metro-win-ubuntu-mountain-lion-macos 4 de novembro de 2012
40template < typename T >
41class pointer
42{
43public:
44
45 using POINTER_TYPE_TAG = pointer_type_t;
46 using TYPE = T;
47
48 using RAW_POINTER = TYPE *;
49
50 T * m_p;
51 ::subparticle * m_psubparticle;
52 ::e_status m_estatus;
53#if REFERENCING_DEBUGGING
54 reference_referer * m_preferer = nullptr;
55#endif
56
57
58 inline pointer();
59 inline pointer(no_initialize_t){}
60 inline pointer( nullptr_t);
61 inline pointer(wparam& wparam);
62 inline pointer(lparam& lparam);
63
64 template < typename ...Args >
65 pointer(allocate_t, Args &&... args);
66
67 pointer(const pointer & t);
68 pointer(pointer && t);
69 //template < typename T2 >
70 //pointer(const ptr < T2 > & p);
71 //template < typename T2 >
72 //pointer(ptr < T2 > && p);
73 //inline pointer(const ::trait & trait);
74
75
76 //inline _pointer < enum_create_new > :
77 // m_p(aaa_memory_new T)
78 //{
79
80 //}
81
82
84 template < typename PARTICLE >
85 inline pointer(enum_create_new, PARTICLE * pparticle) :
86 m_p(nullptr),
87 m_psubparticle(nullptr)
88 {
89
90 //m_preferer = ::allocator::get_referer();
91
92 REFDBG_THIS(this);
93
94 pparticle->construct_newø(*this);
95
96 }
97
98
100 template < typename PARTICLE >
101 inline pointer(enum_create, PARTICLE * pparticle, ::factory::factory * pfactory = nullptr) :
102 m_p(nullptr),
103 m_psubparticle(nullptr)
104 {
105
106 //m_preferer = ::allocator::get_referer();
107
108 REFDBG_THIS(this);
109
110 pparticle->constructø(*this, pfactory);
111
112 }
113
114
116 template < typename T2 >
117 inline pointer(transfer_t, T2* p) :pointer(place_t{}, p) {}
118 template < typename T2 >
119 inline pointer(place_t, T2* p);
120
121
123 template < class T2 >
124 inline pointer(const T2 * p)
125 {
126
127 if (::is_null(p))
128 {
129
130 m_p = nullptr;
131
132 m_psubparticle = nullptr;
133#if REFERENCING_DEBUGGING
134
135 m_preferer = nullptr;
136#endif
137 return;
138
139 }
140
141 auto pNew = dynamic_cast <T *> ((T2 *)p);
142
143 if (::is_set(pNew))
144 {
145#if REFERENCING_DEBUGGING
146
147 ::reference_referer * prefererNew = nullptr;
148
149 if (pNew->is_referencing_debugging_enabled())
150 {
151
152 //prefererNew = ::allocator::push_referer({pNew, this, __FUNCTION_FILE_LINE__ });
153
154 prefererNew = ::allocator::push_referer({ this, __FUNCTION_FILE_LINE__ });
155
156 }
157#endif
158 pNew->increment_reference_count();
159
160 m_p = pNew;
161
162 m_psubparticle = pNew;
163#if REFERENCING_DEBUGGING
164
165 m_preferer = prefererNew;
166#endif
167 }
168 else
169 {
170
171 m_psubparticle = nullptr;
172
173 m_p = nullptr;
174#if REFERENCING_DEBUGGING
175
176 m_preferer = nullptr;
177#endif
178 }
179
180 }
181
182
184 template < class T2 >
185 inline pointer(const ::pointer<T2>& p) :
186 pointer(p.m_p)
187 {
188
189 }
190
192 template < class T2 >
193 inline pointer(const ::cast<T2>& p) :
194 pointer(p.m_p)
195 {
196
197 }
198
199 inline bool operator !() const
200 {
201
202 return is_null();
203
204 }
205
206
207 //inline operator ::i32() const
208 //{
209
210 // return is_set() ? 1 : 0;
211
212 //}
213
214 //template < typename T2 >
215 //inline pointer(const T2 * p);
216
217 //inline pointer(const void * p) : pointer(e_pointer_transfer, (T *)p) {}
218
219 //template < class T2 >
220 //inline pointer(const ::pointer<T2> t2)
221 //{
222
223 // m_p = dynamic_cast <T*>(t2.m_p);
224
225 // m_psubparticle = m_p;
226
227 // if (::is_set(m_p))
228 // {
229
230 // m_p->increment_reference_count();
231
232 // }
233
234 //}
235
236
237 template < class T2 >
238 inline pointer(::pointer<T2>&& t)
239 requires (!::std::is_same<T2, T>::value)
240 {
241
242 if (::is_set(t.m_p))
243 {
244
245 auto p = dynamic_cast < T * > (t.m_p);
246
247 if (::is_set(p))
248 {
249
250 m_p = p;
251
252 m_psubparticle = t.m_psubparticle;
253
254 m_estatus = t.m_estatus;
255
256#if REFERENCING_DEBUGGING
257
258 m_preferer = t.m_preferer;
259
260#endif
261
262 t.m_p = nullptr;
263
264 t.m_psubparticle = nullptr;
265
266#if REFERENCING_DEBUGGING
267
268 t.m_preferer = nullptr;
269
270#endif
271
272 }
273 else
274 {
275
276 m_p = nullptr;
277
278 m_psubparticle = nullptr;
279#if REFERENCING_DEBUGGING
280
281 m_preferer = nullptr;
282#endif
283 }
284
285 }
286 else
287 {
288
289 m_p = nullptr;
290
291 m_psubparticle = nullptr;
292#if REFERENCING_DEBUGGING
293
294 m_preferer = nullptr;
295#endif
296 }
297
298 }
299
300 template < class T2 >
301 inline pointer(::pointer<T2>&& t)
302 requires ::std::is_same<T2, T>::value
303 {
304
305 if (::is_set(t.m_p))
306 {
307
308 auto p = t.m_p;
309
310 if (::is_set(p))
311 {
312
313 m_p = p;
314
315 m_psubparticle = t.m_psubparticle;
316
317 m_estatus = t.m_estatus;
318
319#if REFERENCING_DEBUGGING
320
321 m_preferer = t.m_preferer;
322
323#endif
324
325 t.m_p = nullptr;
326
327 t.m_psubparticle = nullptr;
328
329#if REFERENCING_DEBUGGING
330
331 t.m_preferer = nullptr;
332
333#endif
334
335 }
336 else
337 {
338
339 m_p = nullptr;
340
341 m_psubparticle = nullptr;
342#if REFERENCING_DEBUGGING
343
344 m_preferer = nullptr;
345#endif
346 }
347
348 }
349 else
350 {
351
352 m_p = nullptr;
353
354 m_psubparticle = nullptr;
355#if REFERENCING_DEBUGGING
356
357 m_preferer = nullptr;
358#endif
359 }
360
361 }
362
363 inline ~pointer();
364
365 //template < typename OTHER >
366 //inline pointer & operator +=(::pointer<OTHER>& p) { m_p->compose(p); return *this; }
367
368 //template < typename OTHER >
369 //inline pointer & operator -=(::pointer<OTHER>& p) { m_p->release(p); return *this; }
370
371 //inline static const_char_pointer ::platform::type(this).name();
372
373 inline T* operator ->() { return m_p; }
374 inline T* operator ->() const { return m_p; }
375 inline T & operator *() { return *m_p; }
376 inline T & operator *() const { return *m_p; }
377 inline operator T * () { return m_p; }
378 inline operator T * const () const { return m_p; }
379 inline T * get() { return m_p; }
380 inline const T * get() const { return m_p; }
381
382 inline ::iptr iptr() const { return (::iptr) m_p;}
383
384 inline bool is_set() const;
385 inline bool is_null() const;
386
387 inline bool ok() const;
388 inline bool nok() const;
389
390 template < class T2 >
391 inline pointer & operator = (T2 * p)
392 {
393
394 return reset(p);
395
396 }
397
398
399 pointer & operator = (const pointer & t);
400 pointer & operator = (pointer && t);
401
402
403 template < class T2 >
404 inline pointer & operator = (const ::pointer<T2> & t);
405 template < class T2 >
406 inline pointer & operator = (::pointer<T2> && t);
407
408 template < class T2 >
409 inline pointer& operator = (const ::cast<T2>& t);
410
411 template < typename T2 >
412 inline pointer < T2 > defer_get_new(::particle* pparticle);
413
414
415 //template < typename T2 >
416 //pointer & operator = (const ptr < T2 > & p);
417 //template < typename T2 >
418 //pointer & operator = (ptr < T2 > && p);
419
420
421
422 //template < typename VAR >
423 //inline pointer & operator = (const payload_type < VAR > & payload);
424
425 //void set_referer()
426 //{
427
428 // m_referer = referer;
429
430 //}
431
432 //void on_initialize_particle()
433 //{
434
435 // m_psubparticle->add_reference_item(m_referer);
436
437 //}
438
439
440 //void add_reference_item()
441 //{
442
443 // set_referer();
444
445 // m_psubparticle->add_reference_item();
446
447 //}
448
449
450 //inline pointer& operator = (T * p)
451 //{
452
453 // return reset((T *) p);
454
455 //}
456
457
458 //template < typename T2 >
459 //inline pointer & operator = (const T2 * p)
460 //{
461
462 // return reset((T *) p);
463
464 //}
465
466
467 //template < class T2 >
468 //inline pointer& operator = (const ::prototype::composite < T2 >& composite)
469 //{
470
471 // return operator = (composite.get());
472
473 //}
474
475
476 //template < class T2 >
477 //inline pointer& operator = (const ::prototype::reference < T2 >& reference)
478 //{
479
480 // return operator = (reference.get());
481
482 //}
483
484 inline bool defer_destroy_and_release();
485
486 inline ::i64 release();
487
488 //inline ::i64 global_release();
489
490 inline ::pointer < T > detach() { return ::transfer(*this); }
491 //inline ::subparticle * detach_particle();
492
493
494 template < class T2 >
495 inline ::pointer<T2>cast()
496 {
497
498 return m_p;
499
500 }
501
502
503 template < class T2 >
504 inline ::pointer<T2>cast() const
505 {
506
507 return m_p;
508
509 }
510
511
512 template < class T2 >
513 inline non_const < T2 > * raw_cast()
514 {
515
516 return dynamic_cast <non_const < T2 > * > (m_p);
517
518 }
519
520
521 template < class T2 >
522 inline const non_const < T2 > * raw_cast() const
523 {
524
525 return (const non_const < T2 > *) dynamic_cast <non_const < T2 > * > ((non_const < T > *)m_p);
526
527 }
528
529
530 template < class T2 >
531 inline bool is() const
532 {
533
534 return cast < T2 >().is_set();
535
536 }
537
538
539 //inline bool ok() const;
540
541
542 //inline bool nok() const
543 //{
544
545 // return !ok();
546
547 //}
548
549
550 //template < typename CONTAINER, typename OBJECT, typename ATTRIBUTE >
551 //pointer & merge(const CONTAINER & pcontainer, const OBJECT & pparticle, const ATTRIBUTE & attribute)
552 //{
553
554 // auto pModified = allocateø TYPE(*m_p);
555
556 // pModified->apply(pparticle, attribute);
557
558 // return operator =(pcontainer->get_existing(pModified));
559
560 //}
561
562 //template < typename OBJECT, typename ATTRIBUTE >
563 //pointer & container_merge(const OBJECT & pparticle, const ATTRIBUTE & attribute)
564 //{
565
566 // return merge(m_p->m_pcontainer, pparticle, attribute);
567
568 //}
569
570 //template < typename CONTAINER, typename OBJECT >
571 //pointer & copy(const CONTAINER & pcontainer, const OBJECT & pparticle)
572 //{
573
574 // auto pobjectParent = m_p;
575
576 // auto pOld = m_p;
577
578 // m_p = ___new TYPE(*pparticle);
579
580 // m_psubparticle = m_p;
581
582 // pcontainer->erase(pOld);
583
584 // pcontainer->add(m_p);
585
586 // m_p->initialize(pobjectParent);
587
588 // m_p->m_pcontainer = pcontainer;
589
590 // return *this;
591
592 //}
593
594
595 //template < typename OBJECT >
596 //pointer & container_copy(const OBJECT & pparticle)
597 //{
598
599 // return copy(m_p->m_pcontainer, pparticle);
600
601 //}
602
603 //inline pointer& reset(T * p);
604
605 template < typename T2 >
606 inline pointer& reset(const ::pointer < T2 > & p) { return reset(p.m_p); }
607
608
609 template < typename T2 >
610 inline pointer & reset(T2 * ptr);
611
612
613 template < typename T2 >
614 inline pointer & transfer(T2 * ptr);
615
616
617 inline bool operator ==(nullptr_t) const { return is_null(); }
618 //inline bool operator <=>(nullptr_t) const { return m_p <=> nullptr; }
619
620
621 //inline bool operator !=(nullptr_t) const { return is_set(); }
622
623// template < typename T2 >
624// inline bool operator ==(const T2 * p) const { return m_p == p; }
625 //template < typename T2 >
626 //inline bool operator <=>(const T2 * p) const { return m_p <=> p; }
627
628 //template < typename T2 >
629 //inline bool operator !=(const T2 * p) const { return m_p != p; }
630
631 //inline bool operator ==(const T * p) const { return m_p == p; }
632 //inline bool operator <=>(const T * p) const { return m_p <=> p; }
633 //inline bool operator !=(const T * p) const { return m_p != p; }
634
635 //template < typename TYPE = T >
636 //inline pointer < T > & defer_create_new();
637
638 template < typename TYPE >
639 inline pointer < T > & defer_assign_to(TYPE * & p);
640
641 //template < typename TYPE = T >
642 //inline pointer < T > & create_new();
643
644 template < typename OBJECT >
645 inline pointer < T > & defer_create_new(OBJECT * pparticle);
646
647 template < typename OBJECT >
648 inline pointer < T > & create_new(OBJECT * pparticle);
649
650 //template < typename OBJECT >
651 //inline pointer < T > & defer_create(OBJECT * pparticle, ::factory::factory * pfactory = nullptr);
652
653 //template < typename OBJECT >
654 //inline pointer < T > & create(OBJECT * pparticle, ::factory::factory * pfactory = nullptr);
655
656 template < typename T2 >
657 inline pointer < T > & clone(T2 * p);
658
659 inline void run_and_release()
660 {
661
662 if (is_null())
663 {
664
665 return;
666
667 }
668
669 m_p->run();
670
671 release();
672
673 }
674
675
676 inline void operator()() const
677 {
678
679 ((TYPE *) m_p)->call();
680
681 }
682
683
684};
685
686
687// It must not free memory directly allocated to matter pointed by 'p'.
688// It is recommended to let final deletion and destruction happens at normal destructor.
689// 'destruct' semantics gives a class the ability to use the scoped guard____pointer
690// to release outer references (from operating system for example) that would prevent
691// the matter to be deleted/destroyed when the matter is released by a conventional pointer.
692//
693template < class T >
694inline void destruct(T * p)
695{
696
697 try
698 {
699
700 p->destruct();
701
702 }
703 catch(...)
704 {
705
706 }
707
708}
709
710
712//
713//template < class T >
714//class guard____pointer :
715// public pointer< T >
716//{
717//public:
718// guard__pointer < > {}
719// guard____pointer(const lparam& lparam) : pointer<T>(lparam) {}
720//
721// guard____pointer(const pointer < T > & t): pointer< T>(t) {}
722// guard____pointer(guard____pointer < T > && t): pointer<T>(::transfer(t)) {}
723// //guard____pointer(const allocer & allocer): pointer<T>(allocer) {}
724// template < class T2 >
725// guard____pointer(T2 * p) : pointer<T>(p) {}
726// guard____pointer(T * p) : pointer<T>(p) {}
727//
728// template < class T2 >
729// guard____pointer(const T2 * p): pointer<T>(p) {}
730//
731//
732// template < class T2 >
733// guard____pointer(const ::pointer<T2>& t): pointer<T>(t) {}
734//
735//
736// template < class T2 >
737// guard____pointer(guard____pointer < T2 > && t) :
738// pointer<T>(::transfer(t)) {}
739//
740//
741// ~guard__pointer < >
742// {
743//
744// if(::is_set(this->m_p))
745// {
746//
747// ::destruct(this->m_p);
748//
749// }
750//
751// this->release();
752//
753// }
754//
755//
756//};
757//
758
759template < typename T >
760inline bool is_found(const ::pointer < T > & p) { return p.is_set(); }
761
762
763template < typename T >
764inline bool not_found(const ::pointer < T > & p) { return p.is_null(); }
765
766
767//template < typename T >
768//inline pointer < T > __move_transfer(T* p) { return { e_pointertransfer, p }; }
769//
770//
771template < typename TYPE >
772inline void swap(::pointer<TYPE>& a, ::pointer<TYPE> & b)
773{
774
775 auto t = a;
776 a = b;
777 b = t;
778
779}
780
781
782
783
784//template < typename TYPE >
785//inline ::pointer<TYPE>clone(const ::pointer<TYPE> & p);
786
787
788//template < typename TYPE >
789//inline ::pointer<TYPE>& clone(::pointer<TYPE> & p);
790
791
792template < typename TYPE >
793inline ::pointer<TYPE>& defer_clone(::pointer<TYPE> & p);
794
795
796template < typename TYPE >
797pointer < TYPE > clone(TYPE * p);
798
799
800//template < typename TYPE >
801//inline ::pointer<TYPE> __call__create_new( ::subparticle* pparticle);
802
803
804template < typename TARGET, typename SOURCE >
805inline void copy(::pointer < TARGET > & pTarget, const ::pointer < SOURCE > & pSource);
806
807
808
809//template < typename T, typename ...Args >
810//::pointer < T > allocateø(Args &&... args)
811//{
812//
813// ::pointer < T > p{ transfer_t{}, ::new T(::std::forward<Args>(args)...) };
814//
815// task_on_after_new_particle(p);
816//
817// return ::transfer(p);
818//
819//}
820
821
822//#else
823
824
825template < typename T, typename ...Args >
826::pointer < T > __call_allocate(Args &&... args);
827
828
829//template < typename TYPE >
830//ptr < TYPE >::ptr(const ::pointer < TYPE > & p)
831//{
832//
833// auto pNew = p.m_p;
834//
835// if (::is_null(pNew))
836// {
837//
838// m_p = nullptr;
839//#if REFERENCING_DEBUGGING
840// m_preferer = nullptr;
841//#endif
842// }
843// else
844// {
845//#if REFERENCING_DEBUGGING
846// ::reference_referer * prefererNew = nullptr;
847//
848// if (pNew->is_referencing_debugging_enabled())
849// {
850//
851// prefererNew = ::allocator::defer_get_referer(pNew, { this, __FUNCTION_FILE_LINE__ });
852//
853// }
854//#endif
855// pNew->increment_reference_count();
856//
857// m_p = pNew;
858//#if REFERENCING_DEBUGGING
859// m_preferer = prefererNew;
860//#endif
861// }
862//
863//}
864//
865//template < typename TYPE >
866//ptr < TYPE >::ptr(::pointer < TYPE > && p)
867//{
868//
869// auto pNew = p.m_p;
870//
871// if (::is_null(pNew))
872// {
873//
874// m_p = nullptr;
875//#if REFERENCING_DEBUGGING
876// m_preferer = nullptr;
877//#endif
878// }
879// else
880// {
881//
882// m_p = pNew;
883//#if REFERENCING_DEBUGGING
884// if (!pNew->is_referencing_debugging_enabled())
885// {
886//
887// if (p.m_preferer)
888// {
889//
890// throw "error_wrong_state: " __FUNCTION_FILE_LINE__;
891//
892// }
893//
894// }
895//
896// m_preferer = p.m_preferer;
897//#endif
898// p.m_p = nullptr;
899// p.m_psubparticle = nullptr;
900// p.m_estatus = error_not_initialized;
901//#if REFERENCING_DEBUGGING
902// p.m_preferer = nullptr;
903//#endif
904//
905// }
906//}
907//
908//template < typename TYPE >
909//template < typename T2 >
910//ptr < TYPE >::ptr(const ::pointer < T2 > & p)
911//{
912//
913// auto pNew = dynamic_cast < TYPE * >((T2*)p.m_p);
914//
915// if (::is_null(pNew))
916// {
917//
918// m_p = nullptr;
919//#if REFERENCING_DEBUGGING
920// m_preferer = nullptr;
921//#endif
922// }
923// else
924// {
925//#if REFERENCING_DEBUGGING
926//
927// ::reference_referer * prefererNew = nullptr;
928//
929// if (pNew->is_referencing_debugging_enabled())
930// {
931//
932// prefererNew = ::allocator::defer_get_referer(pNew, { this, __FUNCTION_FILE_LINE__ });
933//
934// }
935//#endif
936//
937// pNew->increment_reference_count();
938//
939// m_p = pNew;
940//#if REFERENCING_DEBUGGING
941//
942// m_preferer = prefererNew;
943//#endif
944//
945// }
946//
947//}
948//
949//template < typename TYPE >
950//template < typename T2 >
951//ptr < TYPE >::ptr(::pointer < T2 > && p)
952//{
953//
954// auto pNew = dynamic_cast < TYPE * >(p.m_p);
955//
956// if (::is_null(pNew))
957// {
958//
959// m_p = nullptr;
960//#if REFERENCING_DEBUGGING
961//
962// m_preferer = nullptr;
963//#endif
964//
965// }
966// else
967// {
968//
969// m_p = pNew;
970//#if REFERENCING_DEBUGGING
971//
972// if (!pNew->is_referencing_debugging_enabled())
973// {
974//
975// if (p.m_preferer)
976// {
977//
978// throw "error_wrong_state: " __FUNCTION_FILE_LINE__;
979//
980// }
981//
982// }
983//
984// m_preferer = p.m_preferer;
985//#endif
986// p.m_p = nullptr;
987//
988// p.m_psubparticle = nullptr;
989//
990// p.m_estatus = error_not_initialized;
991//#if REFERENCING_DEBUGGING
992//
993// p.m_preferer = nullptr;
994//#endif
995// }
996//}
997//
998//
999//
1000//template < typename TYPE >
1001//ptr < TYPE > & ptr < TYPE >::operator =(const ::pointer < TYPE > & p)
1002//{
1003//
1004// auto pNew = p.m_p;
1005//
1006// auto pOld = m_p;
1007//
1008// if (pNew == m_p)
1009// {
1010//
1011// return *this;
1012//
1013// }
1014//#if REFERENCING_DEBUGGING
1015//
1016// auto prefererOld = m_preferer;
1017//#endif
1018// if (::is_null(pNew))
1019// {
1020//
1021// m_p = nullptr;
1022//#if REFERENCING_DEBUGGING
1023//
1024// m_preferer = nullptr;
1025//#endif
1026// }
1027// else
1028// {
1029//#if REFERENCING_DEBUGGING
1030//
1031// ::reference_referer * prefererNew = nullptr;
1032//
1033// if (pNew->is_referencing_debugging_enabled())
1034// {
1035//
1036// prefererNew = ::allocator::defer_get_referer(pNew, { this, __FUNCTION_FILE_LINE__ });
1037//
1038// }
1039//#endif
1040// pNew->increment_reference_count();
1041//
1042// m_p = pNew;
1043//#if REFERENCING_DEBUGGING
1044//
1045// m_preferer = prefererNew;
1046//#endif
1047// }
1048//
1049// if (::is_set(pOld))
1050// {
1051//
1052//
1053//#if REFERENCING_DEBUGGING
1054//
1055// if (pOld->is_referencing_debugging_enabled())
1056// {
1057//
1058// ::allocator::add_releaser(prefererOld);
1059//
1060// }
1061//
1062//#endif
1063// pOld->release();
1064//
1065// }
1066//
1067// return *this;
1068//
1069//
1070//}
1071//
1072//template < typename TYPE >
1073//ptr < TYPE > & ptr < TYPE >::operator =(::pointer < TYPE > && p)
1074//{
1075//
1076// auto pNew = p.m_p;
1077//
1078// auto pOld = m_p;
1079//
1080// if (pNew == m_p)
1081// {
1082//
1083// return *this;
1084//
1085// }
1086//#if REFERENCING_DEBUGGING
1087//
1088// auto prefererOld = m_preferer;
1089//#endif
1090// if (::is_null(pNew))
1091// {
1092//
1093// m_p = nullptr;
1094//#if REFERENCING_DEBUGGING
1095//
1096// m_preferer = nullptr;
1097//#endif
1098//
1099// }
1100// else
1101// {
1102//
1103// m_p = pNew;
1104//#if REFERENCING_DEBUGGING
1105//
1106// m_preferer = p.m_preferer;
1107//#endif
1108// p.m_p = nullptr;
1109// p.m_psubparticle = nullptr;
1110// p.m_estatus = error_not_initialized;
1111//#if REFERENCING_DEBUGGING
1112//
1113// p.m_preferer = nullptr;
1114//#endif
1115//
1116// }
1117//
1118// if (::is_set(pOld))
1119// {
1120//#if REFERENCING_DEBUGGING
1121//
1122// if (pOld->is_referencing_debugging_enabled())
1123// {
1124//
1125// ::allocator::add_releaser(prefererOld);
1126//
1127// }
1128//#endif
1129// pOld->release();
1130//
1131// }
1132//
1133// return *this;
1134//
1135//}
1136//
1137//template < typename TYPE >
1138//template < typename T2 >
1139//ptr < TYPE > & ptr < TYPE >::operator =(const ::pointer < T2 > & p)
1140//{
1141//
1142// auto pNew = dynamic_cast <TYPE *>((T2 *)p.m_p);
1143//
1144// auto pOld = m_p;
1145//
1146// if (pNew == m_p)
1147// {
1148//
1149// return *this;
1150//
1151// }
1152//#if REFERENCING_DEBUGGING
1153//
1154// auto prefererOld = m_preferer;
1155//#endif
1156// if (::is_null(pNew))
1157// {
1158//
1159// m_p = nullptr;
1160//#if REFERENCING_DEBUGGING
1161//
1162// m_preferer = nullptr;
1163//#endif
1164// }
1165// else
1166// {
1167//#if REFERENCING_DEBUGGING
1168//
1169// ::reference_referer * prefererNew = nullptr;
1170//
1171// if (pNew->is_referencing_debugging_enabled())
1172// {
1173//
1174// prefererNew = ::allocator::defer_get_referer(pNew, { this, __FUNCTION_FILE_LINE__ });
1175//
1176// }
1177//#endif
1178// pNew->increment_reference_count();
1179//
1180// m_p = pNew;
1181//#if REFERENCING_DEBUGGING
1182//
1183// m_preferer = prefererNew;
1184//#endif
1185// }
1186//
1187// if (::is_set(pOld))
1188// {
1189//#if REFERENCING_DEBUGGING
1190//
1191// if (pOld->is_referencing_debugging_enabled())
1192// {
1193//
1194// ::allocator::add_releaser(prefererOld);
1195//
1196// }
1197//#endif
1198// pOld->release();
1199//
1200// }
1201//
1202// return *this;
1203//
1204//}
1205//
1206//template < typename TYPE >
1207//template < typename T2 >
1208//ptr < TYPE > & ptr < TYPE >::operator =(::pointer < T2 > && p)
1209//{
1210//
1211// auto pNew = dynamic_cast <TYPE *>((T2 *)p.m_p);
1212//
1213// auto pOld = m_p;
1214//
1215// if (pNew == m_p)
1216// {
1217//
1218// return *this;
1219//
1220// }
1221//
1222//#if REFERENCING_DEBUGGING
1223//
1224// auto prefererOld = m_preferer;
1225//
1226//#endif
1227// if (::is_null(pNew))
1228// {
1229//
1230// m_p = nullptr;
1231//#if REFERENCING_DEBUGGING
1232//
1233// m_preferer = nullptr;
1234//#endif
1235// }
1236// else
1237// {
1238//
1239// m_p = pNew;
1240//#if REFERENCING_DEBUGGING
1241//
1242// m_preferer = p.m_preferer;
1243//#endif
1244// p.m_p = nullptr;
1245// p.m_psubparticle = nullptr;
1246// p.m_estatus = error_not_initialized;
1247//#if REFERENCING_DEBUGGING
1248//
1249// p.m_preferer = nullptr;
1250//#endif
1251//
1252// }
1253//
1254// if (::is_set(pOld))
1255// {
1256//#if REFERENCING_DEBUGGING
1257//
1258// if (pOld->is_referencing_debugging_enabled())
1259// {
1260//
1261// ::allocator::add_releaser(prefererOld);
1262//
1263// }
1264//#endif
1265// pOld->release();
1266//
1267// }
1268//
1269// return *this;
1270//
1271//}
1272
1273
1274template < typename TYPE >
1275inline void defer_finalize(::pointer < TYPE >& p)
1276{
1277
1278 try
1279 {
1280
1281 if (p)
1282 {
1283
1284 p->finalize();
1285
1286 }
1287
1288 }
1289 catch (...)
1290 {
1291
1292 }
1293
1294}
1295
1296
1297template < typename TYPE >
1298inline void defer_destroy(::pointer < TYPE >& p)
1299{
1300
1301 try
1302 {
1303
1304 if (p)
1305 {
1306
1307 p->destroy();
1308
1309 }
1310
1311 }
1312 catch (...)
1313 {
1314
1315 }
1316
1317}
1318
1319
1320//template < typename TYPE >
1321//inline void defer_finalize_and_release(::pointer < TYPE > & p)
1322//{
1323//
1324// auto pFinalizeAndRelease = ::transfer(p);
1325//
1326// if (pFinalizeAndRelease)
1327// {
1328//
1329// ::defer_finalize(pFinalizeAndRelease);
1330//
1331// pFinalizeAndRelease.release();
1332//
1333// }
1334//
1335//}
1336
1337
1338//template < typename TYPE >
1339//inline void defer_finalize__destroy_and_release(::pointer < TYPE >& p)
1340//{
1341//
1342// auto pFinalize_DestroyAndRelease = ::transfer(p);
1343//
1344// if (pFinalize_DestroyAndRelease)
1345// {
1346//
1347// ::defer_finalize(pFinalize_DestroyAndRelease);
1348//
1349// ::defer_destroy(pFinalize_DestroyAndRelease);
1350//
1351// pFinalize_DestroyAndRelease.release();
1352//
1353// }
1354//
1355//}
1356
1357
1358template < typename TYPE >
1359inline void defer_destroy_and_release(::pointer < TYPE >& p)
1360{
1361
1362 auto pDestroyAndRelease = ::transfer(p);
1363
1364 if (pDestroyAndRelease)
1365 {
1366
1367 ::defer_destroy(pDestroyAndRelease);
1368
1369 pDestroyAndRelease.release();
1370
1371 }
1372
1373}
1374
1375
1376template < typename TYPE >
1377::pointer < TYPE > as_pointer(TYPE * p)
1378{
1379
1380return p;
1381
1382}
1383
1384
1385// https://stackoverflow.com/questions/71921797/c-concepts-checking-if-derived-from-a-templated-class-with-unknown-template-p
1396template<class specialization, template<typename> class template_class,
1397 typename ...partial_specialization>
1398concept specializes = requires (specialization s) {
1399 [] <typename ...template_args>(
1400 template_class<partial_specialization..., template_args...>&) {}(s);
1401};
1402
1403// https://stackoverflow.com/questions/71921797/c-concepts-checking-if-derived-from-a-templated-class-with-unknown-template-p
1404template <typename POINTER>
1405concept pointer_derived = requires(POINTER p) {
1406 // IILE, that only binds to A<...> specialisations
1407 // Including classes derived from them
1408 [] <typename TYPE>(::pointer<TYPE>&) {}(p);
1409};
1410
1411template < typename POINTER >
1412concept prototype_subparticle_pointer =
1413::std::is_base_of_v < ::subparticle, ::non_pointer < POINTER > >
1414|| pointer_derived<POINTER>;
1415
1416
1417using subparticle_pointer = ::pointer < ::subparticle >;
1418
1419class time;
1420
1421template < typename RUNNABLE >
1422concept prototype_runnable = requires(RUNNABLE r) {
1423
1424 { r() } ->::std::convertible_to<void>;
1425#if defined(MS_COMPILER)
1426 { r.get_run_timeout() } ->::std::convertible_to<::time>;
1427#else
1428 { r.get_run_timeout() } ->::std::convertible_to<class ::time>;
1429#endif
1430};
1431
1432
1433template < prototype_subparticle SUBPARTICLE >
1434::pointer < SUBPARTICLE > as_pointer(SUBPARTICLE* p)
1435{
1436
1437 return { p };
1438
1439}
1440
1441
1442template < prototype_subparticle SUBPARTICLE >
1443::pointer < SUBPARTICLE > as_pointer(const ::pointer < SUBPARTICLE > & p)
1444{
1445
1446 return { p };
1447
1448}
1449
1450
1451template < prototype_subparticle SUBPARTICLE >
1452::pointer < SUBPARTICLE > transfer_as_pointer(SUBPARTICLE* p)
1453{
1454
1455 return { ::transfer_t{}, p };
1456
1457}
1458
1459
1460class __pointer_site
1461{
1462public:
1463
1464
1465#if REFERENCING_DEBUGGING
1466
1467
1468 reference_referer * m_preferer;
1469
1470
1471 __pointer_site(const ::reference_referer & referer, ::reference_referer ** pprefererGet = nullptr)
1472 {
1473
1474 //m_preferer = øraw_new ::reference_referer(referer);
1475
1476 m_preferer = ::allocator::push_referer(referer);
1477
1478 if (pprefererGet)
1479 {
1480
1481 *pprefererGet = m_preferer;
1482
1483 }
1484
1485 }
1486
1487
1488#else
1489
1490
1491 __pointer_site()
1492 {
1493
1494
1495 }
1496
1497
1498#endif
1499
1500
1501 template < prototype_subparticle SUBPARTICLE >
1502 ::pointer < SUBPARTICLE > operator << (SUBPARTICLE* p)
1503 {
1504
1505#if REFERENCING_DEBUGGING
1506
1507 ::pointer < SUBPARTICLE > pointer({ transfer_t{}, p });
1508
1509 if (p->is_referencing_debugging_enabled())
1510 {
1511
1512 pointer.m_preferer = m_preferer;
1513
1514 }
1515
1516 p->on_after_construct(m_preferer);
1517
1518 return ::transfer(pointer);
1519
1520#else
1521
1522 return { transfer_t{}, p };
1523
1524#endif
1525
1526 }
1527
1528 template < prototype_subparticle SUBPARTICLE >
1529 ::pointer < SUBPARTICLE > operator += (SUBPARTICLE* p)
1530 {
1531
1532#if REFERENCING_DEBUGGING
1533
1534 //::allocator::_push_referer(m_preferer);
1535
1536 return p;
1537
1538#else
1539
1540 return p;
1541
1542#endif
1543 }
1544
1545
1546};
1547
1548
1549//inline static __pointer_site __g__pointer_site;
1550
1551//#if !REFERENCING_DEBUGGING
1552
1553#define __transfer_as_pointer __pointer_site(__refdbg_function_file_line__) <<
1554
1555#define __preferernew_transfer_as_pointer __pointer_site(__refdbg_function_file_line__preferernew) <<
1556
1557#define allocateø __transfer_as_pointer new
1558
1559#define __preferernew_allocate __preferernew_transfer_as_pointer new
1560
1561#define __as_pointer __pointer_site(__refdbg_function_file_line__) +=
1562
1563#define __retain __as_pointer
1564
1565//#endif
1566
1567
1568
1569class __g_initialize_pointer
1570{
1571public:
1572
1573
1574#if REFERENCING_DEBUGGING
1575
1576
1577 reference_referer* m_preferer;
1578
1579
1580#endif
1581
1582 ::particle * m_p;
1583
1584
1585 __g_initialize_pointer(::particle* p COMMA_REFERENCING_DEBUGGING_PARAMETERS_DECLARATION) :
1586 m_p(p)
1587 {
1588
1589
1590#if REFERENCING_DEBUGGING
1591
1592 m_preferer = ::allocator::push_referer(referer);
1593
1594 //if (pprefererGet)
1595 //{
1596
1597 // *pprefererGet = m_preferer;
1598
1599 //}
1600
1601#endif
1602
1603
1604 }
1605
1606
1607 template < typename TYPE >
1608 ::pointer < TYPE > operator << (TYPE * p)
1609 {
1610
1611#if REFERENCING_DEBUGGING
1612
1613 ::pointer < TYPE > pointer({ transfer_t{}, p });
1614
1615 if (p->is_referencing_debugging_enabled())
1616 {
1617
1618 pointer.m_preferer = m_preferer;
1619
1620 }
1621
1622 p->on_after_construct(m_preferer);
1623
1624 //return ::transfer(pointer);
1625
1626#else
1627
1628 ::pointer < TYPE > pointer{ transfer_t{}, p };
1629
1630#endif
1631
1632 pointer->initialize(m_p);
1633
1634 return ::transfer(pointer);
1635
1636 }
1637
1638};
1639
1640#define __initialize_pointer_with(P) __g_initialize_pointer(P __comma_refdbg_function_file_line__) <<
1641
1642#define __preferernew_initialize_pointer_with(P) __g_initialize_pointer(P __comma_refdbg_function_file_line__preferernew) <<
1643
1644#define __initialize_pointer __initialize_pointer_with(this)
1645
1646#define __preferernew_initialize_pointer __preferernew_initialize_pointer_with(this)
1647
1648#define __initialize_new_with(P) __initialize_pointer_with(P) new
1649
1650#define __preferernew_initialize_new_with(P) __preferernew_initialize_pointer_with(P) new
1651
1652#define __initialize_new __initialize_pointer new
1653
1654#define __preferernew_initialize_new __preferernew_initialize_pointer new
1655
1656
1657
1658class __site
1659{
1660public:
1661
1662 CLASS_DECL_ACME ::string operator()(const ::scoped_string & scopedstr);
1663
1664};
1665
1666
1667static inline __site __;
1668
1669
1670// template < typename TYPE >
1671// class scoped_pointer
1672// {
1673// public:
1674//
1675//
1676// TYPE * m_p;
1677//
1678//
1679// scoped_pointer(nullptr_t)
1680// {
1681//
1682// m_p = nullptr;
1683// }
1684//
1685// template < pointer_but_not_integral< TYPE > TOPIC_POINTER >
1686// scoped_pointer(TOPIC_POINTER p)
1687// {
1688//
1689// m_p = p;
1690//
1691// }
1692//
1693//
1694// // template < ::std::convertible_to< ::pointer < TYPE > > POINTER >
1695// // scoped_pointer(const POINTER & p)
1696// // {
1697// //
1698// // m_p = p.m_p;
1699// //
1700// // }
1701//
1702// operator TYPE *() {return m_p;}
1703//
1704// TYPE * operator->() {return m_p;}
1705//
1706// };
1707
1708
1709
1710
1711
1712template < typename TYPE, typename ...Args>
1713::pointer < TYPE > øcreate_pointer(Args &&... args)
1714{
1715
1716 return { transfer_t{}, new TYPE(::std::forward<Args>(args)...) };
1717
1718}
1719
1720
1721
__site
Definition pointer.h:1659
e_status
Definition e_status.h:30
factory::factory
Definition factory.h:201
lparam
Definition lparam.h:9
particle
Definition particle.h:95
pointer
Definition pointer.h:42
pointer::pointer
pointer(enum_create, PARTICLE *pparticle, ::factory::factory *pfactory=nullptr)
consumes a referer
Definition pointer.h:101
pointer::pointer
pointer(const T2 *p)
consumes a referer
Definition pointer.h:124
pointer::pointer
pointer(const ::pointer< T2 > &p)
consumes a referer
Definition pointer.h:185
pointer::pointer
pointer(const ::cast< T2 > &p)
consumes a referer
Definition pointer.h:193
pointer::pointer
pointer(transfer_t, T2 *p)
referer is transferred?
Definition pointer.h:117
pointer::pointer
pointer(enum_create_new, PARTICLE *pparticle)
consumes a referer
Definition pointer.h:85
subparticle
Definition subparticle.h:78
time
Definition aaa_time.h:13
wparam
Definition wparam.h:10
pointer_derived
Definition pointer.h:1405
prototype_runnable
Definition pointer.h:1422
prototype_subparticle_pointer
Definition pointer.h:1412
specializes
Checks if class type Specialisation (the implicit concept argument) is indeed a specialisation of Tem...
Definition pointer.h:1398
allocate_t
Definition _structures.h:7
no_initialize_t
Definition _tags.h:5
place_t
Definition pointer.h:9
pointer_type_t
Definition _structures.h:21
transfer_t
Definition _structures.h:6