Konzept

Das Adapter Muster ist, wie der Name schon sagt, ein Muster, welches als ein Adapter zwischen 2 Objekten fungiert.
Diese Muster ist sehr nützlich bei dem flexiblen programmieren von Ressourcenabhängigen Managern.
Das Konzept des Adapters ist es Daten, die in einen Format vorliegen durch den Adapter in ein für die andere nutzbare Form zu bringen.
So kann ein Adapter z.B. Bitmaps lesen und diese in das gebrauchte Format umwandeln, ein anderer Adapter kann dies für ein PNG und ein weiteres kann dies für eine AVI.

Umsetzung

Wir hatten gerade von meheren möglichen Adaptern geredet, die verschiedene Bildformate und Bildsequenzformate lesen sollen.
Also sollten wir erstmal ermöglichen, dass man mehere Adapter, mit jeweils einen Dateiformat verbinden kann.
C++

class TAdapter
{
  public:
    TAdapter(string FileName);
};

typedef TAdapter* (*CreateAdapterInstanceCallback)(string FileName);

class TAdapterManager
{
  protected:
    map<string,CreateAdapterInstanceCallback> RegisteredAdapters;
  public:
    void RegisterAdapter(string ExtensionName, CreateAdapterInstanceCallback Callback);
    TAdapter* GetAdapterInstance(string ExtensionName);
    bool RemoveAdapter(string ExtensionName);
};

Pascal

pTAdapter=^TAdapter;
TAdapter=class
  public:
    constructor Create(FileName:string);
end;

//Anmerkung: Objekte Pascal kennt die Möglickeit class of class und diese kann man anstatt eines Callbacks verwenden.
//           Nutzen tut man dieses dann so. var AdapterCls:TAdapterCls; MyAdapter:TAdapter; begin MyAdapter:=AdapterCls.Create(); end;
//TAdapterCls=class of TAdpater;
CreateAdapterInstanceCallback=function (FileName:string):pTAdapter;

TAdapterManager=class
  protected:
    RegisteredAdapters:TUniqueHashList;//Eine Liste in der kein Wert doppelt vorkommt und die Strings durch Hashes im Zugriff optimiert werden.
  public:
    //procedure RegisterAdapter(ExtensionName:string; AdapterCls:TAdapterCls);
    procedure RegisterAdapter(ExtensionName:string; Callback:CreateAdapterInstanceCallback);
    function GetAdapterInstance(ExtensionName:string):pTAdapter:
    function RemoveAdapter(ExtensionName:string):Boolean;
end;

Jetzt können wir Einen eigenen Adapter dem AdapterManager bekannt machen, indem wir die Extension(z.B. "gz" oder "avi") und ein passenden Callback übergeben.
Der Callback besitzt nur eine Zeile Code, denn er erzeugt nur eine Instanz und gibt diese zurück.

Nun können wir Adapter registrieren, erstellen und entfernen aber was ist mit dem Austausch von Daten?
Da der Adapter wissen muss, was der Empfänger für Daten haben will, muss der Adapter für den Empfänger zugeschnitten werden und der Empfängger braucht auch eine Routine, die die Daten vom Adapter entgegen nimmt und verarbeitet.
Also müssen wir die Klassen möglichst abstrakt bauen und die Verarbeitung den Nachfahren überlassen.
C++

class TAdapter
{
  public:
    virtual bool LoadFile(string FileName)=0;
    virtual void* GetData()=0;
};

typedef TAdapter* (*CreateAdapterInstanceCallback)();//ruft den constructor auf und LoadFile wird gesondert aufgerufen

class TAdapterManager
{
  protected:
    map<string,CreateAdapterInstanceCallback> RegisteredAdapters;
  public:
    virtual void RegisterAdapter(string ExtensionName, CreateAdapterInstanceCallback Callback);
    virtual TAdapter* GetAdapterInstance(string ExtensionName);
    virtual bool RemoveAdapter(string ExtensionName);
};

Pascal

TAdapter=class
  public:
    function LoadFile(FileName:string):Boolean; virtual; abstract;
    function GetData():pointer; virtual; abstract;
end;

//Anmerkung: Objekte Pascal kennt die Möglickeit class of class und diese kann man anstatt eines Callbacks verwenden.
//           Nutzen tut man dieses dann so. var AdapterCls:TAdapterCls; MyAdapter:TAdapter; begin MyAdapter:=AdapterCls.Create(); end;
//TAdapterCls=class of TAdpater;
CreateAdapterInstanceCallback=function ():TAdapter;//ruft nur den Konstruktor auf, geladen wird erst nach der übergabe der Instanz

TAdapterManager=class
  protected:
    RegisteredAdapters:TUniqueHashList;//Eine Liste in der kein Wert doppelt vorkommt und die Strings durch Hashes im Zugriff optimiert werden.
  public:
    //procedure RegisterAdapter(ExtensionName:string; AdapterCls:TAdapterCls);
    procedure RegisterAdapter(ExtensionName:string; Callback:CreateAdapterInstanceCallback);
    function GetAdapterInstance(ExtensionName:string):pTAdapter:
    function RemoveAdapter(ExtensionName:string):Boolean;
end;

Nun mal ein kleines Beispiel für die einsetzung des Pattern.
Wir haben einen AdapterManager für Konfigurationsdatein, ein Adapter für das lesen von XML Datein und eine Klasse, die die Konfiguration auswertet.
C++

class TAdapter
{
  public:
    virtual bool LoadFile(string FileName)=0;
    virtual void* GetData()=0;
};

struct TConfigData
{
  unsigned int Resolution;
};

class TConfigAdapterForXML:public TAdapter
{
  protected:
    TConfigData* ConfigFile;
  public:
    bool LoadFile(string FileName){
      ...lade und parse XML Datei...
      ConfigFile=new TConfigData;
      ConfigFile->Resolution=XMLParsedResolutionValue;
      ...Datei schliessen Parser freigeben...
    }
    void* GetData(){
      return (void*)ConfigFile;
    }
}

typedef TAdapter* (*CreateAdapterInstanceCallback)();

TAdapter* MyConfigXMLAdapter(){
  return new TConfigAdapterForXML;
}

class TAdapterManager
{
  protected:
    map<string,CreateAdapterInstanceCallback> RegisteredAdapters;
  public:
    virtual void RegisterAdapter(string ExtensionName, CreateAdapterInstanceCallback Callback);
    virtual TAdapter* GetAdapterInstance(string ExtensionName);
    virtual bool RemoveAdapter(string ExtensionName);
};

class TConfig{
  protected:
    unsigned int Resolution;
    TAdapterManager* Manager;
  public:
    TConfig(TAdapterManager* AManager){ Manager=AManager; Resolution=0; }
    bool Load(){
      TAdapter* Adapter=Manager->GetAdapterInstance(".xml");
      if (Adapter)
      {
        if(Adapter->LoadFile("playerconfig.xml"))
          Resolution=(TConfigData*)(Adapter->GetData())->Resolution;
        else
          Resolution=DEFAULT_RESOLUTION;
        delete Adapter;
      }
    }
    unsigned int GetResolution(){ return Resolution; }
};

int main(){
  TAdapterManager* Manager=new TAdapterManager;
  Manager->RegisterAdapter(".xml",MyConfigXMLAdapter);
  TConfig* Config=new TConfig(Manager);
  cout<<Config->GetResolution()<<end;//0
  Config.Load();
  cout<<Config->GetResolution()<<end;//0 oder Wert aus der XML File.
  Manager->RemoveAdapter(".xml");
}

Pascal

TAdapter=class
  public:
    function LoadFile(FileName:string):Boolean; virtual; abstract;
    function GetData():pointer; virtual; abstract;
end;

TConfigData=packed record
  Resolution:cardinal;
end;

TConfigAdapterForXML=class(TAdapter)
  protected:
    ConfigFile:^TConfigData;
  public:
    function LoadFile(FileName:string):Boolean; overload;
    function GetData():pointer; overload;    
end;

function TConfigAdapterForXML.LoadFile(FileName:string;
begin
  ...lade und parse XML Datei...
  getmem(ConfigFile,sizeof(TConfigData));
  ConfigFile.Resolution=XMLParsedResolutionValue;
  ...Datei schliessen Parser freigeben...
end;

function TConfigAdapterForXML.GetData():pointer;
begin
  result:=ConfigFile;
end;

//Anmerkung: Objekte Pascal kennt die Möglickeit class of class und diese kann man anstatt eines Callbacks verwenden.
//           Nutzen tut man dieses dann so. var AdapterCls:TAdapterCls; MyAdapter:TAdapter; begin MyAdapter:=AdapterCls.Create(); end;
//TAdapterCls=class of TAdpater;
CreateAdapterInstanceCallback=function ():TAdapter;//ruft nur den Konstruktor auf, geladen wird erst nach der übergabe der Instanz

function MyConfigXMLAdapter():TAdapter;
begin
  result:=TConfigAdapterForXML.Create();
end;

TAdapterManager=class
  protected:
    RegisteredAdapters:TUniqueHashList;//Eine Liste in der kein Wert doppelt vorkommt und die Strings durch Hashes im Zugriff optimiert werden.
  public:
    //procedure RegisterAdapter(ExtensionName:string; AdapterCls:TAdapterCls);
    procedure RegisterAdapter(ExtensionName:string; Callback:CreateAdapterInstanceCallback);
    function GetAdapterInstance(ExtensionName:string):pTAdapter:
    function RemoveAdapter(ExtensionName:string):Boolean;
end;

TConfig=class
  protected:
    Resolution:cardinal;
    Manager:TAdapterManager;
  public:
    constructor Create(AManager:TAdapterManager);
    function Load():Boolean;
    function GetResolution():cardinal;
end;

constructor TConfig.Create(AManager:TAdapterManager);
begin
  Manager:=AManager;
  Resolution:=0;
end;

function TConfig.Load();
var
  Adapter:TAdapter;
begin
  Adapter:=Manager.GetAdapterInstance('.xml');
  if assigned(Adapter) then
  begin
    if Adapter.LoadFile('playerconfig.xml') then
      Resolution:=TConfigData(Adapter.GetData()^).Resolution
    else
      Resolution:=DEFAULT_RESOLUTION;
    Adapter.free();
  end;
end;

function TConfig.GetResolution():cardinal;
begin
  result:=Resolution;
end;

var
  Manager:TAdapterManager;
  Config:TConfig;
begin
  Manager:=TAdapterManager.Create();
  Manager.RegisterAdapter('.xml',MyConfigXMLAdapter);
  Config:=TConfig.Create(Manager);
  writeln(Config.GetResolution());//0
  Config.Load();
  writeln(Config.GetResolution());//0 oder Wert aus der XML File.
  Manager.RemoveAdapter('.xml');
}

Dies war ein genauerer Pseudocode, beide Versionen sind nicht getestet aber man versteht den sinn doch denke ich sehr schnell.
Man könnte nun weitere Adapter für ini,txt,windows registry und so weiter schreiben, der Config Klasse würde dies nichts ausmachen, da es ja seine gewollten Daten bekommt und verarbeiten kann.

Einsatzbeispiele wären Texturen, Sound, Models, Materials, Scripte und Shader. Mein TexturManager z.B. nutzt Adapter für DDS und der TexturAdapter ist so konzipiert, dass man sogar Bildsequenz basierte Formate(ala avi) davon ableiten könnte.
Dafür muss man im Adapter und Manager eine Updatemethode einbauen, im Manager eine Liste für Updatebare Adapter einführen und im Adapter ein Flag für Updatebar hinzufügen.
Die TexturManager.Update Methode wird dann jeden Frame aufgerufen und diese ruft alle in der UpdatebarenAdapterListe auf.
Update, im Adapter, kann dann sich die Zeit holen und entscheiden, ob es die Bilddaten updated, wenn ja dann werden die verwendeten Bibliotheken(z.B. VFW,libmpeg,...) aufgerufen und das nächste Frame geholt.
Da man die Adapter registrieren kann und sie nicht fest verdrahtet sind, kann man diese z.B. in shared libraries(auch als .so und .dll bekannt) packen und so ein Pluginsystem realisieren.
Ich selber rate allerdings von solch ein Pluginsystem ab, da es die Engine sehr unsicher macht und die Plugins Fehler mit in die Software bringen kann.

Bei Fragen, Kritik, Verbesserungsvorschläge oder ähnlichem einfach mir(TAK2004) eine PM im Forum schreiben.

Adapter Muster

Konzept

Umsetzung

Navigationsmenü

Ansichten

Meine Werkzeuge

Navigation

Hauptkategorien

Suche

Werkzeuge