ClassDescription.h

// -*- C++ -*-
//
// ClassDescription.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_ClassDescription_H
#define ThePEG_ClassDescription_H
 
#include "ThePEG/Config/ThePEG.h"
#include "ClassDescription.fh"
#include "ThePEG/Utilities/Named.h"
#include "ThePEG/Persistency/PersistentOStream.fh"
#include "ThePEG/Persistency/PersistentIStream.fh"
#include "ClassTraits.h"
#include "DescriptionList.h"
 
namespace ThePEG {
 
class ClassDescriptionBase: public Named {
 
public:
 
  typedef vector<const ClassDescriptionBase *> DescriptionVector;
 
protected:
 
  ClassDescriptionBase(string newName, 
                       const type_info & newInfo,
                       int newVersion, 
                       string newLibrary,
                       bool abst)
    : Named(newName), theVersion(newVersion), theLibrary(newLibrary),
      theInfo(newInfo), isAbstract(abst), done(false) {}
 
public:
 
  virtual ~ClassDescriptionBase();
 
  const type_info & info() const { return theInfo; }
 
  int version() const { return theVersion; }
 
  string library() const { return theLibrary; }
 
  bool check() const { return done; }
 
  const DescriptionVector & descriptions() const { return theBaseClasses; }
 
  virtual void setup() = 0;
 
  virtual BPtr create() const = 0;
 
  virtual void output(tcBPtr b, PersistentOStream & os) const = 0;
 
  virtual void input(tBPtr b, PersistentIStream & is, int oldVersion) const = 0;
 
  bool isA(const ClassDescriptionBase & base) const;
 
  bool abstract() const { return isAbstract; }
 
protected:
 
  void baseClasses(DescriptionVector::iterator first,
                   DescriptionVector::iterator last) 
  {
    theBaseClasses = DescriptionVector(first, last);
    done = true;
  }
 
private:
 
  int theVersion;
 
  string theLibrary;
 
  const type_info & theInfo;
 
  DescriptionVector theBaseClasses;
 
  bool isAbstract;
 
  bool done;
 
};
 
template <typename T, int IBase,
          typename B = typename BaseClassTrait<T,IBase>::NthBase>
struct ClassDescriptionHelper {
  static void addBases(vector<const ClassDescriptionBase *> & c){
    const ClassDescriptionBase * b = DescriptionList::find(typeid(B));
    if ( !b ) return;
    c.push_back(b);
    ClassDescriptionHelper<T,IBase+1>::addBases(c);
  }
};
 
template <typename T, int IBase>
struct ClassDescriptionHelper<T, IBase, int> {
  static void addBases(vector<const ClassDescriptionBase *> & ) {}
};
 
template <typename T>
class ClassDescriptionTBase: public ClassDescriptionBase {
 
public:
 
  typedef ClassTraits<T> Traits;
 
public:
 
  ClassDescriptionTBase(bool abst)
    : ClassDescriptionBase(Traits::className(), typeid(T), Traits::version(),
                           Traits::library(), abst) 
  {
    DescriptionList::Register(*this);
    T::Init();
  }
 
  virtual void setup() {
    DescriptionVector bases;
    ClassDescriptionHelper<T,1>::addBases(bases);
    baseClasses(bases.begin(), bases.end());
  }
 
};
 
template <typename T>
class AbstractClassDescription: public ClassDescriptionTBase<T> {
 
public:
 
  typedef ClassTraits<T> Traits;
 
public:
 
  AbstractClassDescription() : ClassDescriptionTBase<T>(true) {}
 
  virtual BPtr create() const {
    throw std::logic_error("Tried to instantiate virtual class " + Named::name());
  }
 
  virtual void output(tcBPtr b, PersistentOStream & os) const {
    Traits::output(Traits::cast(b), os);
  }
 
  virtual void input(tBPtr b, PersistentIStream & is,
                     int oldVersion) const {
    Traits::input(Traits::cast(b), is, oldVersion);
  }
 
};
 
template <typename T>
class ClassDescription: public ClassDescriptionTBase<T> {
 
public:
 
  typedef ClassTraits<T> Traits;
 
public:
 
  ClassDescription() : ClassDescriptionTBase<T>(false) {}
 
  virtual BPtr create() const { return Traits::create(); }
 
  virtual void output(tcBPtr b, PersistentOStream & os) const {
    Traits::output(Traits::cast(b), os);
  }
 
  virtual void input(tBPtr b, PersistentIStream & is,
                     int oldVersion) const {
    Traits::input(Traits::cast(b), is, oldVersion);
  }
 
};
 
template <typename T>
class NoPIOClassDescription: public ClassDescriptionTBase<T> {
 
public:
 
  typedef ClassTraits<T> Traits;
 
public:
 
  NoPIOClassDescription() : ClassDescriptionTBase<T>(false) {}
 
  virtual BPtr create() const { return Traits::create(); }
 
  virtual void output(tcBPtr, PersistentOStream &) const {}
 
  virtual void input(tBPtr, PersistentIStream &, int) const {}
 
};
 
template <typename T>
class AbstractNoPIOClassDescription: public ClassDescriptionTBase<T> {
 
public:
 
  typedef ClassTraits<T> Traits;
 
public:
 
  AbstractNoPIOClassDescription() : ClassDescriptionTBase<T>(true) {}
 
  virtual BPtr create() const {
    throw std::logic_error("Tried to instantiate virtual class " + Named::name());
  }
 
  virtual void output(tcBPtr, PersistentOStream & ) const {}
 
  virtual void input(tBPtr, PersistentIStream &, int) const {}
 
};
 
}
 
#define ThePEG_DECLARE_CLASS_DESCRIPTION(Class)                    \
             \
static ClassDescription<Class> init ## Class                       \
 
#define ThePEG_DECLARE_ABSTRACT_CLASS_DESCRIPTION(Class)           \
            \
static AbstractClassDescription<Class> init ## Class               \
 
#define ThePEG_DECLARE_NOPIO_CLASS_DESCRIPTION(Class)              \
          \
static NoPIOClassDescription<Class> init ## Class                  \
 
#define ThePEG_DECLARE_ABSTRACT_NOPIO_CLASS_DESCRIPTION(Class)     \
         \
static AbstractNoPIOClassDescription<Class> init ## Class          \
 
#define ThePEG_IMPLEMENT_CLASS_DESCRIPTION(Class)                  \
ClassDescription<Class> Class::init ## Class                       \
 
#define ThePEG_IMPLEMENT_ABSTRACT_CLASS_DESCRIPTION(Class)         \
AbstractClassDescription<Class> Class::init ## Class               \
 
#define ThePEG_IMPLEMENT_NOPIO_CLASS_DESCRIPTION(Class)            \
NoPIOClassDescription<Class> Class::init ## Class                  \
 
#define ThePEG_IMPLEMENT_ABSTRACT_NOPIO_CLASS_DESCRIPTION(Class)   \
AbstractNoPIOClassDescription<Class> Class::init ## Class          \
 
#endif /* ThePEG_ClassDescription_H */