Question

I am trying to do a plugin like:

main process()
{
   call plugin to do something;
}

plugin()
{
   PART A: to encode a message, and send to other app;
   PART B: to decode a message, and call PART A to check whether we need to send more messages.
}

So, for PART B, it will be called automatically, when the reply returns. When I am in PARTB, I will return to PART A, but I am in PART A, I can’t directly call PART B, because it should be called when a reply returns, so how can I do a loop in async call? When I send a message, how to wait until the reply comes to PART B. Thanks for your suggesion.

Answer 1

This is up to your implementation of main process and design of your plugins for example I have something like this:

struct message;
typedef std::function<bool(message&)> message_handler;
struct IMainProcess {
    virtual int add_listener( message_handler const& f ) = 0;
    virtual void remove_listener( int key ) = 0;
};
struct IPlugin {
    virtual bool initialize( IMainProcess* p ) = 0;
    virtual void shutdown() = 0;
};

struct MainProcess : IMainProcess {
    int key;
    std::map<int, message_handler > listeners;
    MainProcess() : key( 0 ) {}
    virtual int add_listener( message_handler const& f ) {
        int res = key++;
        listeners[key] = f;
    }
    virtual void remove_listener( int key ) {
        listeners.erase( key );
    }

    void message_received( message& m ) {
        // call all plugins that registered for incoming messages
        for( auto i = listeners.begin(); i != listeners.end(); i++ ) {
            if( !i->second(m) ) break;
        }
    }
};
int main() {
    MainProcess mp;
    // Load plugins from some location and initialize them
    std::vector<std::auto_ptr<IPlugin> > plugins;
    while( IPlugin* p = load_plugin() ) {
        std::auto_ptr<IPlugin> sp( p );
        if( p->initialize(&mp) ) plugins.push_back( sp );
    }
    while( message* msg = wait_for_message() ) {
        std::auto_ptr<message> smsg( msg );
        mp.message_received( *msg );
    }
    // end of operation
    for( auto i = plugins.begin(); i != plugins.end(); i++ ) {
        (*i)->shutdown();
    }
    return 0;
}

Now plugin can have any desired architecture and can also receive incoming messages!