Choix de design pour UndoManager
Bonjour,
Je suis en train de réaliser une librairie d'UndoManager (du moins je commence :p), le principe est de gérer deux stacks, une pour les undos, l'autre pour les redos. Jusqu'à présent j'avais pensé à quelque chose du style :
Code:
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
27
28
29
30
31
|
class UndoManager {
std::stack<UndoRedo*> m_undo_stack;
std::stack<UndoRedo*> m_redo_stack;
};
class UndoRedo {
public:
virtual void undo() =0;
virtual void redo() =0;
};
template <class UndoFunctor, class RedoFunctor>
class UndoItem : public UndoRedo {
private:
UndoFunctor m_undo;
RedoFunctor m_redo;
public:
virtual void undo(); //appel m_undo()
virtual void redo(); //appel m_redo()
}; |
Bref somme toute quelque chose de relativement simple. En farfouillant un peu sur le net, je suis tombé sur un article décrivant une implémentation d'undoManager de la manière suivante :
Code:
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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
template <class F>
class UndoRedo {
private:
F f;
public:
void undo() { f.undo(); }
void redo() { f.redo();}
};
template <class F>
class UndoManager {
std::stack<UndoRedo<F> > m_undo_stack;
std::stack<UndoRedo<F> > m_redo_stack;
};
class UndoAction {
public:
virtual void undo() =0;
virtual void redo() =0;
};
template <class UndoFunctor, class RedoFunctor>
class Concrete UndoAction : public UndoAction {
//identique à UndoItem du design précédent
};
//Instanciation de l'undomanager :
UndoManager<UndoAction> manager; |
Je ne comprends pas l'intérêt de rajouter une indirection supplémentaire. Dans le premier design, on a une interface pour les undo, et une class d'implémentation paramétrée pas les deux types de functors utilisés.
Dans le second cas, on paramètre une classe d'UndoAction par une interface UndoRedo, implémentée par la classe concrète du design précédent.
Y'a-t-il un réel intérêt à faire cela ?
