Ich entwickle zur Zeit einen PluginManager der Plugins in DLL bzw in SO Form laden kann.

Das Plugin selbst enthält eine unbestimmte, vom Pluginentwickler zu definierende, Anzahl an Klassen welche über eine Factory im Pluginmanager instanziert werden.

Zum eigentlichen Problem: Ich raufe mir die Haare auf der Suche nach einer Lösung für die Identifikation von Plugin-Klassen.

Folgender Ablauf schwebt mir vor:
1. PluginManager schaut in sein Verzeichniss und listet alle *.dll oder *.so
2. PluginManager linkt (dynamisch) die erste DLL / SO in seiner Liste und fürht eine Identifikation durch (Schnittstellen Funktionalität)
3. PluginManager sollte nun vom Plugin ein DING erhalten, welches das Plugin beschreibt (Momentan ist das ein struct mit den Variablen name und typ, dieses struct ist im Plugin hart codiert.)
4. Zusätzlich dazu muss sich jede Klasse die der Pluginentwickler im Plugin implementiert hat, mit einem DING ausweisen können (ebenfalls mit name, typ usw) jedoch sollte keine Instanz der Klasse für den Vorgang nötig sein.
5. Der Pluginmanager sollte am ende dieser "Loading Plugins" routine eine Liste mit allen Plugin namen,typen,usw haben und zusätzlich dazu eine list mit allen objekten die er aus diesen Plugins erzeugen kann (im Prinzip eine Liste mit Funkionspointern auf die Konstruktoren.

Die Factory übernimmt nun das Instanzieren.

Okay, eine Möglichkeit wäre die Verwendung einer PluginInfo Klasse, welche alle PluginInfos plus eine Liste (std::list) mit allen Klassen im Plugin speichert und einen Pointer auf dieses Object an den Pluginmanager übergibt.

Nachteil: Ich müsste eine Plugin Init Routine schreiben welche diese Liste bei benutzung des Plugins erzeugt ( std::list.push_back("name"); usw...).

Ich möchte die Sache gerne Simpel lösen und auch dem Plugin Entwickler das Leben leichter machen. Es soll möglichst nicht an einer Stelle seine Klasse definieren müssen un an einer völlig anderen Stelle eine Referenz zu dieser Klasse in einen Liste eintragen müssen.

Habe bereits an structs, bzw an eine verkettete Liste von Structs gedacht, jedoch ist das ohne Object nicht wirklich zu realisieren das sich die structs untereinander nicht kennen.

Ich bitte um ein Tatkräftioges Brainstorming, da mein eigenes Brain momentan sehr ausgelaugt ist.

Vielen Dank

Grüße Bloop

Init() -> initialisiert Variablen, die von den Funktionen der Dll benötigt werden

Setup(Pointer auf "Haupt-Klasse des Programmes oder spezielle PlugIn-Daten")
-> Verändert die Daten der Haupt-Klasse um beispielsweise einen neuen Menüeintrag zu erstellen

Info("Pointer auf auszufüllende Informationsstruktur") -> Eine Struktur die Daten wie Autor, Version, etc. ausfüllt an denen das Programm prüft ob es Setup ausführt oder nicht

Exit() -> PlugIn herunterfahren um beispielsweise Speicher frei zu geben

Hier mal ein Beispiel für ein Python-\1:

# Plugin-name
__name = "Plugin nr 7"
__author = "Badestrand"
__version = "1.2.3"

# Database and table to use
__dbserver = "localhost"
__user = "root"
__password = "Geheim"
__database = "mydb"

#intialization-routine
def Initialize( options ):
    options.fahr_zur_hoelle = true
    options.jesus_lebt = false

def DoSomethingFunny( mekka ):
    mekka.TravelTo()
    mekka.Pray()

def End():
    "sad"

// Header (gemeinsam für alle Plugins)
class Plugin
{
public:
    virtual ~Plugin()=0;
    // ...
};

struct PluginDllInfo
{
    char const* Name;
    // ...
};

struct PluginInfo
{
    char const* Name;
    int Type;
    // ...
    Plugin* (*Create)();
};

MY_DLL_EXPORT PluginDllInfo const* GetDllInfo();
MY_DLL_EXPORT PluginInfo const* const* GetPluginInfoArray();

MY_DLL_EXPORT PluginDllInfo const* GetDllInfo()
{
    static PluginDllInfo i = { "sepp", ... };
    return sepp;
}

class FooPlugin : public Plugin
{
public:
    FooPlugin() { ... }
    virtual ~FooPlugin() {}

    // ...
};

Plugin* CreateFooPlugin()
{
    return new FooPlugin;
}

class BarPlugin : public Plugin
{
public:
    BarPlugin() { ... }
    virtual ~BarPlugin() {}

    // ...
};

Plugin* CreateBarPlugin()
{
    return new BarPlugin;
}

MY_DLL_EXPORT PluginInfo const* const* GetPluginInfoArray()
{
    static PluginInfo FooInfo = { "foo", ... , CreateFooPlugin };
    static PluginInfo BarInfo = { "bar", ... , CreateBarPlugin };
    static PluginInfo* i[] = {&FooInfo, &BarInfo, 0};
    return i;
}

Das wäre simpel.
WinAmp DSP Plugins sind so ähnlich aufgebaut. Guck dir die Doku dazu an, ist recht einfach.

----

Du könntest aber genausogut eine vollständige "PluginDllInfo" Klasse basteln, die dann Funktionen zum Enumerieren der einzelnen Plugin Factory Klassen hat (eine Factory Klasse entspricht dabei dann einem PluginInfo, nur halt in "schönerem Gewand").

und Danke für eure Antworten.

COM ist nicht möglich da ich ANSI C++ verwende um Platformunabhängig zu sein.
Die Plugin Init() Funktion hab ich mir aich schon überlegt, das löst aber nicht das Problem der "unbestimmten Menge an Klassen".
Skriptsprache scheidet aus weil ich mitunter recht komplexe Dinge mit meinen Plugins machen muss.

Hustbear, deine Lösung deckt sich (erschreckender Weise inklusive der Klassenhierarchie) mit meiner Idee.

Als führt kein Weg drum herum alle PluginInfos an einer Stelle Hart zu codieren.

Vielen Dank euch allen!

MfG Kimmi