USBDaemon entwerfen mit Policies / Traits, USB Geräte

[Ein ehemaliger Benutzer]

Hi zusammen,

grübel mal über einem kleinen Problem... Ich möchte spezielle USB-Peripherie und deren Überwachung abbilden.

Die Peripherie sieht so aus (H = Hub, E = Endgerät):

H

E E E H

E E E E

Die einzelnen E können seperat abgenommen und angesteckt werden, oder der ganze Baum durch den obersten Hub. Der mittlere Hub ist fest.

Ausserdem können mehrere dieser Bäume an den Rechner angeschlossen werden.

--------------------------------------------------------------------------------

Die Endgeräte melden sich entweder als Massenspeicher oder als Modem (normale serielle Verbindung) an. D.h. InterfaceClass wird interessant sein, aber dazu später.

--------------------------------------------------------------------------------

Die Applikation hat erstmal 2 Schichten. Die unteres (Hardware-Überwachung) soll das Anmelden und Abmelden der Geräte überwachen. Die obere Schicht arbeitet dann mit Objekten, die das eigentlich Fachkonzept repräsentieren, aber assoziert sind mit den eigentlichen Hardware-Ressourcen. Die Idee dahinter ist Entkopplung.

Ich habe jetzt erstmal vor, ein Programm zur Überwachung in der ersten Schicht zur schreiben. Überwachung heisst in diesem Sinne erstmal, regelmässig eine Art Tabelle über die angeschlossenen Geräte und deren Anmeldungsmodus zu aktualisieren.
Die zweite Schicht kann dann regelmässig schauen, ob sich was geändert hat, oder sie lässt sich benachrichtigen.

--------------------------------------------------------------------------------

Wie die Suche nach diesen Geräten zu erfolgen hat, wollte ich in eine Policy auslagern (da Betriebssystem-spezifisch und somit zu Compile-Zeit bekannt), die ich mit den Charakteristika der zu suchenden Geräte parametrisiere.

Ich versuche jetzt mal meinen Ansatz mit Hilfe ein paar Codeteilchen zu erläutern:

USBDevicesTraits.h:

struct USBDeviceTraits_Base
{
	typedef unsigned short vendorID_type;

	static const vendorID_type vendorID = 0x0000; //spezielle Werte hier
};

template <typename> struct USBDeviceTraits: public USBDeviceTraits_Base {};

class Fachklasse; //Klasse der Objekte, die mit User interagieren
class Hub;

template<> struct USBDeviceTraits<Fachklasse>: public USBDeviceTraits_Base
{
	typedef unsigned short productID_type;
	typedef unsigned short deviceVersion_type;

	static const productID_type productID = 0x0000;
	static const deviceVersion_type deviceVersion = 0x0000;
};

template<> struct USBDeviceTraits<Hub>: public USBDeviceTraits_Base
{
	typedef unsigned short productID_type;
	typedef unsigned short deviceVersion_type;
	typedef unsigned char deviceClass_type;

	static const productID_type productID = 0x0000;
	static const deviceVersion_type deviceVersion = 0x0000;
	static const deviceClass_type deviceClass = 0x09;
};

FindingPolicy.h:

template <typename USBDeviceTraits> class USBDeviceFinderLinux
{
	public:
		static /*Rückgabe-Werte, Diskussion nachher*/ find()
{
			//Betriebssystem-abhängig bzw. API-abhängig
}
};

USBDaemon.h:

template <template <typename> class FindingPolicy> class CollectorDaemon
	: private	FindingPolicy<USBDeviceTraits<Fachklasse> >,
			FindingPolicy<USBDeviceTraits<Hub> >
{
	public:
		static void update()
{
			//rufe das richtige find()
                        //ändere Tabelle

}

	private:
		//Irgendeine Tabelle(n) / Zuordung Hub-Endgerät o.ä.
};

--------------------------------------------------------------------------------

Wo ich mich derzeit aufhänge, ist an den Rückgabetypen der find-Funktion in der Policy.

Die Überlegung ist folgende:

Die Funktion übernimmt die USB-GeräteCharakteristika, sucht sich die benötigten raus, um seine Aufgabe zu erfüllen und gibt eine Liste mit den fehlenden Informationen über die Geräte raus.
Allerdings gibt es jetzt ein Problem: Ich möchte unterschiedliche Rückgaben haben:

Input = Endgerät-Typ <=> Output -Liste = für mich wichtige Infos = (serialNo, parentSerialNo [=HubNo], interfaceClass [storage | modem], address [bspw. com1 oder i:])*

Input = Hub-Typ <=> Output -Liste = (serialNo, parentSerialNo)*

Ich komme somit echt ins Zweifeln, ob es da überhaupt noch sinnvoll ist, generisch zu programmieren. Ich meine, dadurch dass ich ein typisiertes "find" benutzte, sollte die Rückgabe auch klar sein, aber dazu müsste der Entwickler des find-Algorithmusses ja die Typen kennen?

Gut ich könnte auch generell Structs zurückgeben, wo einige Member einfach ungültige Werte besitzen...hmm

Was ich auf keinen Fall möchte, ist, dass die 1. Schicht schon die Fachklassen kennen muss.

Eine andere Überlegung, die mich derzeit umhertreibt, ist die, ob das Design überhaupt so sinnvoll ist. Vielleicht könnt ihr ja dazu eine Meinung abgeben?

Vielen Dank!

[Ein ehemaliger Benutzer]

*schieb*

Nanu, hat keiner eine Idee dazu :-)? Hier gibt es doch so einige Experten!