Interfaced.h

// -*- C++ -*-
//
// Interfaced.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_Interfaced_H
#define ThePEG_Interfaced_H
// This is the declaration of the Interfaced class.
 
#include "ThePEG/Config/ThePEG.h"
#include "InterfacedBase.h"
#include "ThePEG/PDT/PID.h"
 
namespace ThePEG {
 
class Interfaced: public InterfacedBase {
 
  friend class Repository;
 
  friend class EventGenerator;
 
public:
 
  virtual ~Interfaced();
 
public:
 
  virtual bool defaultInit();
 
  PPtr getParticle(PID) const;
 
  PDPtr getParticleData(PID) 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 &) = delete;
 
};
 
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 */