Interfaced.h

// -*- C++ -*-
//
// Interfaced.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_Interfaced_H
#define ThePEG_Interfaced_H
// This is the declaration of the Interfaced class.

#include "ThePEG/Config/ThePEG.h"
#include "InterfacedBase.h"

namespace ThePEG {

class Interfaced: public InterfacedBase {

  friend class Repository;

  friend class EventGenerator;

public:

  virtual ~Interfaced();

public:

  virtual bool defaultInit();

  PPtr getParticle(long) const;

  PDPtr getParticleData(long) const;

  bool used() const { return theUseFlag; }

  void useMe() const { if ( !used() ) setUsed(); }

  tEGPtr generator() const { return theGenerator; }

public:

  void persistentOutput(PersistentOStream & os) const;

  void persistentInput(PersistentIStream & is, int version);

  static void Init();

protected:

  static void registerRepository(IBPtr);

  static void registerRepository(IBPtr, string newName);

  void reporeg(IBPtr object, string name) const;

  template <typename PtrT>
  bool setDefaultReference(PtrT & ptr, string classname, string objectname) {
    if ( ptr ) return true;
    const ClassDescriptionBase * db = DescriptionList::find(classname);
    if ( !db ) return false;
    ptr = dynamic_ptr_cast<PtrT>(db->create());
    if ( !ptr ) return false;
    reporeg(ptr, objectname);
    if ( !ptr->defaultInit() ) return false;
    return true;
  }

  Interfaced() : theUseFlag(false) {}

  Interfaced(const string & newName) 
    : InterfacedBase(newName), theUseFlag(false) {}

  Interfaced(const Interfaced & i)
    : InterfacedBase(i), theGenerator(i.theGenerator), theUseFlag(false) {}
  
protected:

  void setGenerator(tEGPtr generator) { theGenerator=generator; }

private:

  void setUsed() const;

  tEGPtr theGenerator;

  mutable bool theUseFlag;

  string doDefaultInit(string);

private:

  static AbstractClassDescription<Interfaced> initInterfaced;

  Interfaced & operator=(const Interfaced &);

};

template <>
struct BaseClassTrait<Interfaced,1>: public ClassTraitsType {
  typedef InterfacedBase NthBase;
};

template <>
struct ClassTraits<Interfaced>: public ClassTraitsBase<Interfaced> {
  static string className() { return "ThePEG::Interfaced"; }
};

}

#endif /* ThePEG_Interfaced_H */

---