FortranInstance.h

Go to the documentation of this file.

#ifndef gen_FortranInstance_h
#define gen_FortranInstance_h

#include <string>

namespace gen {

// the callbacks from Pythia6/Herwig6 which are passed to the FortranInstance
extern "C" {
    void upinit_();
    void upevnt_();
    void upveto_(int*);
}

class FortranInstance {
    public:
    FortranInstance() : instanceNesting(0) {}
    virtual ~FortranInstance();

    void call(void(&fn)())
    { InstanceWrapper wrapper(this); fn(); }
    template<typename T> T call(T(&fn)())
    { InstanceWrapper wrapper(this); return fn(); }
    template<typename A> void call(void(&fn)(A), A a)
    { InstanceWrapper wrapper(this); fn(a); }
    template<typename T, typename A> T call(T(&fn)(A), A a)
    { InstanceWrapper wrapper(this); return fn(a); }
    template<typename A1, typename A2> void call(void(&fn)(A1, A2), A1 a1, A2 a2)
    { InstanceWrapper wrapper(this); fn(a1, a2); }
    template<typename T, typename A1, typename A2> T call(T(&fn)(A1, A2), A1 a1, A2 a2)
    { InstanceWrapper wrapper(this); return fn(a1, a2); }

    // if a member is instantiated at the beginning of a method,
    // it makes sure this FortranInstance instance is kept as
    // current instance during the execution of the method
    // This wrapper makes the enter()..leave() cycle exception-safe
    struct InstanceWrapper {
        InstanceWrapper(FortranInstance *instance)
        { this->instance = instance; instance->enter(); }

        ~InstanceWrapper()
        { instance->leave(); }

        FortranInstance *instance;
    };

    // set this instance to be the current one
    // will throw exception when trying to reenter Herwig twice
    virtual void enter();

    // leave instance
    // will throw if the currently running instance does not match
    virtual void leave();

    // get the currently running instance (from enterInstance)
    // intended for callbacks from Fortran
    template<typename T>
    static T *getInstance()
    {
        T *instance = dynamic_cast<T*>(currentInstance);
        if (!instance)
            throwMissingInstance();
        return instance;
    }

    // Fortran callbacks
    virtual void upInit();
    virtual void upEvnt();
    virtual bool upVeto();

        static const std::string kFortranInstance;

    private:
    // list all the Fortran callbacks here
    friend void gen::upinit_();
    friend void gen::upevnt_();
    friend void gen::upveto_(int*);

    // internal methods
    static void throwMissingInstance();

    // how many times enter() was called
    // this is to make sure leave() will release the instance
    // after the same number of calls
    // nesting can in theory occur if the Fortran callback calls
    // into Herwig again
    int         instanceNesting;

    // this points to the Herwig instance that is currently being executed
    static FortranInstance  *currentInstance;
};

} // namespace gen

#endif // gen_FortranInstance_h