ClassTraits.h

// -*- C++ -*-
//
// ClassTraits.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_ClassTraits_H
#define ThePEG_ClassTraits_H
// This is the declaration of the ClassTraitsBase, ClassTraits and
// BaseClassTraits classes.
 
 
#include "ThePEG/Config/ThePEG.h"
// #include "ClassTraits.fh"
// #include "ClassTraits.xh"
#include "ThePEG/Persistency/PersistentOStream.fh"
#include "ThePEG/Persistency/PersistentIStream.fh"
#include "DescriptionList.h"
 
namespace ThePEG {
 
struct ClassTraitsType: public TraitsType {};
 
template <typename T>
struct ClassTraitsBase: public ClassTraitsType {
 
  ThePEG_DECLARE_TEMPLATE_POINTERS(T,TPtr);
  ThePEG_DECLARE_POINTERS(Base,BPtr);
 
  static TPtr create() { return TPtr::Create(); }
 
  //  static string className() { return T::className(); }
  static string className() {
    return DescriptionList::className(typeid(T));
  }
 
  static int version() {
    return DescriptionList::version(typeid(T));
  }
 
 
  static string library() {
    return DescriptionList::library(typeid(T));
  }
 
  static void output(tcTPtr t, PersistentOStream & os) {
    t->persistentOutput(os);
  }
 
  static void input(tTPtr t, PersistentIStream & is, int oldVersion) {
    t->persistentInput(is, oldVersion);
  }
 
  static TPtr cast(BPtr b) { return dynamic_ptr_cast<TPtr>(b); }  
 
  static cTPtr cast(cBPtr b) { return dynamic_ptr_cast<cTPtr>(b); }
 
  static tTPtr cast(tBPtr b) { return dynamic_ptr_cast<tTPtr>(b); }  
 
  static tcTPtr cast(tcBPtr b) { return dynamic_ptr_cast<tcTPtr>(b); }
 
};
 
template <typename T>
struct ClassTraits: public ClassTraitsBase<T> {};
 
template<>
struct ClassTraits<double> : public ClassTraitsBase<double> {
  static string className() { return "double"; }
};
 
template <typename Derived, int BaseN>
struct BaseClassTrait: public ClassTraitsType {
  typedef int NthBase;
};
 
}
 
#define ThePEG_DECLARE_BASE_CLASS_TRAITS_1(Class,Base)                     \
                                              \
template <>                                                                \
struct BaseClassTrait<Class,1>: public ClassTraitsType {                   \
                         \
  typedef Base NthBase;                                                    \
};                                                                         \
 
#define ThePEG_DECLARE_BASE_CLASS_TRAITS_2(Class,Base1,Base2)              \
                                              \
template <>                                                                \
struct BaseClassTrait<Class,1>: public ClassTraitsType {                   \
                         \
  typedef Base1 NthBase;                                                   \
};                                                                         \
                                              \
template <>                                                                \
struct BaseClassTrait<Class,2>: public ClassTraitsType {                   \
                        \
  typedef Base2 NthBase;                                                   \
};                                                                         \
 
#define ThePEG_DECLARE_NAMED_DYNAMIC_CLASS_TRAITS_(Class,Name,Lib)         \
          \
template <>                                                                \
struct ClassTraits<Class>:                                                 \
    public ClassTraitsBase<Class> {                                        \
                          \
  static string className() { return Name; }                               \
                                                                      \
  static string library() { return Lib; }                                  \
}                                                                          \
 
 
 
#define ThePEG_DECLARE_CLASS_TRAITS(Class,Base)                           \
ThePEG_DECLARE_BASE_CLASS_TRAITS_1(Class,Base)                            \
ThePEG_DECLARE_NAMED_DYNAMIC_CLASS_TRAITS_(Class,"ThePEG::" #Class,"")    \
 
#define ThePEG_DECLARE_DYNAMIC_CLASS_TRAITS(Class,Base,Lib)               \
ThePEG_DECLARE_BASE_CLASS_TRAITS_1(Class,Base)                            \
ThePEG_DECLARE_NAMED_DYNAMIC_CLASS_TRAITS_(Class,"ThePEG::" #Class,Lib)   \
 
#define ThePEG_DECLARE_CLASS_TRAITS_2(Class,Base1,Base2)                  \
ThePEG_DECLARE_BASE_CLASS_TRAITS_2(Class,Base1,Base2)                     \
ThePEG_DECLARE_NAMED_DYNAMIC_CLASS_TRAITS_(Class,"ThePEG/::" #Class,"")    \
 
#define ThePEG_DECLARE_DYNAMIC_CLASS_TRAITS_2(Class,Base1,Base2,Lib)      \
ThePEG_DECLARE_BASE_CLASS_TRAITS_2(Class,Base1,Base2)                     \
ThePEG_DECLARE_NAMED_DYNAMIC_CLASS_TRAITS_(Class,"ThePEG::" #Class,Lib)   \
 
#define ThePEG_DECLARE_NAMED_CLASS_TRAITS(Class,Base,Name)                \
ThePEG_DECLARE_BASE_CLASS_TRAITS_1(Class,Base)                            \
ThePEG_DECLARE_NAMED_DYNAMIC_CLASS_TRAITS_(Class,Name,"")                 \
 
#define ThePEG_DECLARE_NAMED_DYNAMIC_CLASS_TRAITS(Class,Base,Name,Lib)    \
ThePEG_DECLARE_BASE_CLASS_TRAITS_1(Class,Base)                            \
ThePEG_DECLARE_NAMED_DYNAMIC_CLASS_TRAITS_(Class,Name,Lib)                \
 
#define ThePEG_DECLARE_NAMED_CLASS_TRAITS_2(Class,Base1,Base2,Name)       \
ThePEG_DECLARE_BASE_CLASS_TRAITS_2(Class,Base1,Base2)                     \
ThePEG_DECLARE_NAMED_DYNAMIC_CLASS_TRAITS_(Class,Name,"")                 \
 
#endif /* ThePEG_ClassTraits_H */