Moin,
ich habe ein Eventsystem, das Delegates benutzt, um Events zu verarbeiten.
Es soll eine Basisklasse UserInterface geben und mehrere Unterklassen, z.b. MainInterface. Eine Methode von MainInterface könnte dann z.b. so heißen: AppliedSettings
Interfaces sind für mich nichts anderes als eine Ansammlung von Steuerelementen - normalerweise entspricht der Inhalt eines fensters einem Interface, aber man kann das natürlich noch weiter aufteilen und Interfaces können auch andere Interfaces enthalten. (Frame ftw.!)
Mein Problem ist jetzt, dass ich eine Liste von Delegates habe, die an einem Event lauschen. Diese Delegates müssen nicht zwingend dasselbe Interface besitzen und können somit Instanzen verschiedener Klassen sein. Das beißt sich mit der Idee der Liste.
Delegate.h:
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
#ifndef DELEGATE_H
#define DELEGATE_H
namespace SF{
namespace Core{
template <typename T, typename R, typename P> class Delegate{
T &obj;
typedef R (T::*ptr)(P);
ptr callback;
public:
Delegate(T &obj, ptr callback): obj(obj), callback(callback) {}
R operator()(P p){
return (obj.*callback)(p);
}
};
}
}
#endif
|
MainInterface.h
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
#ifndef MAIN_INTERFACE_H
#define MAIN_INTERFACE_H
#include "UserInterface.h"
#include "Event.h"
#include "MsgBox.h"
class MainInterface: public SF::GUI::UserInterface{
public:
bool test(SF::GUI::Event evt){
std::shared_ptr<SF::GUI::MsgBox> meineBox = SF::Core::EnvFactory::createMsgBox(std::wstring(L"Es funktioniert!!!"));
return true;
}
};
#endif
|
Auszug aus EventDispatcher.h:
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
|
class EventDispatcher{
public:
typedef SF::Core::Delegate<SF::GUI::UserInterface, bool, Event> Callback;
protected:
typedef std::list<Callback> ClientsContainer;
|
Das Problem besteht also eigentlich darin, wie ich Objekte unterschiedlichen Typs in einem Standardcontainer untergebracht & verarbeitet bekomme. Das mit unterschiedlichen Typen ist aber eigentlich nicht relevant, da die Delegates zum Standardcontainer hin alle gleich aussehen (wenn ich z.b. nen Pointer auf das Objekt nehmen würde). Nur intern im Delegate spielen die unterschiedlichen Typen eigentlich eine Rolle. Problematisch ist hier die obige Verwendung von Templates, weil sie die Typinformation nach außen zum Standardcontainer herausträgt. (was ja eigentlich nicht nötig wäre).
Ich weiß, dass es mit Boost möglich ist, einen Standarcontainer mit Objekten unterschiedlicher Typen zu füllen. Aber eigentlich suche ich mehr nach einer Lösung, die Klasse nach außen zu verstecken und nur intern im Delegate zu unterscheiden. Ich frage hier, weil mir dazu genau nix einfällt.
Mit freundlichen Grüßen,
dispy