CurrentGenerator.h

// -*- C++ -*-
//
// CurrentGenerator.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_CurrentGenerator_H
#define ThePEG_CurrentGenerator_H
// This is the declaration of the CurrentGenerator class.
 
#include "ThePEG/Repository/EventGenerator.h"
#include "CurrentGenerator.fh"
 
namespace ThePEG {
 
class CurrentGenerator {
 
public:
 
  CurrentGenerator() : generatorPushed(false) {}
 
  CurrentGenerator(const CurrentGenerator &)
    : generatorPushed(false) {}
 
  CurrentGenerator(const EGPtr & eg) : generatorPushed(false) {
    if ( eg ) {
      theGeneratorStack.push_back(eg);
      generatorPushed = true;
    }
  }
 
  ~CurrentGenerator() {
    if ( generatorPushed ) theGeneratorStack.pop_back();
  }
 
public:
 
  static bool isVoid() {
    return theGeneratorStack.empty() || !(theGeneratorStack.back());
  }
 
  static EventGenerator & current() {
    return *theGeneratorStack.back();
  }
 
  EventGenerator & operator*() const {
    return *theGeneratorStack.back();
  }
 
  EventGenerator * operator->() const {
    return theGeneratorStack.back();
  }
 
  static EventGenerator * ptr() {
    return theGeneratorStack.back();
  }
 
  operator bool() const {
    return ptr();
  }
 
  bool operator!() const {
    return !ptr();
  }
 
  static tSMPtr standardModel() {
    return current().standardModel();
  }
 
  static tStrategyPtr strategy() { return current().strategy(); }
 
  static ostream & out() { return current().out(); }
 
  static ostream & log() { return current().log(); }
 
  static ostream & ref() { return current().ref(); }
 
  template <typename T>
  static typename Ptr<T>::pointer getPtr(const T & t) {
    return current().getPtr(t);
  }
 
  static IBPtr getPointer(string name) {
    return current().getPointer(name);
  }
 
  template <typename T>
  static typename Ptr<T>::pointer getObject(string name) {
    return current().getObject<T>(name);
  }
 
  template <typename T>
  static typename Ptr<T>::pointer getDefault() {
    return current().getDefault<T>();
  }
 
public:
 
  class Redirect {
 
  public:
 
    Redirect(ostream & os, bool internal = false)
      : theStream(&os), theBuffer(os.rdbuf()) {
      if ( internal ) theStream->rdbuf(intStream.rdbuf());
      else if ( !current().useStdOut() )
        theStream->rdbuf(current().misc().rdbuf());
    }
 
    ~Redirect() {
      theStream->rdbuf(theBuffer);
    }
 
    string str() const {
      return intStream.str();
    }
 
    ostream * theStream;
 
    std::streambuf * theBuffer;
 
    ostringstream intStream;
 
  };
 
private:
 
  static vector<EGPtr> theGeneratorStack;
 
  bool generatorPushed;
 
private:
 
  CurrentGenerator & operator=(const CurrentGenerator &) = delete;
 
};
 
}
 
#endif /* ThePEG_CurrentGenerator_H */