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 */