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);
};

TAdapter = class
  public:
    constructor Create(FileName: String);
end;

(*
Anmerkung: Objekt Pascal kennt die Möglichkeit class of class und diese kann man anstatt eines Callbacks verwenden.
Nutzen tut man dieses dann so:
type
  TAdapterCls = class of TAdapter;
var 
  AdapterCls: TAdapterCls;
  MyAdapter: TAdapter;
begin
  MyAdapter := AdapterCls.Create();
end;
*)

CreateAdapterInstanceCallback = function (FileName: String): TAdapter;

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; Callback: CreateAdapterInstanceCallback);
    function GetAdapterInstance(ExtensionName: String): TAdapter:
    function RemoveAdapter(ExtensionName: String): Boolean;
end;

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

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

CreateAdapterInstanceCallback = function: TAdapter; //ruft nur den Konstruktor auf, geladen wird erst nach der Übergabe der Instanz

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");
}

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

PConfigData = ^TConfigData;
TConfigData = packed record
  Resolution: Cardinal;
end;

TConfigAdapterForXML = class(TAdapter)
  protected:
    ConfigFile: PConfigData;
  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;

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;
  public:
    //procedure RegisterAdapter(ExtensionName: String; AdapterCls:TAdapterCls);
    procedure RegisterAdapter(ExtensionName: String; Callback: CreateAdapterInstanceCallback);
    function GetAdapterInstance(ExtensionName: String): TAdapter:
    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');
}