//designfrage - sowas wie traits für enums...

muffmolch

Blöder threadtirwl, sorry.
Ich habe das Problem, dass ich in meinem Programm eine Klasse hat, die einen Model-Parameter besitzt, den sie für alles mögliche benötigt.
Zudem ist von diesem z.B. in einer Hilfsklasse der "Template-Parameter abhängig:

namespace XXX
{
   enum MODEL { A, B, C };
}

class ModuleA {};
class ModuleB {};
class ModuleC {};

class Klasse : public Basis
public:
  void virtualFoo()
  {
     switch(this->model){
     case XXX::A: this->foo<ModuleA>();
     case XXX::B: this->foo<ModuleD>();
     case XXX::C: this->foo<ModuleC>();
     default: throw exception(...);
  }
  template< typename ModelModule >
  void foo()
  {
      ...
      xyz = new blabla< ModelModule  >;
      ...
  }
};

Diese switch-Anweisung ist sehr unschön und gerade bei neuen Modellen bekommt man erst zur Laufzeit die Infor, dass Fälle nicht abgefangen wurden. Aber es MUSS eh für jedes Modell ein Modul vorhanden sein, andernfalls sollte der Compiler bereits streiken.
Ich dachte hier an Traits. Sowas wie

void virtualFoo()
{
  this->foo< Traits< this->model >::ModelModule >();
}

Doch das geht für enums ja nicht. Hat da jemand eine Idee?
SirAnn

hustbaer

Guck dir mal das strategy-pattern an.

muffmolch

okay. hi erbin ich wieder. ja, strategy ist ne feine sache. allerdings ist hier komposition statt vererbung nur ein weiterer aspekt, den man berücksichtigen koennte, der aber nicht das problem löst.

daher zum eigentlichen problem:

die Klasse ist bereits ein Strategie-Modul.
um genau zu sein ist dieses Modul zum setzen von connectoren zwischen konkreten blöcken in einem strömungssimulator bestimmt.
der je nach simulator-modell kann dieses modul sich unterscheiden. zudem ist ein weiterer parameter der typ des connectors. natürlich kann man jetzt für jede kombination von modell, connector und connector typ eine weitere strategie implementieren. der code für das setzen dieser connectoren ist jedoch relativ komplex und zudem immer derselbe -> jede menge redundanter quellcode -> templates bieten sich an

das einzige problem, dass ich habe ist, dass der tatsächliche typ erst zur laufzeit herausstellt und eben ein enum ist

stark vereinfacht:

void setzeConnectors() //<-überschriebene virtuelle Methode -> interface nicht änderbar
{
    if     (this->model == A) this->setzeConnectors< connector1A, connector2A >();
    else if(this->model == B) this->setzeConnectors< connector1B, connector2B >
    ...
}
template< typename conn1, typename conn2 >
void setzeConnectors()
{
   //300 Zeilen quellcode mit einzigem unterschied:
   //block->setzeConn( conn1() ); etc. pp.
}

eigentlich dachte ich daran, dass ich für jeden modell typ ein odere mehrere traits erstellte, die dann verwendet werden. aber dann muesste Klasse eine template Klasse sein. und gerade das möchte ich verhindern