struct VisiAPI   // Plugin -> Framework
{
    virtual void registerTerminationEvent(TerminationCondition* condition, TerminationEventAction* action) = 0;
};

class CorePlugin
{
private:
    VisiAPI* api;

protected:
    void registerTerminationEvent(TerminationCondition* condition, TerminationEventAction* action)
    {
        api->registerTerminationEvent(condition, action);
    }
public:
    virtual void initialize() = 0;
};

class MoP : private VisiAPI //implements API privately
{
private:
    CorePlugin* plugin;
    TerminationChecker checker;
    State* state;
    Simulator simulator;

    void registerTerminationEvent(TerminationCondition* condition, TerminationEventAction* action )
    {
        checker.registerTerminationEvent( condition, action );
    }

    void simulate()
    {
        simulator(state, checker);
    }
};

class TerminationChecker
{
    struct ConditionAction
    {
        TerminationCondition* condition;
        TerminationEventAction* action;
    };

    list<ConditionAction> conditions;
public:
    void registerTerminationEvent(TerminationCondition* condition, TerminationEventAction* action )
    {
        conditions.push_back( ConditionAction( condition, action ) );
    }

    TerminationEventAction* checkTerminationConditions(State* state, CorePlugin* plugin)
    {
        list<ConditionAction>::iterator cond = conditions.begin();
        TerminationEventAction* actionToDo = NULL;

        while ( cond != conditions.end() && actionToDo == NULL )
        {
             if ( cond->condition->applies( state ) )
                 actionToDo = cond->action;
             ++cond;
        }

        conditions.clear();

        /* TO BE DONE IN THE MoP::simulate()
        if (actionToDo != NULL)
        {
            actionToDo->raiseEvent();
        }
    */
    return actionToDo;
    }
};


// Meanwhile, somewhere in PluginCity...
class MyPrettyPlugin : public CorePlugin
{
private:
    void someBizarreEvent() { doSomething... }
    void moreBizarreEvent() { doSomething... }
    void bizarrestEvent()   { breakTheWorld; }


    class CallSomeBizarreEvent : public TerminationEventAction
    {
        MyPrettyPlugin* parent;

        virtual void raiseEvent()
        {
            parent->someBizarreEvent();
        }

    public:
        CallSomeBizarreEvent(MyPrettyPlugin* parent);
    };

    class CallMoreBizarreEvent : public TerminationEventAction
    {
        MyPrettyPlugin* parent;

        virtual void raiseEvent()
        {
            parent->moreBizarreEvent();
        }

    public:
        CallMoreBizarreEvent(MyPrettyPlugin* parent);
    };

    class CallBizarrestEvent : public TerminationEventAction
    {
        MyPrettyPlugin* parent;

        virtual void raiseEvent()
        {
            parent->bizarrestEvent();
        }

    public:
        CallBizarrestEvent(MyPrettyPlugin* parent);
    };

    class BizarreCondition : public TerminationCondition
    {
        virtual bool applies(State* state)
        {
            return false; // never occurs!
        }
    };

    virtual void initialize()
    {
        registerTerminationEvent( new Cd4sTraspassEvent(34.5, Down), new CallSomeBizarreEvent(this) );

        registerTerminationEvent( new ViremiaTraspassEvent(34.5, Down), new CallMoreBizarreEvent(this) );

        registerTerminationEvent( new BizarreCondition(), new CallBizarrestEvent(this) );
    }
};