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 
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 
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 
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 =
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 
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 
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 
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 
706 
711 
716  template <typename UPtr>
717  TransientConstRCPtr(const UPtr & u) : ptr(PtrTraits<UPtr>::barePointer(u)) {}
718 
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 
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 
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 
942  return RCPtr<T>::Create();
943  }
944 
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) {
1030  t.assignDynamic(u);
1031  return t;
1032  }
1033 
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 
1089 
1093  template <typename UPtr>
1094  static transient_const_pointer DynamicCast(const UPtr & u) {
1096  t.assignDynamic(u);
1097  return t;
1098  }
1099 
1103  template <typename UPtr>
1104  static transient_const_pointer ConstCast(const UPtr & u) {
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 */