3. policies und singletons

policies und singletons

  • S

    Hallo Leute

    Ich spiele mich immer noch mit Policies und singletons rum...

    Folgendes:

    momentan sieht es so aus:

    class Singleton
{
private:
  ~Singleton();
public:
  template<class Policy>
  void InitSingleton();

  Singleton& Instance();

  virtual char* foo() = 0;
};

template<class Policy>
class realSingleton
{
private:
  friend class Singleton;
public:
  char* foo();
};

    das funktioniert soweit so gut.
    ich kann mittels
    Singleton::Instance().foo();
    foo aufrufen.

    nun möchte ich aber den rückgabe typ von foo in ein policy verwandeln.

    Singleton speichert werte in einer datei und liest sie wieder aus - eigentlich kann Singleton alle Typen die den op>> und op<< unterstützen speichern.

    aber leider funktioniert das mit policies nicht so wie es soll. denn bei meiner lösung muss Singleton den rückgabetype kennen, was aber unmöglich ist, da Singleton kein template sein kann.

    Die Lösung mit
    Singletonstd::string::Instance().foo();
    scheidet aus, da Singleton noch andere policies hat - die nicht überall bekannt sein können/sollen.

    Singleton könnte so aussehen:

    template<class StringT, class Geheim>
Singleton
{
};

    wobei Geheim etwas mit dem speichern der daten zu tun hat.
    Geheim will ich einmal zentral angeben. und zwar dynamisch:

    if(x)
{
  Singleton::Init<std::string, ganz_geheim>();
}
else
{
  Singleton::Init<std::string, nicht_so_gehim>();
}

    wobei std::string statisch bleibt - nur Geheim will ich dynamisch angeben.

    die lösung mit einem globalen typedef auf std::string (und ich dann in Singleton nur das typedef verwende) will ich umgehen, da dass IMHO sehr unschön ist.

    ich grüble daran schon über eine woche und ich fürchte, dass es keine lösung dafür gibt. aber wenn es eine gibt, bzw. ein workaround, dann wisst ihr ihn, stimmts?

    danke schonmal.

    0
  • S

    sorry wenn ich pushe - aber mir ist eure Meinung dazu ziemlich wichtig.

    0
  • H

    Hallo,
    ich befürchte es wird ziemlich schwer eine Meinung dazu abzugeben, da die Informationen dafür meiner Meinung nach nicht ausreichend sind.

    nun möchte ich aber den rückgabe typ von foo in ein policy verwandeln.

    Singleton speichert werte in einer datei und liest sie wieder aus - eigentlich kann Singleton alle Typen die den op>> und op<< unterstützen speichern.

    aber leider funktioniert das mit policies nicht so wie es soll. denn bei meiner lösung muss Singleton den rückgabetype kennen, was aber unmöglich ist, da Singleton kein template sein kann.

    Damit scheint mir das mit dem Variablen Rückgabewert erstmal unmöglich zu sein. Singleton ist kein Template, also hast du keinen Templateparameter zur Verfügung. foo ist virtuell, also kann es kein Membertemplate sein.

    da Singleton noch andere policies hat - die nicht überall bekannt sein können/sollen.

    Das verstehe ich nicht wirklich. Deshalb eine vielleicht naive Frage:
    Defaultparameter sind nicht möglich?

    Der Rest ist mir irgendwie völlig unklar. Vielleicht würde es helfen, wenn du noch mal genauer beschreibst, was du eigentlich vorhast.

    [ Dieser Beitrag wurde am 22.03.2003 um 19:15 Uhr von HumeSikkins editiert. ]

    0
  • S

    Original erstellt von HumeSikkins:
    Hallo,
    ich befürchte es wird ziemlich schwer eine Meinung dazu abzugeben, da die Informationen dafür meiner Meinung nach nicht ausreichend sind.

    sorry, ich versuchs besser zu erklären.

    Damit scheint mir das mit dem Variablen Rückgabewert erstmal unmöglich zu sein. Singleton ist kein Template, also hast du keinen Templateparameter zur Verfügung. foo ist virtuell, also kann es kein Membertemplate sein.

    das ist die momentane lösung.
    eine änderung des designs ist durchaus möglich.

    Das verstehe ich nicht wirklich. Deshalb eine vielleicht naive Frage:
    Defaultparameter sind nicht möglich?

    ne, default params gehen nicht 😞

    Beispiel:

    int main()
{
   Session::Init<std::string, SaveToFile>();
   Session* p=Session::Instance();
}

    so könnte es momentan aussehen.
    SaveToFile bestimmt WO gespeichert wird. (zB in einer Datei, Datanbank, oder sonstwo)
    Wohin gespeichert wird, ist aber für den rest des programmes uninteressant.
    nun kann aber folgendes sein:

    int main()
{
   if(argc==2 && !strcmp(argv[1],"to_db")
   {
      Session::Init<std::string, SaveToDB>();
   }
   else
      Session::Init<std::string, SaveToFile>();
   Session* p=Session::Instance();
}

    für die semantik des programms ist es ja egal wohin gespeichert wird.

    jetzt will ich irgendwo anders einfach:

    Session* p=Session::Instance();
p->write("Hallo");

    ob "Hallo" jetzt in einer DB oder einem File steht, ist dann eigentlich nicht wichtig.

    Wichtig ist natürlich, ob std::string, AnsiString, QString oder sonstwas gespeichert wird.

    Der Rest ist mir irgendwie völlig unklar. Vielleicht würde es helfen, wenn du noch mal genauer beschreibst, was du eigentlich vorhast.

    das ganze ist für meine CGI Library.

    der Programmierer will uU nicht std::string verwenden, sondern eine andere Implementation (weil ich Libraries nicht mag, die einem eine string klasse vorgeben)

    das ergebnis soll sein, dass ich folgendes machen kann

    //irgendwo in main()
Session::Init<string, SaveToFile>(); //oder andere syntax
//wichtig ist - ein singleton mit 2 policies wird angelegt:
//SaveToFile speichert die übergeben daten (uU muss es auch SaveToFile<string> heissen)
//string ist der datentyp der gespeichert werden soll

//irgendwo im programm
Session* p=Session::Instance();
//oder auch Instance<string>
//hier wird der Singleton angesprochen - ob SaveToFile oder SaveToDB
//ist hier nicht bekannt. hier weiss man nur, dass man string verwendet
p->write("hallo");
//schreibe entweder in ein file oder eine db - völlig egal.
//string "hallo" wird gespeichert, wohin interessiert nicht.

    ich hoffe es ist klar... ansonsten einfach nachfragen.

    danke!!!

    0
Anmelden zum Antworten