/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_5_3_13_patch3/src/GeneratorInterface/Core/interface/FortranInstance.h

Go to the documentation of this file.

#ifndef gen_FortranInstance_h
#define gen_FortranInstance_h

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();

    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