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