Problem bei modularem Projekt mit Variablenübergabe (Datenübergabe)

UFOSWORLD

Hallo,

stellt euch folgendes vor.

Ich entwickle ein Programm, das modular aufgebaut werden soll, d.h. in meinem Fall

es gibt ein Grundgerüst, in das verschiedene Verabeitungsmodule dynamisch reingeladen werden.

wenn dann Daten in das erste Modul geschoben werden, dann sollen am Ausgang des Moduls die Daten an das nächste Modul weitergereicht werden.

Das wäre ja kein Problem, wenn es sich nicht um Module handeln würde, die man nach dem BauskastenPrinzip beliebig hintereinanderschalten kann.

D.h. Ich habe Eingabemodule E1, E2, E3, Verarbeitungsmodule V1, V2, V3, und Ausgabemodule A1, A2 A3

nun sollen z.b. E2 V3 A1 hintereinandergeschalten werden und die Daten sollen durchwandern....

Problem ist nun. Da die Module alle verschiedene Daten zu verarbeiten haben, kann ich ja nicht bei Modul E2 sagen... ausgabe ist 2 mal integer und 3 mal String, wenn dann V3 nur 3 String aufnehmen kann...

Zusätzlich sollen in Zukunft weitere Module geschrieben werde, von dennen bis jetzt noch keiner weiss wie dort die Ein/Ausgabe aussehen wird.

Jetzt mal abgesehen von der Logik das ich da Daten rumschiebe, die vielleicht nicht Sinnvoll sind im nächsten Modul.

Wie kann ich das Problem lösen?

Also eine möglichkeit alles was das eine Modul auswirft, ins nächste Modul reinzuwerfen... die Überprüfung würde dann im Modul erfolgen....

hat jemand nen Tip.... in C++

danke UFO

CStoll

Mal sehen, ob ich dich richtig verstehe: Modul 1 hat einige Ausgänge und weiß, welche Typen es dort liefert. Modul 2 hat Eingänge und erwartet dort bestimmte Typen. Soweit richtig?

Solange es sich dabei "nur" um verschiedene Darstellungsmöglichkeiten der selben Daten handelt, könntest du ja noch ein Konverter-Modul schreiben, das im Ernstfall zwischen die beiden Module geklemmt wird (und z.B. eine int-Zahl in einen String umwandeln kann). Wenn die Module wirklich mit unterschiedlichen Daten arbeiten wollen, kannst du sie halt nicht zusammenklemmen.
(ein Beispiel aus der Grafikverarbeitung: Ein Grafikfilter erwartet Bilddaten als Eingabe - dem kannst du kein Dreieecksnetz (Darstellungsform für dreidimensionale Objekte) übergeben. Also sollte es bei dem Versuch, den Filter an den Ausgang eines 3D-Scanners anzuschließen, einen Fehler geben.)

Zusätzlich sollen in Zukunft weitere Module geschrieben werde, von dennen bis jetzt noch keiner weiss wie dort die Ein/Ausgabe aussehen wird.

Dann wäre es vielleicht eine gute Idee, die Schnittstellen deiner Module zu standardisieren (d.h. du definierst eine Menge an Datenformaten und zwei Module können nur miteinander verbunden werden, wenn sie kompatibel sind).

UFOSWORLD

CStoll schrieb:

Mal sehen, ob ich dich richtig verstehe: Modul 1 hat einige Ausgänge und weiß, welche Typen es dort liefert. Modul 2 hat Eingänge und erwartet dort bestimmte Typen. Soweit richtig?

Ja , also Modul 1 weiss welche Daten es rauswirft... Modul 2 weiss welche Daten es erwartet... nur kann es sein das Modul 2a andere Sachen mit den Daten macht als Modul 2b

Ein paar Ideen die ich bisher gesammelt habe in Stichworten:

- ASN.1 ( ASN.1C)
- BER (Basic Encoding Rules)
- Übergabe per ByteStream (Modul selbst kümmert sich dann um das umwandeln in
Daten) d.h. ich benötige am Ende von Eingabemodul, sowie am Eingang und am
Ende von Verarbeitungsmodul und zusätzlich am Ausgabemoduleingang eine
Umwandlungsroutine....

Stream allgemein

Naja und selbe Daten sind es auch nicht immer, deshalb ja der Modulare ansatz... einmal kommen z.b. 2 Strings und 3 Zahlen im Datenpacket, das andere mal 3 Strings und nix... das dritte mal 5 Strings und 10 Zahlen...

d.h. das vorgehen wäre soo... ich kuck welche Daten den reinkommen... (von Hand) dementsprechend wähle ich das Eingabemodul(z.b. von Textdatei, Ethernet,...), das mir die Daten überprüft, ob z.b. alle Felder gefüllt sind...
nun kommt die übergabe an das Verabeitungsmodul... das z.b. 2 Strings tauscht... und zu den zahlen was addiert oder sonstiges...
dann die Übergabe zum Ausgabemodul, das mir die Daten rauswirft... z.b. auf Console, in Textfile, auf Netzwerkschnittstelle... (dies steht ja dann im Ausgabemodul)

CStoll schrieb:

Dann wäre es vielleicht eine gute Idee, die Schnittstellen deiner Module zu standardisieren (d.h. du definierst eine Menge an Datenformaten und zwei Module können nur miteinander verbunden werden, wenn sie kompatibel sind).

Ja diesen Tip habe ich auch schon bekommen... hast du ein beispiel??

danke UFO

p.s. das ganze soll unter Linux erstellt werden... d.h. da ich die Module ja während der Laufzeit des Programms lade, müssen es .so Files sein... wie sieht es da dann mit den Übergabeparametern aus... (also beim Laden der .so files kann man ja direkt die Funktion angeben, die er aus der .so File aufrufen soll... mit Übergabe geht das ja auch (Cosinus 2.0 Beispiel)

CStoll

UFOSWORLD schrieb:

CStoll schrieb:

Mal sehen, ob ich dich richtig verstehe: Modul 1 hat einige Ausgänge und weiß, welche Typen es dort liefert. Modul 2 hat Eingänge und erwartet dort bestimmte Typen. Soweit richtig?

Ja , also Modul 1 weiss welche Daten es rauswirft... Modul 2 weiss welche Daten es erwartet... nur kann es sein das Modul 2a andere Sachen mit den Daten macht als Modul 2b

Was die einzelnen Module mit den Daten machen, ist irrelevant. Wichtig ist, daß Modul 2die Ausgabedaten von Modul 1 versteht

Naja und selbe Daten sind es auch nicht immer, deshalb ja der Modulare ansatz... einmal kommen z.b. 2 Strings und 3 Zahlen im Datenpacket, das andere mal 3 Strings und nix... das dritte mal 5 Strings und 10 Zahlen...

Randfrage: Um was für Daten geht es denn hier? Und kommen diese verschiedenen Datenzusammenstellungen im selben Programmlauf vor?

CStoll schrieb:

Dann wäre es vielleicht eine gute Idee, die Schnittstellen deiner Module zu standardisieren (d.h. du definierst eine Menge an Datenformaten und zwei Module können nur miteinander verbunden werden, wenn sie kompatibel sind).

Ja diesen Tip habe ich auch schon bekommen... hast du ein beispiel??

Auf Anhieb nicht. Aber die DirectX-Filtergraphen bauen afair auf einem vergleichbaren Konzept auf.

PS: Mit .so Files kenne ich mich nicht so aus. Aber die Datenübergabe wirst du vermutlich IN deinem Programm realisieren müssen.

Mal eine (mögliche) Prinziplösung

//mögliche Übertragungstypen
enum pin_data{p_int,p_string,...};

//algemeiner Pin:
class pin
{
  pin_data m_type;
public:
  bin_data get_type() { return m_type; }

//Eingabepin eines Moduls:
class in_pin
{
  out_pin* m_src;
public:
  bool connect(out_pin* src,bool checked=false)
  {
    if(checked || (m_type == src->get_type()))
    {
      m_src = src;
      src->connect(this);
      return true;
    }
    else
    {
      //eventuell Konverter-Module laden und indirekt verbinden
      return false;
    }
  }
};

//Ausgabepin
class out_pin
{
  //analog dazu aufgebaut
};

//Eingabemodul - hat nur Datenausgänge
template<int out>
class input_module
{
  out_pin m_opins[out];
public:
  ...
};

//Ausgabemodul - hat nur Dateneingänge
template<int in>
class output_module
{
  in_pin m_ipins[in];
public:
  ...
};

//Verarbeitungsmodul
template<int in,int out>
class transform_module : public output_module<in>,public input_module<out>
{
  ...
};