Die Problemstellung zuerst:
Es gibt zwei Klassen, nennen wir sie A und B. Die beiden Klassen sind fertig und können nicht modifiziert werden. Sie stammen von unterschiedlichen Bibliotheken und es muss eine Kommunikation zwischen diesen Bibliotheken realisiert werden. Dabei muss ein Objekt von der Klasse A umgewandelt werden zu einem Objekt der Klasse B und umgekehrt.

Mein bisherige Lösung:
Die ist eigentlich ganz einfach. Ich habe eine Funktion geschrieben, welche ein A entgegennimmt und ein B zurückgibt, sowie eine zweite Funktion, welche ein B entgegennimmt und ein A zurückgibt. Simpel und einfach, nur leider nicht gerade sehr praktisch. Dadurch entstehen dann solche Quellcodezeilen:

LibraryB::set_something(to_b_object(LibraryA::get_something()));
// bzw.
LibraryA::set_something(to_a_object(LibraryB::get_something()));

Die Frage:
Kann ich diese Funktion to_b_object , bzw. to_a_object , irgendwie automatisieren, bzw. verstecken? Also das die Konvertierung von alleine gemacht wird? Grundsätzlich suche ich sowas:

class A
{
};

class B
{
};

////////////////////
// DAS HIER: -------

operator A(B const&)
{
	return A();
}

// -----------------
////////////////////

void foo(A const&)
{
}

int main()
{
	B b;
	foo(b);

	return 0;
}

Das geht natürlich nicht, weil es ein "non-static member" sein muss. Aber gibt es irgendeinen Weg?

Grüssli

Edit: Hmm, scheint nicht zu funktionieren, sorry. Könntest du an den Stellen, an denen du die Klassen gemeinsam verwendest, nicht eine einheitliche Klasse einsetzen, die zu beiden kompatibel ist?

Edit: Hmm, scheint nicht zu funktionieren, sorry. Könntest du an den Stellen, an denen du die Klassen gemeinsam verwendest, nicht eine einheitliche Klasse einsetzen, die zu beiden kompatibel ist?

Genau das kann ich nicht, bzw. probiere ich zu vermeiden. Theoretisch wäre es möglich, würde aber eine Heidenarbeit sein, da die eine Bibliothek bei den Schnittstellen umgeschrieben werden müsste und es würde eine zusätzliche Abhängigkeit schaffen, welche ich eigentlich vermeiden möchte.

Die andere Bibliothek möchte ich nicht anfassen, weil sie nicht von mir ist und ziemlich gross. Ich weiss nicht, was dies für Effekte haben könnte. Es wäre allerdings am einfachsten, wenn ich dort die Klasse leicht anpassen würde.

Ich würde aber lieber beide Bibliotheken in Ruhe lassen

Grüssli

Die eigene Bibliothek ist eine Datenverwaltung, welche zum Beispiel das Datum über Boost.DateTime speichert.
Nun erstelle ich ein GUI über/mit wxWidgets, jetzt muss natürlich jeweils zwischen Boost.DateTime und wxDateTime konvertiert werden, wenn es zur GUI geht und dann wieder zurück in die Datenverwaltung (also die Veränderungen übernommen werden).

Das ist fast ein reines durchreichen, aber ist eben recht mühsam. Ich könnte natürlich in meiner Datenverwaltung eine Abhängigkeit zu wxWidgets machen und intern dann Boost.DateTime kapseln, aber ich möchte in der Datenverwaltung unabhängig von wxWidgets bleiben.
wxWidgets selber möchte ich nicht anfassen.

Grüssli

du hast eine fest verdrahtete Abhängigkeit von wxWidgets und boost::datetime. dadurch dass du keine eigenen datentypen verwendest kannst du das Interface deiner verschiedenen Schichten nicht kontrollieren. Ich denke du solltest wirklich mindestens eines von beiden Systemen kapseln.

Das bringt aber auch nichts, wie soll ich denn diese Verdrahtung mit einer zusätzlichen Klasse aufheben? Die Datenverwaltung weiss nichts von wxWidgets und wxWidgets weiss nichts von der Datenverwaltung. Und diese Unabhängigkeit möchte ich dringends so belassen.

Wenn ich nun in der Datenverwaltung Boost.DateTime kapsle, was bringt mir das? Ich kenne wxWidgets ja nicht, kann dadurch keine implizite Konvertierung erstellen.
Wenn ich Boost.DateTime im eigenen Programm kapsle, wo ich die Datenverwaltung und wxWidgets verwende, bringt mir das eigentlich nur ein Mehraufwand. Das ist dann nicht viel anders als eine Funktion, welche zwischen den Datentypen umwandelt, also wie ich es jetzt schon habe.
Und in wxWidgets etwas verändern gehen, ist auch nicht möglich.

Ich sehe also nicht, wie mir dies etwas bringen sollte, bzw. auf was du hinaus willst.

Vielleicht auch noch zur Klarheit ein Diagramm, wie das Projekt aufgebaut ist:

-------------------
                 |------------- | Boost (Library) |
                 V              -------------------
-----------------------------                        -----------------------
| Datenverwaltung (Library) |           ¦            | wxWidgets (Library) |
-----------------------------                        -----------------------
           |                            ¦                         |
           |                            V                         |
           |                 ----------------                     |
           --------------->  | Programm.exe | <--------------------
                             ----------------

(Die Verbindung zwischen Boost und Programm.exe ist für das Problem nebensächlich. Daher die grösseren Lücken im Pfeil.)

Grüssli

Wenn du eine überschaubare Anzahl(1-3) von Datenbankklassen hast würde ich von denen ableiten, in den Subklassen aber nur Funktionen überladen die du wirklich brauchst(bei der ersten Verwendung).
Tipp:
Wenn du mit Visual Studio arbeitest kannst du dir ein kleines Makro schreiben welches dir den Großteil der Arbeit abnimmt.

Eine andere Möglichkeit sehe ich da nicht.

template<typename FromT, typename ToT>
struct Convert;

template<typename T>
struct Convert<T, T>
{
  static T convert(T const& t)
  {
    return t;
  }
};

template<>
struct Convert<std::string, wxString>
{
  static wxString convert(std::string const& str)
  {
    return wxString::FromUTF8(str.c_str());
  }
};

// usw.

template<typename ControlT>
struct GetSetControlValue
{
  typedef wxString SetType;
  typedef wxString GetType;

  static void set(ControlT& control, SetType const& val)
  {
    control.SetValue(val);
  }

  static GetType get(ControlT& control)
  {
    return control.GetValue();
  }
};

// ... Spezialisierungen ...

template<typename ControlT, typename ValueT>
void set_value(ControlT& control, ValueT const& value)
{
  typedef GetSetControlValue<ControlT> GSCV;

  GSCV::set(control, Convert<ValueT, GSCV::SetType>::convert(value));
}

So ganz fertig durchdacht ist es noch nicht. Ich überlege mir sogar aktuell, ob ich nicht eine Klasse dazu schreiben soll, welche diesen Datenaustausch noch weiter automatisiert. Wodurch ich am Ende in einer Dialogklasse ein entsprechendes Datenaustausch Objekt initialisiere und dann nur noch jeweils ein Objekt übergeben kann. Dann wird alles korrekt geschrieben und dann wieder korrekt gelesen. Mal schauen, wie ich die Idee weiterentwicklen werde

Grüssli