RCPtr.h

// -*- C++ -*-
//
// RCPtr.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_RCPtr_H
#define ThePEG_RCPtr_H
// This is the declaration of the RCPtrBase,
 
 
#include "ReferenceCounted.h"
#include "RCPtr.fh"
#include "PtrTraits.h"
 
namespace ThePEG {
namespace Pointer {
 
class RCPtrBase {
 
  typedef ReferenceCounted::CounterType CounterType;
 
protected:
 
  void increment(const ReferenceCounted * rcp) {
    if ( rcp ) rcp->incrementReferenceCount();
  }
  bool release(const ReferenceCounted * rcp) {
    return rcp && rcp->decrementReferenceCount();
  }
 
};
 
template <typename T>
class RCPtr: public RCPtrBase {
 
public:
 
  typedef void iterator_category;
  typedef void difference_type;
  typedef T * pointer;
  typedef const T * const_pointer;
  typedef T & reference;
  typedef const T & const_reference;
  typedef T value_type;
 
public:
 
  RCPtr() : ptr(nullptr) {}
 
  RCPtr( decltype(nullptr) ) : ptr(nullptr) {}
 
  RCPtr(const RCPtr & p) : ptr(p.ptr) { increment(); }
 
  template <typename UPtr>
  RCPtr(const UPtr & u) 
    : ptr(PtrTraits<UPtr>::barePointer(u)) { increment(); }
 
  explicit RCPtr(pointer p) : ptr(p) { increment(); }
 
  ~RCPtr() { release(); }
 
  static RCPtr Create() {
    RCPtr<T> p;
    return p.create();
  }
 
  static RCPtr Create(const_reference t) {
    RCPtr<T> p;
    return p.create(t);
  }
 
 
  RCPtr & create() {
    release();
    ptr = new T;
    //  increment(); // ReferenceCounted() constructor starts at 1
    return *this;
  }
 
  RCPtr & create(const_reference t) {
    release();
    ptr = new T(t);
    //  increment(); // ReferenceCounted() constructor starts at 1
    return *this;
  }
 
  RCPtr & operator=(const RCPtr & p) {
    if ( ptr == p.ptr ) return *this;
    release();
    ptr = p.ptr;
    increment();
    return *this;
  }
 
  template <typename UPtr>
  RCPtr & operator=(const UPtr & u) {
    if ( ptr == PtrTraits<UPtr>::barePointer(u) ) return *this;
    release();
    ptr = PtrTraits<UPtr>::barePointer(u);
    increment();
    return *this;
  }
 
  template <typename UPtr>
  RCPtr & assignDynamic(const UPtr & u) {
    pointer up = dynamic_cast<pointer>(PtrTraits<UPtr>::barePointer(u));
    if ( ptr == up ) return *this;
    release();
    ptr = up;
    increment();
    return *this;
  }
 
  template <typename UPtr>
  RCPtr & assignConst(const UPtr & u) {
    pointer up = const_cast<pointer>(PtrTraits<UPtr>::barePointer(u));
    if ( ptr == up ) return *this;
    release();
    ptr = up;
    increment();
    return *this;
  }
 
  void swap(RCPtr & p) {
    const pointer tmp = ptr;
    ptr = p.ptr;
    p.ptr = tmp;
    //  std::swap(ptr, p.ptr);
  }
 
  bool operator==(const RCPtr & p) const { return ptr == p.ptr; }
 
  bool operator!=(const RCPtr & p) const { return ptr != p.ptr; }
 
  bool operator==(const_pointer p) const { return ptr == p; }
 
  bool operator!=(const_pointer p) const { return ptr != p; }
 
  template <typename UPtr>
  bool operator==(const UPtr & u) const {
    return ptr == PtrTraits<UPtr>::barePointer(u);
  }
 
  template <typename UPtr>
  bool operator!=(const UPtr & u) const {
    return ptr != PtrTraits<UPtr>::barePointer(u);
  }
 
  bool operator<(const RCPtr & p) const {
    return ( ptr && p.ptr && ptr->uniqueId != p.ptr->uniqueId ) ?
      ptr->uniqueId < p.ptr->uniqueId : ptr < p.ptr;
  }
 
  bool operator<(const_pointer p) const {
    return ( ptr && p && ptr->uniqueId != p->uniqueId ) ?
      ptr->uniqueId < p->uniqueId : ptr < p;
  }
 
  bool operator!() const { return !ptr; }
 
  operator T * () const { return ptr; }
 
  pointer operator->() const { return ptr; }
 
  reference operator*() const { return *ptr; }
 
private:
 
  void increment() { RCPtrBase::increment(ptr); }
 
  void release() { if ( RCPtrBase::release(ptr) )  delete ptr; }
   
  pointer ptr;
 
};
 
template <typename T>
class ConstRCPtr : public RCPtrBase {
 
public:
 
  typedef void iterator_category;
  typedef void difference_type;
  typedef T * pointer;
  typedef const T * const_pointer;
  typedef T & reference;
  typedef const T & const_reference;
  typedef T value_type;
 
public:
 
  ConstRCPtr() : ptr(nullptr) {}
 
  ConstRCPtr( decltype(nullptr) ) : ptr(nullptr) {}
 
  ConstRCPtr(const ConstRCPtr & p) : ptr(p.ptr) { increment(); }
 
  template <typename UPtr>
  ConstRCPtr(const UPtr & u) : ptr(PtrTraits<UPtr>::barePointer(u)) { increment(); }
 
  explicit ConstRCPtr(const_pointer p) : ptr(p) { increment(); }
 
  ~ConstRCPtr() { release(); }
 
  ConstRCPtr & operator=(const ConstRCPtr & p) {
    if ( ptr == p.ptr ) return *this;
    release();
    ptr = p.ptr;
    increment();
    return *this;
  }
  
  template <typename UPtr>
  ConstRCPtr & operator=(const UPtr & u) {
    if ( ptr == PtrTraits<UPtr>::barePointer(u) ) return *this;
    release();
    ptr = PtrTraits<UPtr>::barePointer(u);
    increment();
    return *this;
  }
 
  template <typename UPtr>
  ConstRCPtr & assignDynamic(const UPtr & u) {
    const_pointer up =
      dynamic_cast<const_pointer>(PtrTraits<UPtr>::barePointer(u));
    if ( ptr == up ) return *this;
    release();
    ptr = up;
    increment();
    return *this;
  }
 
  void swap(ConstRCPtr & p) {
    const const_pointer tmp = ptr;
    ptr = p.ptr;
    p.ptr = tmp;
    //  std::swap(ptr, p.ptr);
  }  
 
  bool operator==(const ConstRCPtr & p) const { return ptr == p.ptr; }
 
  bool operator!=(const ConstRCPtr & p) const { return ptr != p.ptr; }
 
  bool operator==(const_pointer p) const { return ptr == p; }
 
  bool operator!=(const_pointer p) const { return ptr != p; }
 
  template <typename UPtr>
    bool operator==(const UPtr & u) const { return ptr == PtrTraits<UPtr>::barePointer(u); }
 
  template <typename UPtr>
  bool operator!=(const UPtr & u) const { return ptr != PtrTraits<UPtr>::barePointer(u); }
 
  bool operator<(const ConstRCPtr & p) const {
    return ( ptr && p.ptr && ptr->uniqueId != p.ptr->uniqueId ) ?
      ptr->uniqueId < p.ptr->uniqueId : ptr < p.ptr;
  }
 
  bool operator<(const_pointer p) const {
    return ( ptr && p && ptr->uniqueId != p->uniqueId ) ?
      ptr->uniqueId < p->uniqueId : ptr < p;
  }
 
  bool operator!() const { return !ptr; }
 
  operator const T * () const { return ptr; }
 
  const_pointer operator->() const { return ptr; }
 
  const_reference operator*() const { return *ptr; }
 
private:
 
  void increment() { RCPtrBase::increment(ptr); }
 
  void release() { if ( RCPtrBase::release(ptr) ) delete ptr; }
   
  const_pointer ptr;
 
};
 
template <typename T>
class TransientRCPtr {
 
public:
 
  typedef void iterator_category;
  typedef void difference_type;
  typedef T * pointer;
  typedef const T * const_pointer;
  typedef T & reference;
  typedef const T & const_reference;
  typedef T value_type;
 
public:
 
  TransientRCPtr() : ptr(nullptr) {}
 
  TransientRCPtr( decltype(nullptr) ) : ptr(nullptr) {}
 
  TransientRCPtr(const TransientRCPtr & p) : ptr(p.ptr) {}
 
  template <typename UPtr>
  TransientRCPtr(const UPtr & u) : ptr(PtrTraits<UPtr>::barePointer(u)) {}
 
  explicit TransientRCPtr(pointer p) : ptr(p) {}
 
  ~TransientRCPtr() {}
 
  TransientRCPtr & operator=(const TransientRCPtr & p) {
    ptr = p.ptr;
    return *this;
  }
 
  template <typename UPtr>
  TransientRCPtr & operator=(const UPtr & u) {
    ptr = PtrTraits<UPtr>::barePointer(u);
    return *this;
  }
 
  template <typename UPtr>
  TransientRCPtr & assignDynamic(const UPtr & u) {
    ptr = dynamic_cast<pointer>(PtrTraits<UPtr>::barePointer(u));
    return *this;
  }
 
  template <typename UPtr>
  TransientRCPtr & assignConst(const UPtr & u) {
    ptr = const_cast<pointer>(PtrTraits<UPtr>::barePointer(u));
    return *this;
  }
 
  bool operator==(const TransientRCPtr & p) const { return ptr == p.ptr; }
 
  bool operator!=(const TransientRCPtr & p) const { return ptr != p.ptr; }
 
  bool operator==(const_pointer p) const { return ptr == p; }
 
  bool operator!=(const_pointer p) const { return ptr != p; }
 
  template <typename UPtr>
  bool operator==(const UPtr & u) const { return ptr == PtrTraits<UPtr>::barePointer(u); }
 
  template <typename UPtr>
  bool operator!=(const UPtr & u) const { return ptr != PtrTraits<UPtr>::barePointer(u); }
 
  bool operator<(const TransientRCPtr & p) const {
    return ( ptr && p.ptr && ptr->uniqueId != p.ptr->uniqueId ) ?
      ptr->uniqueId < p.ptr->uniqueId : ptr < p.ptr;
  }
 
  bool operator<(const_pointer p) const {
    return ( ptr && p && ptr->uniqueId != p->uniqueId ) ?
      ptr->uniqueId < p->uniqueId : ptr < p;
  }
 
  bool operator!() const { return !ptr; }
 
  operator T * () const { return ptr; }
 
  pointer operator->() const { return ptr; }
 
  reference operator*() const { return *ptr; }
 
private:
 
  pointer ptr;
 
};
 
template <typename T>
class TransientConstRCPtr {
 
public:
 
  typedef void iterator_category;
  typedef void difference_type;
  typedef T * pointer;
  typedef const T * const_pointer;
  typedef T & reference;
  typedef const T & const_reference;
  typedef T value_type;
 
public:
 
  TransientConstRCPtr() : ptr(nullptr) {}
 
  TransientConstRCPtr( decltype(nullptr) ) : ptr(nullptr) {}
 
  TransientConstRCPtr(const TransientConstRCPtr & p) : ptr(p.ptr) {}
 
  template <typename UPtr>
  TransientConstRCPtr(const UPtr & u) : ptr(PtrTraits<UPtr>::barePointer(u)) {}
 
  explicit TransientConstRCPtr(const_pointer p) : ptr(p) {}
 
  ~TransientConstRCPtr() {}
 
  TransientConstRCPtr & operator=(const TransientConstRCPtr & p) {
    ptr = p.ptr;
    return *this;
  }
 
  template <typename UPtr>
  TransientConstRCPtr & operator=(const UPtr & u) {
    ptr = PtrTraits<UPtr>::barePointer(u);
    return *this;
  }
 
  template <typename UPtr>
  TransientConstRCPtr & assignDynamic(const UPtr & u) {
    ptr = dynamic_cast<const_pointer>(PtrTraits<UPtr>::barePointer(u));
    return *this;
  }
 
  bool operator==(const TransientConstRCPtr & p) const { return ptr == p.ptr; }
 
  bool operator!=(const TransientConstRCPtr & p) const { return ptr != p.ptr; }
 
  bool operator==(const_pointer p) const { return ptr == p; }
 
 
  bool operator!=(const_pointer p) const { return ptr != p; }
 
  template <typename UPtr>
  bool operator==(const UPtr & u) const { return ptr == PtrTraits<UPtr>::barePointer(u); }
 
  template <typename UPtr>
  bool operator!=(const UPtr & u) const { return ptr != PtrTraits<UPtr>::barePointer(u); }
 
  bool operator<(const TransientConstRCPtr & p) const {
    return ( ptr && p.ptr && ptr->uniqueId != p.ptr->uniqueId ) ?
      ptr->uniqueId < p.ptr->uniqueId : ptr < p.ptr;
  }
 
  bool operator<(const_pointer p) const {
    return ( ptr && p && ptr->uniqueId != p->uniqueId ) ?
      ptr->uniqueId < p->uniqueId : ptr < p;
  }
 
  bool operator!() const { return !ptr; }
 
  operator const T * () const { return ptr; }
 
  const_pointer operator->() const { return ptr; }
 
  const_reference operator*() const { return *ptr; }
 
private:
 
  const_pointer ptr;
 
};
 
template <typename T>
struct PtrTraits< RCPtr<T> >: public PtrTraitsType {
 
  typedef typename RCPtr<T>::value_type value_type;
  typedef typename RCPtr<T>::reference reference;
  typedef typename RCPtr<T>::const_reference const_reference;
  typedef RCPtr<T> pointer;
  typedef ConstRCPtr<T> const_pointer;
  typedef TransientRCPtr<T> transient_pointer;
  typedef TransientConstRCPtr<T> transient_const_pointer;
 
  static T * barePointer(const RCPtr<T> & p) { return p.operator->(); }
 
  static pointer create() { return RCPtr<T>::Create(); }
 
  static pointer create(const_reference t) { return RCPtr<T>::Create(t); }
 
  static void destroy(pointer) {}
 
  template <typename UPtr>
  static pointer DynamicCast(const UPtr & u) {
    pointer t;
    t.assignDynamic(u);
    return t;
  }
 
  template <typename UPtr>
  static pointer ConstCast(const UPtr & u) {
    pointer t;
    t.assignConst(u);
    return t;
  }
 
  static pointer PtrCast(T * t) {
    return pointer(t);
  }
 
  static const bool reference_counted = true;
 
}; 
 
template <typename T>
struct PtrTraits< ConstRCPtr<T> >: public PtrTraitsType {
 
  typedef typename ConstRCPtr<T>::value_type value_type;
  typedef typename ConstRCPtr<T>::reference reference;
  typedef typename ConstRCPtr<T>::const_reference const_reference;
  typedef RCPtr<T> pointer;
  typedef ConstRCPtr<T> const_pointer;
  typedef TransientRCPtr<T> transient_pointer;
  typedef TransientConstRCPtr<T> transient_const_pointer;
 
  static const T * barePointer(const ConstRCPtr<T> & p) {
    return p.operator->();
  }
 
  static const_pointer create() {
    return RCPtr<T>::Create();
  }
 
  static const_pointer create(const_reference t) {
    return RCPtr<T>::Create(t);
  }
 
  static void destroy(const_pointer) {}
 
  template <typename UPtr>
  static const_pointer DynamicCast(const UPtr & u) {
    const_pointer t;
    t.assignDynamic(u);
    return t;
  }
 
  template <typename UPtr>
  static const_pointer ConstCast(const UPtr & u) {
    const_pointer t;
    t.assignDynamic(u);
    return t;
  }
 
  static const_pointer PtrCast(const T * t) {
    return const_pointer(t);
  }
 
  static const bool reference_counted = true;
 
}; 
 
template <typename T>
struct PtrTraits< TransientRCPtr<T> >: public PtrTraitsType {
 
  typedef typename TransientRCPtr<T>::value_type value_type;
  typedef typename TransientRCPtr<T>::reference reference;
  typedef typename TransientRCPtr<T>::const_reference const_reference;
  typedef RCPtr<T> pointer;
  typedef ConstRCPtr<T> const_pointer;
  typedef TransientRCPtr<T> transient_pointer;
  typedef TransientConstRCPtr<T> transient_const_pointer;
 
  static T * barePointer(const TransientRCPtr<T> & p) {
    return p.operator->();
  }
 
  static void destroy(transient_pointer) {}
 
  template <typename UPtr>
  static transient_pointer DynamicCast(const UPtr & u) {
    transient_pointer t;
    t.assignDynamic(u);
    return t;
  }
 
  static transient_pointer ConstCast(transient_const_pointer c) {
    transient_pointer t;
    t.assignConst(c);
    return t;
  }
 
   static transient_pointer PtrCast(T * t) {
    return transient_pointer(t);
  }
 
  static const bool reference_counted = false;
 
}; 
 
template <typename T>
struct PtrTraits< TransientConstRCPtr<T> >: public PtrTraitsType {
 
  typedef typename TransientConstRCPtr<T>::value_type value_type;
  typedef typename TransientConstRCPtr<T>::reference reference;
  typedef typename TransientConstRCPtr<T>::const_reference const_reference;
  typedef RCPtr<T> pointer;
  typedef ConstRCPtr<T> const_pointer;
  typedef TransientRCPtr<T> transient_pointer;
  typedef TransientConstRCPtr<T> transient_const_pointer;
 
  static const T * barePointer(const TransientConstRCPtr<T> & p) {
    return p.operator->();
  }
 
  static void destroy(transient_const_pointer) {}
 
  template <typename UPtr>
  static transient_const_pointer DynamicCast(const UPtr & u) {
    transient_const_pointer t;
    t.assignDynamic(u);
    return t;
  }
 
  template <typename UPtr>
  static transient_const_pointer ConstCast(const UPtr & u) {
    transient_const_pointer t;
    t.assignConst(u);
    return t;
  }
 
  static transient_const_pointer PtrCast(const T * t) {
    return transient_const_pointer(t);
  }
 
  static const bool reference_counted = false;
 
}; 
 
}
}
 
namespace std {
 
template <typename T>
inline void swap(ThePEG::Pointer::RCPtr<T> & t1, 
                 ThePEG::Pointer::RCPtr<T> & t2) {
  t1.swap(t2);
}
 
template <typename T>
inline void swap(ThePEG::Pointer::ConstRCPtr<T> & t1,
                 ThePEG::Pointer::ConstRCPtr<T> & t2) {
  t1.swap(t2);
}
 
}
 
#endif /* ThePEG_RCPtr_H */