PtrTraits.h

// -*- C++ -*-
//
// PtrTraits.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_PtrTraits_H
#define ThePEG_PtrTraits_H
// This is the declaration of the PtrTraits class.
 
namespace ThePEG {
namespace Pointer {
 
struct PtrTraitsType {};
 
template <class T>
struct PtrTraits: public PtrTraitsType {};
 
template <class T>
struct PtrTraits<T *>: public PtrTraitsType {
 
  typedef T value_type;
  typedef T & reference;
  typedef const T & const_reference;
  typedef T * pointer;
  typedef T * const_pointer;
 
  static T * barePointer(T * p) { return p; }
 
  static pointer create() { return new T; }
 
  static pointer create(const_reference t) { return new T(t); }
 
  static void destroy(pointer tp) { delete tp; }
 
  template <class R>
  static pointer DynamicCast(R * r) { return dynamic_cast<pointer>(r); }
 
  static pointer ConstCast(const T * t) { return const_cast<pointer>(t); }
 
  static pointer PtrCast(T * t) { return t; }
 
  static const bool reference_counted = false;
 
};
 
template <class T>
struct PtrTraits<const T *>: public PtrTraitsType {
 
  typedef T value_type;
  typedef T & reference;
  typedef const T & const_reference;
  typedef T * pointer;
  typedef T * const_pointer;
 
  static const T * barePointer(const T * p) { return p; }
 
  static pointer create() { return new T; }
 
  static pointer create(const_reference t) { return new T(t); }
 
  static void destroy(pointer tp) { delete tp; }
 
  template <class R>
  static const_pointer DynamicCast(const R * r) {
    return dynamic_cast<const_pointer>(r);
  }
 
  static const_pointer ConstCast(const T * r) { return r; }
 
  static const_pointer PtrCast(const T * t) { return t; }
 
  static const bool reference_counted = false;
 
};
 
template <class T1, class T2>
T1 dynamic_ptr_cast(const T2 & t2) { return PtrTraits<T1>::DynamicCast(t2); }
 
 
template <class T1, class T2>
T1 const_ptr_cast(const T2 & t2) { return PtrTraits<T1>::ConstCast(t2); }
 
template <typename Ptr>
inline Ptr ptr_new() { return PtrTraits<Ptr>::create(); }
 
template <typename Ptr>
inline Ptr ptr_new(typename PtrTraits<Ptr>::const_reference t) {
  return PtrTraits<Ptr>::create(t);
}
 
template <typename T>
inline typename Ptr<T>::pointer new_ptr() {
  return PtrTraits< typename Ptr<T>::pointer >::create();
}
 
template <typename T>
inline typename Ptr<T>::pointer new_ptr(const T & t) {
  return PtrTraits< typename Ptr<T>::pointer >::create(t);
}
 
template <typename TPtr, typename T>
inline TPtr ptr_cast(T * t) {
  return PtrTraits<TPtr>::PtrCast(t);
}
 
template <typename TPtr, typename T>
inline TPtr ptr_cast_const(const T * t) {
  return PtrTraits<TPtr>::PtrCast(const_cast<T*>(t));
}
 
 
}
}
 
#endif /* ThePEG_PtrTraitsH */