ClassDescription.h

// -*- C++ -*-
//
// ClassDescription.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2007 Leif Lonnblad
//
// ThePEG is licenced under version 2 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 ~ClassDescriptionTBase() {}

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

---