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