InterfacedBase.h

// -*- C++ -*-
//
// InterfacedBase.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_InterfacedBase_H
#define ThePEG_InterfacedBase_H
// This is the declaration of the InterfacedBase class.
 
#include "ThePEG/Config/ThePEG.h"
#include "ThePEG/Utilities/Named.h"
#include "ThePEG/Utilities/ClassDescription.h"
#include "ThePEG/Utilities/HoldFlag.h"
#include "InterfacedBase.xh"
 
namespace ThePEG {
 
class InterfacedBase: public PersistentBase, public Named {
 
  friend class BaseRepository;
 
  friend class InterfaceBase;
 
  friend class EventGenerator;
 
public:
 
  enum InitState {
    initializing = -1, 
    uninitialized = 0, 
    initialized = 1,   
    runready = 2       
  };
 
public:
 
  virtual ~InterfacedBase();
 
  string fullName() const { return Named::name(); }
 
  string name() const {
    return Named::name().substr(Named::name().rfind('/')+1);
  }
 
  string path() const {
    string::size_type slash = Named::name().rfind('/');
    string ret;
    if ( slash != string::npos ) ret = Named::name().substr(0,slash);
    return ret;
  }
 
  string comment() const { return theComment; }
 
  void setup(istream & is) {
    readSetup(is);
    getline(is, theComment);
  }
 
protected:
 
  virtual void readSetup(istream & is);
 
  virtual void doupdate() {}
 
  virtual void doinit() {}
 
  virtual void doinitrun() {}
 
  virtual void dofinish() {}
 
  virtual IVector getReferences() { return IVector(); }
 
  virtual void rebind(const TranslationMap &) {}
 
public:
 
  void update() {
    if ( initState ) return;
    HoldFlag<InitState> hold(initState, initializing, initialized);
    doupdate();
  }
 
  void init() {
    if ( initState ) return;
    HoldFlag<InitState> hold(initState, initializing, initialized);
    doinit();
  }
 
  virtual bool preInitialize() const;
 
  void initrun() {
    if ( initState == runready || initState == initializing ) return;
    HoldFlag<InitState> hold(initState, initializing, runready);
    doinitrun();
  }
 
  void finish() {
    if ( initState == uninitialized || initState == initializing ) return;
    HoldFlag<InitState> hold(initState, initializing, uninitialized);
    dofinish();
  }
 
  void touch() { isTouched = true; }
 
  void reset() { initState = uninitialized; }
 
  void clear() {
    reset();
    untouch();
  }
 
  InitState state() const { return initState; }
 
  bool locked() const { return isLocked; }
 
  bool touched() const { return isTouched; }
 
  virtual IBPtr fullclone() const { return clone(); }
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual IBPtr clone() const = 0;
 
  InterfacedBase()
    : Named(""), isLocked(false), isTouched(true), 
      initState(uninitialized) {}
 
  InterfacedBase(string newName)
    : Named(newName), isLocked(false), isTouched(true),
      initState(uninitialized) {}
 
  InterfacedBase(const InterfacedBase & i)
    : Base(i), Named(i), isLocked(false), isTouched(true), 
      initState(uninitialized), theComment(i.theComment),
      objectDefaults(i.objectDefaults) {}
 
private:
 
  void name(string newName) { Named::name(newName); }
 
  void lock() { isLocked = true; }
 
  void unlock() { isLocked = false; }
 
  void untouch() { isTouched = false; }
 
private:
 
  string addComment(string);
 
private:
 
  bool isLocked;
 
  bool isTouched;
 
  InitState initState;
 
  string theComment;
 
  map<string,string> objectDefaults;
 
public:
 
  virtual void debugme() const;
 
private:
 
  static AbstractClassDescription<InterfacedBase> initInterfacedBase;
 
  InterfacedBase & operator=(const InterfacedBase &) = delete;
 
protected:
 
  struct UpdateChecker {
    UpdateChecker(bool & touched) : isTouched(touched) {}
    UpdateChecker(const UpdateChecker & uc) : isTouched(uc.isTouched) {}
    static void check(tIBPtr, bool &);
    template <typename ptr> void operator()(const ptr & i) {
      check(i, isTouched);
    }
    bool & isTouched;
  };
 
  struct UpdateMapChecker {
    UpdateMapChecker(bool & touched) : isTouched(touched) {}
    UpdateMapChecker(const UpdateMapChecker & uc) : isTouched(uc.isTouched) {}
    template <typename ref> void operator()(const ref & i) {
      UpdateChecker::check(i.second, isTouched);
    }
    bool & isTouched;
  };
 
};
 
template <>
struct BaseClassTrait<InterfacedBase,1>: public ClassTraitsType {
  typedef PersistentBase NthBase;
};
 
template <>
struct ClassTraits<InterfacedBase>: public ClassTraitsBase<InterfacedBase> {
  static string className() { return "ThePEG::InterfacedBase"; }
};
 
}
 
#endif /* ThePEG_InterfacedBase_H */