Shared Library Question

Discussion in 'C++' started by listigerBiber, Aug 10, 2003.

  1. Hello,

    i want to extend a program of mine with a plugin architecture.
    I can load and use the shared libs which are implementations of a
    abstract base class without any problems. But what i need is a
    bi-directional interface, the plugins have to acess objects of the
    main programm (pointers to them are passed at plugin initialisation).
    This works too - but only if i include the header and .cpp files of
    these api objects into every plugin - and that is bloated bullshit !

    is there a way to include the api .h files only and uses the
    implementation code from the main-application (gcc 3.2 linux 2.4) ??
    if i try to do that library loading fails with unresolved symbols
    .....

    Thanx C.S.
    listigerBiber, Aug 10, 2003
    #1
    1. Advertising

  2. "listigerBiber" <-heidelberg.de> wrote...
    > i want to extend a program of mine with a plugin architecture.
    > I can load and use the shared libs which are implementations of a
    > abstract base class without any problems. But what i need is a
    > bi-directional interface, the plugins have to acess objects of the
    > main programm (pointers to them are passed at plugin initialisation).
    > This works too - but only if i include the header and .cpp files of
    > these api objects into every plugin - and that is bloated bullshit !
    >
    > is there a way to include the api .h files only and uses the
    > implementation code from the main-application (gcc 3.2 linux 2.4) ??
    > if i try to do that library loading fails with unresolved symbols
    > ....


    What you need is to provide an SDK to the writers of plug-ins. You
    have determined what classes plug-ins need, now you have to expose
    those classes. The most convenient way is to create "pure abstract"
    interfaces. The real objects that will do the work you will create
    on demand in some kind of factory function. The plug-ins will call
    your factory or will receive the pointers to base classes some other
    way, then will call the methods of those base classes, which will
    resolve in calls to the implementations through polymorphism.

    So, you basically on the right track. Simply extract the interface
    the plug-ins will use into the base class, declare those functions
    virtual and pure. Make your classes derive from those interfaces,
    create the instances of your classes and pass the addresses as base
    class pointers to plug-ins.

    Victor
    Victor Bazarov, Aug 10, 2003
    #2
    1. Advertising

  3. listigerBiber

    Cy Edmunds Guest

    "Allen" <> wrote in message
    news:WMwZa.95236$...
    > Hi listigerBiber, all,
    >
    > > One way to implement a C interface which I have used quite a lot is to

    > make
    > > each plugin have only one function. The function returns a pointer to a

    C
    > > struct which has nothing but function pointers.

    >
    > id's QuakeII engine (GPL) uses a very similar method. The loading
    > module and loaded module exchange references through one function call.
    >
    > struct import
    > {
    > //lots of pointers to funcs in other module
    > } Ii;
    >
    > struct export
    > {
    > //lots more pointers to funcs in current module
    > }Ie;
    >
    > //init pointers in Ie to local functions you want to access in other

    module
    >
    > __declspec(dllexport) import GetAPI(export Ie); //defined in other
    > module--platform specific interface
    > Ii = GetAPI(Ie); //this func saves off the Ie info and then inits the

    Ii
    > pointers to its local funcs to be accessed in the calling module
    >
    >
    > I have a different method for doing the same thing. I made a global
    > data tree where each node looks like:
    >
    > struct Glob
    > {
    > char szName[MAX_STRING];
    > DWORD dwFlags; //valid fields and requests
    > char szValue[MAX_STRING];
    > int iValue;
    > float fValue;
    > void* pVoid;
    > PGLOB pParentGlob;
    > PGLOB pLeftGlob;
    > PGLOB pRightGlob;
    > };
    >
    > Then, pointers to my equivalent of the above import/export structs

    would
    > be placed in Glob::pVoid for all to access.
    >
    > HTH
    > --
    >
    > Best wishes,
    > Allen
    >
    > No SPAM in my email !!
    >



    Funny you should mention QuakeII. I'm the author of the QuakeII mods WoD7
    and WoD8. :) But as you say, it was iD software that wrote the stuff you're
    talking about.

    Guess in this context I'll use my real sig, including my QuakeII clan name
    LOL

    --
    Cycho{HHR}
    http://home.rochester.rr.com/cyhome/
    Cy Edmunds, Aug 10, 2003
    #3
  4. Thank you very much !
    your hint with the abstract base class for the pluginfactory worked
    ....
    of course the pluginfactory or application api must have a pure
    virtual base class !!

    "Victor Bazarov" <> wrote in message news:<9ltZa.79503$>...
    > "listigerBiber" <-heidelberg.de> wrote...
    > > i want to extend a program of mine with a plugin architecture.
    > > I can load and use the shared libs which are implementations of a
    > > abstract base class without any problems. But what i need is a
    > > bi-directional interface, the plugins have to acess objects of the
    > > main programm (pointers to them are passed at plugin initialisation).
    > > This works too - but only if i include the header and .cpp files of
    > > these api objects into every plugin - and that is bloated bullshit !
    > >
    > > is there a way to include the api .h files only and uses the
    > > implementation code from the main-application (gcc 3.2 linux 2.4) ??
    > > if i try to do that library loading fails with unresolved symbols
    > > ....

    >
    > What you need is to provide an SDK to the writers of plug-ins. You
    > have determined what classes plug-ins need, now you have to expose
    > those classes. The most convenient way is to create "pure abstract"
    > interfaces. The real objects that will do the work you will create
    > on demand in some kind of factory function. The plug-ins will call
    > your factory or will receive the pointers to base classes some other
    > way, then will call the methods of those base classes, which will
    > resolve in calls to the implementations through polymorphism.
    >
    > So, you basically on the right track. Simply extract the interface
    > the plug-ins will use into the base class, declare those functions
    > virtual and pure. Make your classes derive from those interfaces,
    > create the instances of your classes and pass the addresses as base
    > class pointers to plug-ins.
    >
    > Victor
    listigerBiber, Aug 11, 2003
    #4
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. DJ Dev
    Replies:
    3
    Views:
    16,098
    Gandalf
    Feb 8, 2004
  2. Joe Fallon
    Replies:
    3
    Views:
    753
    =?Utf-8?B?Z3V5?=
    Jul 16, 2004
  3. ben
    Replies:
    3
    Views:
    504
    Kevin Spencer
    Nov 15, 2004
  4. Replies:
    1
    Views:
    1,257
    santosh
    Jul 15, 2008
  5. DJ Stunks
    Replies:
    0
    Views:
    316
    DJ Stunks
    Feb 10, 2007
Loading...

Share This Page