DescribeClass.h

// -*- C++ -*-
//
// DescribeClass.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_DescribeClass_H
#define ThePEG_DescribeClass_H
 
#include "ThePEG/Utilities/ClassDescription.h"
 
namespace ThePEG {
 
template <typename BaseT1, typename BaseT2 = int,
          typename BaseT3 = int, typename BaseT4 = int>
struct BaseClasses {};
 
template <typename T>
struct BaseClassesTraits {
 
  typedef T Base1;
 
  typedef int Base2;
 
  typedef int Base3;
 
  typedef int Base4;
 
};
 
template <typename BaseT1, typename BaseT2, typename BaseT3, typename BaseT4>
struct BaseClassesTraits< BaseClasses<BaseT1,BaseT2,BaseT3,BaseT4> > {
 
  typedef BaseT1 Base1;
 
  typedef BaseT2 Base2;
 
  typedef BaseT3 Base3;
 
  typedef BaseT4 Base4;
 
};
 
template <typename T, bool NoPIO>
struct DescribeClassPIOHelper {
 
  static void output(const T & t, PersistentOStream & os) {
    t.persistentOutput(os);
  }
 
  static void input(T & t, PersistentIStream & is, int oldVersion) {
    t.persistentInput(is, oldVersion);
  }
 
};
 
template <typename T>
struct DescribeClassPIOHelper<T,true> {
 
  static void output(const T &, PersistentOStream &) {}
 
  static void input(T &, PersistentIStream &, int) {}
 
};
 
template <typename T, bool abstract>
struct DescribeClassAbstractHelper {
 
  static typename ThePEG::Ptr<T>::pointer create() {
    return new_ptr(T());
  }
};
 
template <typename T>
struct DescribeClassAbstractHelper<T,true> {
 
  static typename ThePEG::Ptr<T>::pointer create() {
    throw std::logic_error("Tried to instantiate abstract class " +
                           ClassTraits<T>::className());
   }
 
};
 
 
 
 
template <typename T, typename BaseT, bool Abstract = false, bool NoPIO = false>
class DescribeClassT: public ClassDescriptionBase {
 
public:
 
  ThePEG_DECLARE_TEMPLATE_POINTERS(T,TPtr);
  ThePEG_DECLARE_POINTERS(Base,BPtr);
 
  DescribeClassT(string cname, string lib, int vers = 0)
    : ClassDescriptionBase(cname, typeid(T), vers, lib, Abstract) {
    DescriptionList::Register(*this);
    T::Init();
  }
 
  virtual ~DescribeClassT() {}
 
  virtual void setup() {
    DescriptionVector bases;
    const ClassDescriptionBase * b =
      DescriptionList::find(typeid(typename BaseClassesTraits<BaseT>::Base1));
    if ( b ) bases.push_back(b);
    b = DescriptionList::find(typeid(typename BaseClassesTraits<BaseT>::Base2));
    if ( b ) bases.push_back(b);
    b = DescriptionList::find(typeid(typename BaseClassesTraits<BaseT>::Base3));
    if ( b ) bases.push_back(b);
    b = DescriptionList::find(typeid(typename BaseClassesTraits<BaseT>::Base4));
    if ( b ) bases.push_back(b);
    baseClasses(bases.begin(), bases.end());
  }
 
  virtual BPtr create() const {
    return DescribeClassAbstractHelper<T,Abstract>::create();
  }
 
  virtual void output(tcBPtr o, PersistentOStream & os) const {
    tcTPtr t = dynamic_ptr_cast<tcTPtr>(o);
    DescribeClassPIOHelper<T,NoPIO>::output(*t, os);
  }
 
  virtual void input(tBPtr o, PersistentIStream & is, int oldVersion) const {
    tTPtr t = dynamic_ptr_cast<tTPtr>(o);
    DescribeClassPIOHelper<T,NoPIO>::input(*t, is, oldVersion);
  }
 
};
   
template <typename T, typename BaseT = int,
  bool Abstract = false, bool NoPIO = false>
class DescribeClass: public DescribeClassT<T,BaseT,Abstract,NoPIO> {
 
public:
 
  DescribeClass(string cname, string lib, int vers = 0)
    : DescribeClassT<T,BaseT,Abstract,NoPIO>(cname, lib, vers) {}
 
};
   
template <typename T, typename BaseT = int>
class DescribeNoPIOClass: public DescribeClassT<T,BaseT,false,true> {
 
public:
 
  DescribeNoPIOClass(string cname, string lib, int vers = 0)
    : DescribeClassT<T,BaseT,false,true>(cname, lib, vers) {}
 
};
   
template <typename T, typename BaseT = int>
class DescribeAbstractClass: public DescribeClassT<T,BaseT,true,false> {
 
public:
 
  DescribeAbstractClass(string cname, string lib, int vers = 0)
    :DescribeClassT<T,BaseT,true,false>(cname, lib, vers) {}
 
};
   
template <typename T, typename BaseT = int>
class DescribeAbstractNoPIOClass: public DescribeClassT<T,BaseT,true,true> {
 
public:
 
  DescribeAbstractNoPIOClass(string cname, string lib, int vers = 0)
    :DescribeClassT<T,BaseT,true,true>(cname, lib, vers) {}
 
};
   
}
 
 
#endif /* ThePEG_DescribeClass_H */