ThePEG  1.8.0
RCPtr.h
1 // -*- C++ -*-
2 //
3 // RCPtr.h is a part of ThePEG - Toolkit for HEP Event Generation
4 // Copyright (C) 1999-2011 Leif Lonnblad
5 //
6 // ThePEG is licenced under version 2 of the GPL, see COPYING for details.
7 // Please respect the MCnet academic guidelines, see GUIDELINES for details.
8 //
9 #ifndef ThePEG_RCPtr_H
10 #define ThePEG_RCPtr_H
11 // This is the declaration of the RCPtrBase,
12 
13 
14 #include "ReferenceCounted.h"
15 #include "RCPtr.fh"
16 #include "PtrTraits.h"
17 
18 namespace ThePEG {
19 namespace Pointer {
20 
30 class RCPtrBase {
31 
34 
35 protected:
36 
40  void increment(const ReferenceCounted * rcp) {
41  if ( rcp ) rcp->incrementReferenceCount();
42  }
46  bool release(const ReferenceCounted * rcp) {
47  return rcp && rcp->decrementReferenceCount();
48  }
49 
50 };
51 
59 template <typename T>
60 class RCPtr: public RCPtrBase {
61 
62 public:
63 
65  typedef void iterator_category;
67  typedef void difference_type;
69  typedef T * pointer;
71  typedef const T * const_pointer;
73  typedef T & reference;
75  typedef const T & const_reference;
77  typedef T value_type;
78 
79 public:
80 
85  RCPtr() : ptr(0) {}
86 
90  RCPtr(const RCPtr & p) : ptr(p.ptr) { increment(); }
91 
96  template <typename UPtr>
97  RCPtr(const UPtr & u)
98  : ptr(PtrTraits<UPtr>::barePointer(u)) { increment(); }
99 
103  explicit RCPtr(pointer p) : ptr(p) { increment(); }
104 
109  ~RCPtr() { release(); }
110 
115  static RCPtr Create() {
116  RCPtr<T> p;
117  return p.create();
118  }
119 
124  static RCPtr Create(const_reference t) {
125  RCPtr<T> p;
126  return p.create(t);
127  }
128 
129 
134  RCPtr & create() {
135  release();
136  ptr = new T;
137  // increment(); // ReferenceCounted() constructor starts at 1
138  return *this;
139  }
140 
145  RCPtr & create(const_reference t) {
146  release();
147  ptr = new T(t);
148  // increment(); // ReferenceCounted() constructor starts at 1
149  return *this;
150  }
151 
155  RCPtr & operator=(const RCPtr & p) {
156  if ( ptr == p.ptr ) return *this;
157  release();
158  ptr = p.ptr;
159  increment();
160  return *this;
161  }
162 
167  template <typename UPtr>
168  RCPtr & operator=(const UPtr & u) {
169  if ( ptr == PtrTraits<UPtr>::barePointer(u) ) return *this;
170  release();
172  increment();
173  return *this;
174  }
175 
180  template <typename UPtr>
181  RCPtr & assignDynamic(const UPtr & u) {
182  pointer up = dynamic_cast<pointer>(PtrTraits<UPtr>::barePointer(u));
183  if ( ptr == up ) return *this;
184  release();
185  ptr = up;
186  increment();
187  return *this;
188  }
189 
194  template <typename UPtr>
195  RCPtr & assignConst(const UPtr & u) {
196  pointer up = const_cast<pointer>(PtrTraits<UPtr>::barePointer(u));
197  if ( ptr == up ) return *this;
198  release();
199  ptr = up;
200  increment();
201  return *this;
202  }
203 
207  void swap(RCPtr & p) {
208  const pointer tmp = ptr;
209  ptr = p.ptr;
210  p.ptr = tmp;
211  // std::swap(ptr, p.ptr);
212  }
213 
217  bool operator==(const RCPtr & p) const { return ptr == p.ptr; }
218 
222  bool operator!=(const RCPtr & p) const { return ptr != p.ptr; }
223 
227  bool operator==(const_pointer p) const { return ptr == p; }
228 
232  bool operator!=(const_pointer p) const { return ptr != p; }
233 
237  template <typename UPtr>
238  bool operator==(const UPtr & u) const {
239  return ptr == PtrTraits<UPtr>::barePointer(u);
240  }
241 
245  template <typename UPtr>
246  bool operator!=(const UPtr & u) const {
247  return ptr != PtrTraits<UPtr>::barePointer(u);
248  }
249 
253  bool operator<(const RCPtr & p) const {
254  return ( ptr && p.ptr && ptr->uniqueId != p.ptr->uniqueId ) ?
255  ptr->uniqueId < p.ptr->uniqueId : ptr < p.ptr;
256  }
257 
261  bool operator<(const_pointer p) const {
262  return ( ptr && p && ptr->uniqueId != p->uniqueId ) ?
263  ptr->uniqueId < p->uniqueId : ptr < p;
264  }
265 
269  bool operator!() const { return !ptr; }
270 
274  operator T * () const { return ptr; }
275 
279  pointer operator->() const { return ptr; }
280 
284  reference operator*() const { return *ptr; }
285 
286 private:
287 
292 
297  void release() { if ( RCPtrBase::release(ptr) ) delete ptr; }
298 
302  pointer ptr;
303 
304 };
305 
314 template <typename T>
315 class ConstRCPtr : public RCPtrBase {
316 
317 public:
318 
320  typedef void iterator_category;
322  typedef void difference_type;
324  typedef T * pointer;
326  typedef const T * const_pointer;
328  typedef T & reference;
330  typedef const T & const_reference;
332  typedef T value_type;
333 
334 public:
335 
339  ConstRCPtr() : ptr(0) {}
340 
344  ConstRCPtr(const ConstRCPtr & p) : ptr(p.ptr) { increment(); }
345 
350  template <typename UPtr>
351  ConstRCPtr(const UPtr & u) : ptr(PtrTraits<UPtr>::barePointer(u)) { increment(); }
352 
356  explicit ConstRCPtr(const_pointer p) : ptr(p) { increment(); }
357 
363 
368  if ( ptr == p.ptr ) return *this;
369  release();
370  ptr = p.ptr;
371  increment();
372  return *this;
373  }
374 
379  template <typename UPtr>
380  ConstRCPtr & operator=(const UPtr & u) {
381  if ( ptr == PtrTraits<UPtr>::barePointer(u) ) return *this;
382  release();
384  increment();
385  return *this;
386  }
387 
392  template <typename UPtr>
393  ConstRCPtr & assignDynamic(const UPtr & u) {
394  const_pointer up =
395  dynamic_cast<const_pointer>(PtrTraits<UPtr>::barePointer(u));
396  if ( ptr == up ) return *this;
397  release();
398  ptr = up;
399  increment();
400  return *this;
401  }
402 
406  void swap(ConstRCPtr & p) {
407  const const_pointer tmp = ptr;
408  ptr = p.ptr;
409  p.ptr = tmp;
410  // std::swap(ptr, p.ptr);
411  }
412 
416  bool operator==(const ConstRCPtr & p) const { return ptr == p.ptr; }
417 
421  bool operator!=(const ConstRCPtr & p) const { return ptr != p.ptr; }
422 
426  bool operator==(const_pointer p) const { return ptr == p; }
427 
431  bool operator!=(const_pointer p) const { return ptr != p; }
432 
436  template <typename UPtr>
437  bool operator==(const UPtr & u) const { return ptr == PtrTraits<UPtr>::barePointer(u); }
438 
442  template <typename UPtr>
443  bool operator!=(const UPtr & u) const { return ptr != PtrTraits<UPtr>::barePointer(u); }
444 
448  bool operator<(const ConstRCPtr & p) const {
449  return ( ptr && p.ptr && ptr->uniqueId != p.ptr->uniqueId ) ?
450  ptr->uniqueId < p.ptr->uniqueId : ptr < p.ptr;
451  }
452 
456  bool operator<(const_pointer p) const {
457  return ( ptr && p && ptr->uniqueId != p->uniqueId ) ?
458  ptr->uniqueId < p->uniqueId : ptr < p;
459  }
460 
464  bool operator!() const { return !ptr; }
465 
469  operator const T * () const { return ptr; }
470 
474  const_pointer operator->() const { return ptr; }
475 
479  const_reference operator*() const { return *ptr; }
480 
481 private:
482 
487 
492  void release() { if ( RCPtrBase::release(ptr) ) delete ptr; }
493 
497  const_pointer ptr;
498 
499 };
500 
508 template <typename T>
510 
511 public:
512 
514  typedef void iterator_category;
516  typedef void difference_type;
518  typedef T * pointer;
520  typedef const T * const_pointer;
522  typedef T & reference;
524  typedef const T & const_reference;
526  typedef T value_type;
527 
528 public:
529 
533  TransientRCPtr() : ptr(0) {}
534 
538  TransientRCPtr(const TransientRCPtr & p) : ptr(p.ptr) {}
539 
544  template <typename UPtr>
545  TransientRCPtr(const UPtr & u) : ptr(PtrTraits<UPtr>::barePointer(u)) {}
546 
550  explicit TransientRCPtr(pointer p) : ptr(p) {}
551 
556 
561  ptr = p.ptr;
562  return *this;
563  }
564 
569  template <typename UPtr>
570  TransientRCPtr & operator=(const UPtr & u) {
572  return *this;
573  }
574 
579  template <typename UPtr>
580  TransientRCPtr & assignDynamic(const UPtr & u) {
581  ptr = dynamic_cast<pointer>(PtrTraits<UPtr>::barePointer(u));
582  return *this;
583  }
584 
589  template <typename UPtr>
590  TransientRCPtr & assignConst(const UPtr & u) {
591  ptr = const_cast<pointer>(PtrTraits<UPtr>::barePointer(u));
592  return *this;
593  }
594 
598  bool operator==(const TransientRCPtr & p) const { return ptr == p.ptr; }
599 
603  bool operator!=(const TransientRCPtr & p) const { return ptr != p.ptr; }
604 
608  bool operator==(const_pointer p) const { return ptr == p; }
609 
613  bool operator!=(const_pointer p) const { return ptr != p; }
614 
618  template <typename UPtr>
619  bool operator==(const UPtr & u) const { return ptr == PtrTraits<UPtr>::barePointer(u); }
620 
624  template <typename UPtr>
625  bool operator!=(const UPtr & u) const { return ptr != PtrTraits<UPtr>::barePointer(u); }
626 
630  bool operator<(const TransientRCPtr & p) const {
631  return ( ptr && p.ptr && ptr->uniqueId != p.ptr->uniqueId ) ?
632  ptr->uniqueId < p.ptr->uniqueId : ptr < p.ptr;
633  }
634 
638  bool operator<(const_pointer p) const {
639  return ( ptr && p && ptr->uniqueId != p->uniqueId ) ?
640  ptr->uniqueId < p->uniqueId : ptr < p;
641  }
642 
646  bool operator!() const { return !ptr; }
647 
651  operator T * () const { return ptr; }
652 
656  pointer operator->() const { return ptr; }
657 
661  reference operator*() const { return *ptr; }
662 
663 private:
664 
668  pointer ptr;
669 
670 };
671 
680 template <typename T>
682 
683 public:
684 
686  typedef void iterator_category;
688  typedef void difference_type;
690  typedef T * pointer;
692  typedef const T * const_pointer;
694  typedef T & reference;
696  typedef const T & const_reference;
698  typedef T value_type;
699 
700 public:
701 
705  TransientConstRCPtr() : ptr(0) {}
706 
710  TransientConstRCPtr(const TransientConstRCPtr & p) : ptr(p.ptr) {}
711 
716  template <typename UPtr>
717  TransientConstRCPtr(const UPtr & u) : ptr(PtrTraits<UPtr>::barePointer(u)) {}
718 
722  explicit TransientConstRCPtr(const_pointer p) : ptr(p) {}
723 
728 
733  ptr = p.ptr;
734  return *this;
735  }
736 
741  template <typename UPtr>
742  TransientConstRCPtr & operator=(const UPtr & u) {
744  return *this;
745  }
746 
751  template <typename UPtr>
752  TransientConstRCPtr & assignDynamic(const UPtr & u) {
753  ptr = dynamic_cast<const_pointer>(PtrTraits<UPtr>::barePointer(u));
754  return *this;
755  }
756 
760  bool operator==(const TransientConstRCPtr & p) const { return ptr == p.ptr; }
761 
765  bool operator!=(const TransientConstRCPtr & p) const { return ptr != p.ptr; }
766 
770  bool operator==(const_pointer p) const { return ptr == p; }
771 
772 
776  bool operator!=(const_pointer p) const { return ptr != p; }
777 
781  template <typename UPtr>
782  bool operator==(const UPtr & u) const { return ptr == PtrTraits<UPtr>::barePointer(u); }
783 
787  template <typename UPtr>
788  bool operator!=(const UPtr & u) const { return ptr != PtrTraits<UPtr>::barePointer(u); }
789 
793  bool operator<(const TransientConstRCPtr & p) const {
794  return ( ptr && p.ptr && ptr->uniqueId != p.ptr->uniqueId ) ?
795  ptr->uniqueId < p.ptr->uniqueId : ptr < p.ptr;
796  }
797 
801  bool operator<(const_pointer p) const {
802  return ( ptr && p && ptr->uniqueId != p->uniqueId ) ?
803  ptr->uniqueId < p->uniqueId : ptr < p;
804  }
805 
809  bool operator!() const { return !ptr; }
810 
814  operator const T * () const { return ptr; }
815 
819  const_pointer operator->() const { return ptr; }
820 
824  const_reference operator*() const { return *ptr; }
825 
826 private:
827 
831  const_pointer ptr;
832 
833 };
834 
838 template <typename T>
839 struct PtrTraits< RCPtr<T> >: public PtrTraitsType {
840 
844  typedef typename RCPtr<T>::reference reference;
848  typedef RCPtr<T> pointer;
855 
859  static T * barePointer(const RCPtr<T> & p) { return p.operator->(); }
860 
864  static pointer create() { return RCPtr<T>::Create(); }
865 
869  static pointer create(const_reference t) { return RCPtr<T>::Create(t); }
870 
874  static void destroy(pointer) {}
875 
879  template <typename UPtr>
880  static pointer DynamicCast(const UPtr & u) {
881  pointer t;
882  t.assignDynamic(u);
883  return t;
884  }
885 
889  template <typename UPtr>
890  static pointer ConstCast(const UPtr & u) {
891  pointer t;
892  t.assignConst(u);
893  return t;
894  }
895 
899  static pointer PtrCast(T * t) {
900  return pointer(t);
901  }
902 
906  static const bool reference_counted = true;
907 
908 };
909 
913 template <typename T>
914 struct PtrTraits< ConstRCPtr<T> >: public PtrTraitsType {
915 
923  typedef RCPtr<T> pointer;
930 
934  static const T * barePointer(const ConstRCPtr<T> & p) {
935  return p.operator->();
936  }
937 
941  static const_pointer create() {
942  return RCPtr<T>::Create();
943  }
944 
948  static const_pointer create(const_reference t) {
949  return RCPtr<T>::Create(t);
950  }
951 
955  static void destroy(const_pointer) {}
956 
960  template <typename UPtr>
961  static const_pointer DynamicCast(const UPtr & u) {
962  const_pointer t;
963  t.assignDynamic(u);
964  return t;
965  }
966 
970  template <typename UPtr>
971  static const_pointer ConstCast(const UPtr & u) {
972  const_pointer t;
973  t.assignDynamic(u);
974  return t;
975  }
976 
980  static const_pointer PtrCast(const T * t) {
981  return const_pointer(t);
982  }
983 
987  static const bool reference_counted = true;
988 
989 };
990 
994 template <typename T>
995 struct PtrTraits< TransientRCPtr<T> >: public PtrTraitsType {
996 
1011 
1015  static T * barePointer(const TransientRCPtr<T> & p) {
1016  return p.operator->();
1017  }
1018 
1022  static void destroy(transient_pointer) {}
1023 
1027  template <typename UPtr>
1028  static transient_pointer DynamicCast(const UPtr & u) {
1029  transient_pointer t;
1030  t.assignDynamic(u);
1031  return t;
1032  }
1033 
1037  static transient_pointer ConstCast(transient_const_pointer c) {
1038  transient_pointer t;
1039  t.assignConst(c);
1040  return t;
1041  }
1042 
1046  static transient_pointer PtrCast(T * t) {
1047  return transient_pointer(t);
1048  }
1049 
1053  static const bool reference_counted = false;
1054 
1055 };
1056 
1060 template <typename T>
1062 
1077 
1081  static const T * barePointer(const TransientConstRCPtr<T> & p) {
1082  return p.operator->();
1083  }
1084 
1088  static void destroy(transient_const_pointer) {}
1089 
1093  template <typename UPtr>
1094  static transient_const_pointer DynamicCast(const UPtr & u) {
1095  transient_const_pointer t;
1096  t.assignDynamic(u);
1097  return t;
1098  }
1099 
1103  template <typename UPtr>
1104  static transient_const_pointer ConstCast(const UPtr & u) {
1105  transient_const_pointer t;
1106  t.assignConst(u);
1107  return t;
1108  }
1109 
1113  static transient_const_pointer PtrCast(const T * t) {
1114  return transient_const_pointer(t);
1115  }
1116 
1120  static const bool reference_counted = false;
1121 
1122 };
1123 
1124 }
1125 }
1126 
1127 namespace std {
1128 
1133 template <typename T>
1134 inline void swap(ThePEG::Pointer::RCPtr<T> & t1,
1136  t1.swap(t2);
1137 }
1138 
1143 template <typename T>
1144 inline void swap(ThePEG::Pointer::ConstRCPtr<T> & t1,
1146  t1.swap(t2);
1147 }
1148 
1149 }
1150 
1151 #endif /* ThePEG_RCPtr_H */
TransientRCPtr(const UPtr &u)
Copyconstructor for class UPtr which has operator-> defined resulting in a value implicitly convertib...
Definition: RCPtr.h:545
T value_type
Template argument typedef.
Definition: RCPtr.h:332
ConstRCPtr(const_pointer p)
Construction from real pointer.
Definition: RCPtr.h:356
ConstRCPtr< T >::value_type value_type
Template argument typedef.
Definition: RCPtr.h:917
The PtrTraits class is used everywhere in ThePEG to interface to the pointers which are handled...
Definition: PtrTraits.h:39
pointer ptr
The actual pointer.
Definition: RCPtr.h:302
bool release(const ReferenceCounted *rcp)
Decrement the counter of a reference counted object.
Definition: RCPtr.h:46
static pointer ConstCast(const UPtr &u)
Cast away constness.
Definition: RCPtr.h:890
TransientRCPtr & operator=(const TransientRCPtr &p)
Assignment.
Definition: RCPtr.h:560
TransientConstRCPtr & assignDynamic(const UPtr &u)
Assignment from class UPtr which has operator-> defined resulting in a value which can be cast dynami...
Definition: RCPtr.h:752
TransientRCPtr & assignDynamic(const UPtr &u)
Assignment from class UPtr which has operator-> defined resulting in a value which can be cast dynami...
Definition: RCPtr.h:580
~TransientRCPtr()
Destructor.
Definition: RCPtr.h:555
static transient_pointer PtrCast(T *t)
Cast from a basic pointer.
Definition: RCPtr.h:1046
RCPtr< T >::reference reference
Template argument typedef.
Definition: RCPtr.h:844
RCPtr & operator=(const UPtr &u)
Assignment from class UPtr which has operator-> defined resulting in a value implicitly convertible t...
Definition: RCPtr.h:168
T & reference
Template argument typedef.
Definition: RCPtr.h:328
ConstRCPtr< T > const_pointer
Template argument typedef.
Definition: RCPtr.h:850
void iterator_category
Template argument typedef.
Definition: RCPtr.h:320
reference operator*() const
Dereferencing.
Definition: RCPtr.h:284
void release()
Stop pointing to the current object and delete it if this was the last pointer to it...
Definition: RCPtr.h:297
bool operator!=(const_pointer p) const
Test for inequality of the underlying pointers.
Definition: RCPtr.h:776
TransientConstRCPtr< T > transient_const_pointer
Template argument typedef.
Definition: RCPtr.h:854
static transient_const_pointer ConstCast(const UPtr &u)
Cast away constness.
Definition: RCPtr.h:1104
bool operator==(const UPtr &u) const
Test for equality of the underlying pointers.
Definition: RCPtr.h:437
bool operator!=(const TransientRCPtr &p) const
Test for inequality of the underlying pointers.
Definition: RCPtr.h:603
void swap(RCPtr &p)
Make p point to the object pointed to by this and vice versa.
Definition: RCPtr.h:207
static const_pointer create(const_reference t)
Create an copy of an object and return a pointer to it.
Definition: RCPtr.h:948
void increment(const ReferenceCounted *rcp)
Increment the counter of a reference counted object.
Definition: RCPtr.h:40
void release()
Stop pointing to the current object and delete it if this was the last pointer to it...
Definition: RCPtr.h:492
TransientRCPtr< T > transient_pointer
Template argument typedef.
Definition: RCPtr.h:1074
TransientConstRCPtr & operator=(const TransientConstRCPtr &p)
Assignment.
Definition: RCPtr.h:732
void incrementReferenceCount() const
Increment the reference count.
TransientRCPtr & assignConst(const UPtr &u)
Assignment from class UPtr which has operator-> defined resulting in a value whcih can be const_cast&#39;...
Definition: RCPtr.h:590
T value_type
Template argument typedef.
Definition: RCPtr.h:77
TransientRCPtr< T >::const_reference const_reference
Template argument typedef.
Definition: RCPtr.h:1002
TransientConstRCPtr is a simple wrapper around a bare const pointer which can be assigned to and from...
Definition: RCPtr.h:681
static pointer PtrCast(T *t)
Cast from a basic pointer.
Definition: RCPtr.h:899
bool operator!=(const ConstRCPtr &p) const
Test for inequality of the underlying pointers.
Definition: RCPtr.h:421
ConstRCPtr< T > const_pointer
Template argument typedef.
Definition: RCPtr.h:925
TransientRCPtr is a simple wrapper around a bare pointer which can be assigned to and from an RCPtr a...
Definition: RCPtr.h:509
STL namespace.
bool operator==(const_pointer p) const
Test for equality of the underlying pointers.
Definition: RCPtr.h:770
ConstRCPtr is a reference counted (smart) const pointer.
Definition: RCPtr.h:315
const T & const_reference
Template argument typedef.
Definition: RCPtr.h:75
static transient_pointer ConstCast(transient_const_pointer c)
Cast away constness.
Definition: RCPtr.h:1037
void increment()
Increment the counter of the object pointed to.
Definition: RCPtr.h:291
ConstRCPtr< T >::const_reference const_reference
Template argument typedef.
Definition: RCPtr.h:921
bool operator==(const_pointer p) const
Test for equality of the underlying pointers.
Definition: RCPtr.h:227
This is the main namespace within which all identifiers in ThePEG are declared.
Definition: FactoryBase.h:28
const_reference operator*() const
Dereferencing.
Definition: RCPtr.h:824
bool operator<(const_pointer p) const
Test for ordering.
Definition: RCPtr.h:638
void difference_type
Template argument typedef.
Definition: RCPtr.h:688
const T * const_pointer
Template argument typedef.
Definition: RCPtr.h:326
bool operator<(const_pointer p) const
Test for ordering.
Definition: RCPtr.h:456
T & reference
Template argument typedef.
Definition: RCPtr.h:522
ConstRCPtr & operator=(const UPtr &u)
Assignment from class UPtr which has operator-> defined resulting in a value implicitly convertible t...
Definition: RCPtr.h:380
static transient_pointer DynamicCast(const UPtr &u)
Cast dynamically.
Definition: RCPtr.h:1028
const T * const_pointer
Template argument typedef.
Definition: RCPtr.h:520
RCPtr & assignDynamic(const UPtr &u)
Assignment from class UPtr which has operator-> defined resulting in a value which can be cast dynami...
Definition: RCPtr.h:181
~RCPtr()
Destructor.
Definition: RCPtr.h:109
TransientConstRCPtr(const UPtr &u)
Copyconstructor for class UPtr which has operator-> defined resulting in a value implicitly convertib...
Definition: RCPtr.h:717
const_pointer ptr
The actual pointer.
Definition: RCPtr.h:497
RCPtr(const UPtr &u)
Copy constructor for class UPtr which has operator-> defined resulting in a value implicitly converti...
Definition: RCPtr.h:97
RCPtr & assignConst(const UPtr &u)
Assignment from class UPtr which has operator-> defined resulting in a value which can be const_cast&#39;...
Definition: RCPtr.h:195
bool operator!=(const UPtr &u) const
Test for inequality of the underlying pointers.
Definition: RCPtr.h:625
T value_type
Template argument typedef.
Definition: RCPtr.h:526
const T & const_reference
Template argument typedef.
Definition: RCPtr.h:524
ConstRCPtr()
Constructor for null pointer.
Definition: RCPtr.h:339
void swap(ConstRCPtr &p)
Make p point to the object pointed to by this and vice versa.
Definition: RCPtr.h:406
void iterator_category
Template argument typedef.
Definition: RCPtr.h:514
static T * barePointer(const RCPtr< T > &p)
Return the bare pointer of the given pointer object.
Definition: RCPtr.h:859
TransientRCPtr< T >::value_type value_type
Template argument typedef.
Definition: RCPtr.h:998
const T & const_reference
Template argument typedef.
Definition: RCPtr.h:330
const T & const_reference
Template argument typedef.
Definition: RCPtr.h:696
bool operator==(const_pointer p) const
Test for equality of the underlying pointers.
Definition: RCPtr.h:426
RCPtr & create(const_reference t)
Allocate and copy-construct an object of class T and point to it, possibly deleting the object pointe...
Definition: RCPtr.h:145
TransientConstRCPtr< T >::reference reference
Template argument typedef.
Definition: RCPtr.h:1066
static pointer create(const_reference t)
Create an copy of an object and return a pointer to it.
Definition: RCPtr.h:869
ReferenceCounted::CounterType CounterType
Get counter type from ReferenceCounted class.
Definition: RCPtr.h:33
T * pointer
Template argument typedef.
Definition: RCPtr.h:324
bool operator!=(const UPtr &u) const
Test for inequality of the underlying pointers.
Definition: RCPtr.h:246
pointer operator->() const
Member access.
Definition: RCPtr.h:279
static const_pointer ConstCast(const UPtr &u)
Cast away constness.
Definition: RCPtr.h:971
TransientConstRCPtr< T > transient_const_pointer
Template argument typedef.
Definition: RCPtr.h:1076
static const T * barePointer(const TransientConstRCPtr< T > &p)
Return the bare pointer of the given pointer object.
Definition: RCPtr.h:1081
T * pointer
Template argument typedef.
Definition: RCPtr.h:69
bool operator!=(const UPtr &u) const
Test for inequality of the underlying pointers.
Definition: RCPtr.h:788
bool operator==(const TransientConstRCPtr &p) const
Test for equality of the underlying pointers.
Definition: RCPtr.h:760
reference operator*() const
Dereferencing.
Definition: RCPtr.h:661
TransientRCPtr< T > transient_pointer
Template argument typedef.
Definition: RCPtr.h:852
static void destroy(const_pointer)
Destroy the object pointed to.
Definition: RCPtr.h:955
bool operator<(const TransientRCPtr &p) const
Test for ordering.
Definition: RCPtr.h:630
static transient_const_pointer DynamicCast(const UPtr &u)
Cast dynamically.
Definition: RCPtr.h:1094
bool operator<(const RCPtr &p) const
Test for ordering.
Definition: RCPtr.h:253
static const_pointer create()
Create an object and return a pointer to it.
Definition: RCPtr.h:941
T value_type
Template argument typedef.
Definition: RCPtr.h:698
TransientRCPtr< T > transient_pointer
Template argument typedef.
Definition: RCPtr.h:927
static RCPtr Create(const_reference t)
Allocate and copy-construct an object of class T and return a RCPtr to it.
Definition: RCPtr.h:124
RCPtr(const RCPtr &p)
Copy constructor.
Definition: RCPtr.h:90
TransientConstRCPtr & operator=(const UPtr &u)
Assignment from class UPtr which has operator-> defined resulting in a value implicitly convertible t...
Definition: RCPtr.h:742
void difference_type
Template argument typedef.
Definition: RCPtr.h:322
TransientRCPtr< T >::reference reference
Template argument typedef.
Definition: RCPtr.h:1000
RCPtr & operator=(const RCPtr &p)
Assignment.
Definition: RCPtr.h:155
const_pointer ptr
The actual pointer.
Definition: RCPtr.h:831
const_reference operator*() const
Dereferencing.
Definition: RCPtr.h:479
ConstRCPtr & assignDynamic(const UPtr &u)
Assignment from class UPtr which has operator-> defined resulting in a value which can be cast dynami...
Definition: RCPtr.h:393
static void destroy(pointer)
Destroy the object pointed to.
Definition: RCPtr.h:874
bool operator!=(const UPtr &u) const
Test for inequality of the underlying pointers.
Definition: RCPtr.h:443
bool operator==(const_pointer p) const
Test for equality of the underlying pointers.
Definition: RCPtr.h:608
void iterator_category
Template argument typedef.
Definition: RCPtr.h:65
bool operator!() const
Returns true if the underlying pointer is null.
Definition: RCPtr.h:809
bool operator<(const TransientConstRCPtr &p) const
Test for ordering.
Definition: RCPtr.h:793
bool operator!() const
Returns true if the underlying pointer is null.
Definition: RCPtr.h:269
RCPtr is a reference counted (smart) pointer.
Definition: RCPtr.h:60
bool operator!() const
Returns true if the underlying pointer is null.
Definition: RCPtr.h:646
bool operator==(const UPtr &u) const
Test for equality of the underlying pointers.
Definition: RCPtr.h:238
bool operator==(const RCPtr &p) const
Test for equality of the underlying pointers.
Definition: RCPtr.h:217
const T * const_pointer
Template argument typedef.
Definition: RCPtr.h:71
RCPtr< T > pointer
Template argument typedef.
Definition: RCPtr.h:848
const_pointer operator->() const
Member access.
Definition: RCPtr.h:474
TransientConstRCPtr< T >::value_type value_type
Template argument typedef.
Definition: RCPtr.h:1064
TransientRCPtr & operator=(const UPtr &u)
Assignment from class UPtr which has operator-> defined resulting in a value implicitly convertible t...
Definition: RCPtr.h:570
bool operator==(const UPtr &u) const
Test for equality of the underlying pointers.
Definition: RCPtr.h:619
static T * barePointer(const TransientRCPtr< T > &p)
Return the bare pointer of the given pointer object.
Definition: RCPtr.h:1015
bool operator<(const_pointer p) const
Test for ordering.
Definition: RCPtr.h:261
TransientConstRCPtr(const_pointer p)
Construction from real pointer.
Definition: RCPtr.h:722
bool decrementReferenceCount() const
Decrement with the reference count.
static const T * barePointer(const ConstRCPtr< T > &p)
Return the bare pointer of the given pointer object.
Definition: RCPtr.h:934
RCPtrBase is the base class of RCPtr and ConstRCPtr which are reference counted (smart) pointers...
Definition: RCPtr.h:30
PtrTraitsType is an empty non-polymorphic base class for all PtrTraits classes.
Definition: PtrTraits.h:20
bool operator==(const ConstRCPtr &p) const
Test for equality of the underlying pointers.
Definition: RCPtr.h:416
TransientRCPtr< T > transient_pointer
Template argument typedef.
Definition: RCPtr.h:1008
unsigned int CounterType
The integer type used for counting.
const T * const_pointer
Template argument typedef.
Definition: RCPtr.h:692
~ConstRCPtr()
Destructor.
Definition: RCPtr.h:362
ReferenceCounted must be the (virtual) base class of all classes which may be pointed to by the RCPtr...
bool operator!=(const TransientConstRCPtr &p) const
Test for inequality of the underlying pointers.
Definition: RCPtr.h:765
TransientConstRCPtr< T > transient_const_pointer
Template argument typedef.
Definition: RCPtr.h:1010
bool operator!=(const_pointer p) const
Test for inequality of the underlying pointers.
Definition: RCPtr.h:613
TransientRCPtr(pointer p)
Construction from real pointer.
Definition: RCPtr.h:550
TransientRCPtr()
Constructor for null pointer.
Definition: RCPtr.h:533
T & reference
Template argument typedef.
Definition: RCPtr.h:73
bool operator==(const UPtr &u) const
Test for equality of the underlying pointers.
Definition: RCPtr.h:782
ConstRCPtr(const ConstRCPtr &p)
Copy constructor.
Definition: RCPtr.h:344
bool operator<(const ConstRCPtr &p) const
Test for ordering.
Definition: RCPtr.h:448
TransientConstRCPtr()
Constructor for null pointer.
Definition: RCPtr.h:705
static void destroy(transient_const_pointer)
Destroy the object pointed to.
Definition: RCPtr.h:1088
~TransientConstRCPtr()
Destructor.
Definition: RCPtr.h:727
ConstRCPtr< T > const_pointer
Template argument typedef.
Definition: RCPtr.h:1072
pointer ptr
The actual pointer.
Definition: RCPtr.h:668
T * pointer
Template argument typedef.
Definition: RCPtr.h:690
void increment()
Increment the counter of the object pointed to.
Definition: RCPtr.h:486
bool operator!=(const_pointer p) const
Test for inequality of the underlying pointers.
Definition: RCPtr.h:431
T & reference
Template argument typedef.
Definition: RCPtr.h:694
RCPtr< T > pointer
Template argument typedef.
Definition: RCPtr.h:1004
ConstRCPtr & operator=(const ConstRCPtr &p)
Assignment.
Definition: RCPtr.h:367
const_pointer operator->() const
Member access.
Definition: RCPtr.h:819
RCPtr< T > pointer
Template argument typedef.
Definition: RCPtr.h:1070
RCPtr< T >::const_reference const_reference
Template argument typedef.
Definition: RCPtr.h:846
TransientRCPtr(const TransientRCPtr &p)
Copy constructor.
Definition: RCPtr.h:538
RCPtr(pointer p)
Construction from real pointer.
Definition: RCPtr.h:103
void difference_type
Template argument typedef.
Definition: RCPtr.h:516
static transient_const_pointer PtrCast(const T *t)
Cast from a basic pointer.
Definition: RCPtr.h:1113
T * pointer
Template argument typedef.
Definition: RCPtr.h:518
bool operator==(const TransientRCPtr &p) const
Test for equality of the underlying pointers.
Definition: RCPtr.h:598
ConstRCPtr< T > const_pointer
Template argument typedef.
Definition: RCPtr.h:1006
TransientConstRCPtr(const TransientConstRCPtr &p)
Copy constructor.
Definition: RCPtr.h:710
bool operator!=(const_pointer p) const
Test for inequality of the underlying pointers.
Definition: RCPtr.h:232
bool operator<(const_pointer p) const
Test for ordering.
Definition: RCPtr.h:801
pointer operator->() const
Member access.
Definition: RCPtr.h:656
TransientConstRCPtr< T >::const_reference const_reference
Template argument typedef.
Definition: RCPtr.h:1068
void difference_type
Template argument typedef.
Definition: RCPtr.h:67
bool operator!=(const RCPtr &p) const
Test for inequality of the underlying pointers.
Definition: RCPtr.h:222
static void destroy(transient_pointer)
Destroy the object pointed to.
Definition: RCPtr.h:1022
void iterator_category
Template argument typedef.
Definition: RCPtr.h:686
ConstRCPtr(const UPtr &u)
Copyconstructor for class UPtr which has operator-> defined resulting in a value implicitly convertib...
Definition: RCPtr.h:351
static pointer DynamicCast(const UPtr &u)
Cast dynamically.
Definition: RCPtr.h:880
ConstRCPtr< T >::reference reference
Template argument typedef.
Definition: RCPtr.h:919
TransientConstRCPtr< T > transient_const_pointer
Template argument typedef.
Definition: RCPtr.h:929
RCPtr & create()
Allocate and construct an object of class T and point to it, possibly deleting the object pointed to ...
Definition: RCPtr.h:134
static pointer create()
Create an object and return a pointer to it.
Definition: RCPtr.h:864
static RCPtr Create()
Allocate and construct an object of class T and return a RCPtr to it.
Definition: RCPtr.h:115
RCPtr< T >::value_type value_type
Template argument typedef.
Definition: RCPtr.h:842
RCPtr< T > pointer
Template argument typedef.
Definition: RCPtr.h:923
static const_pointer DynamicCast(const UPtr &u)
Cast dynamically.
Definition: RCPtr.h:961
bool operator!() const
Returns true if the underlying pointer is null.
Definition: RCPtr.h:464
static const_pointer PtrCast(const T *t)
Cast from a basic pointer.
Definition: RCPtr.h:980