[POO/Template] Problème de conception du à une classe template
Bonjour à tous :)
Alors voila je souhaite charger un objet dynamique depuis un fichier xml : par exemple un fichier nommé ninja qui contiendrait la position du ninja, le mesh utilisé...
Je créer donc un attribut pour chaque propriété du ninja (position, mesh).
J'ai une classe Attribute :
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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
|
template<class T>
class _NaosExport_ Attribute : public BaseAttribute
{
protected:
/// Type de l'attribut (float, int...)
Ogre::String mType;
/// Valeur de l'attribut.
T mValue;
public:
/**
* Constructeur par défaut.
*/
Attribute(const Ogre::String _type, T _value):
mType(_type),
mValue(_value)
{}
/**
* Destructeur.
*/
virtual ~Attribute(void)
{}
/**
* BaseAttribute::serialize().
*/
virtual shared_ptr<xmlpp::Document> serialize(void)
{
shared_ptr<xmlpp::Document> document(new xmlpp::Document("noname"));
xmlpp::Element* rootNode = document->create_root_node(mType);
Ogre::String attributeValueString = lexical_cast<Ogre::String>(mValue);
rootNode->set_attribute("value", attributeValueString);
return document;
}
/**
* BaseAttribute::deserialize().
*/
virtual bool deserialize(xmlpp::Element* _element)
{
if(_element == NULL)
{
return false;
}
else
{
xmlpp::Attribute* attribute = _element->get_attribute("value");
if(attribute == NULL)
{
return false;
}
else
{
Ogre::String attributeValue = attribute->get_value();
mValue = lexical_cast<T>(attributeValue);
}
}
return true;
}
/**
* Retourne le type de l'attribut.
*/
Ogre::String getType(void) const { return mType; }
/**
* Retourne la value de l'attribut.
*/
T getValue(void) const { return mValue; }
}; |
Mainteant dans mon DynamicObjectManager j'ai la possibilité d'enregistrer des callbacks (functor) qui vont me permettre de charger (avec Ogre) les attributs d'un objet dynamique : position, mesh...
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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
|
class _NaosExport_ BaseDynamicObjectCallbackFunctor
{
public:
/**
* Constructeur par défaut.
*/
BaseDynamicObjectCallbackFunctor(void) {}
/**
* Destructeur.
*/
virtual ~BaseDynamicObjectCallbackFunctor(void) {}
/**
* Effectue l'appel à la fonction.
* @Param _attribute : attribut analysé par le callback.
*/
virtual void handle(shared_ptr<BaseAttribute> _attribute) = 0;
};
template<class T>
class _NaosExport_ DynamicObjectCallback : public BaseDynamicObjectCallbackFunctor
{
public:
typedef void (T::*CallbackPtr)(shared_ptr<BaseAttribute> _attribute);
private:
/// Instance de la classe chargée d'analyser l'attribut.
T* mObject;
/// Pointeur sur méthode de l'objet ci-dessus.
CallbackPtr mFunction;
public:
/**
* Constructeur par défaut.
* @Param _object : instance de la classe chargée d'analyser l'attribut.
* _function : pointeur sur la méthode de l'objet ci-dessus.
*/
DynamicObjectCallback(T* _object, CallbackPtr _function):
mObject(_object),
mFunction(_function)
{}
/**
* Destructeur.
*/
virtual ~DynamicObjectCallback(void)
{
NAOS_DELETE(mObject);
}
/**
* Effectue l'appel à la fonction.
* @Param _attribute : attribut analysé par le callback.
*/
virtual void handle(shared_ptr<BaseAttribute> _attribute)
{
if(mObject == NULL)
{
Debugger::getSingleton().logMessage("Tentative d'effectuer un appel à une fonction via un objet null");
return;
}
if(mFunction == NULL)
{
Debugger::getSingleton().logMessage("Tentative d'effectuer un appel à une fonction nulle via un objet");
return;
}
(mObject->*mFunction)(_attribute);
}
}; |
Un attribut est une classe template, l'argument T étant le type de la donnée que je veux y mettre.
Mais comme vous pouvez le voir les callback prennent en paramètre un BaseAttribute et non pas un Attribute donc je peux pas accéder aux méthodes de Attribute tel que getValue() qui me serait ici bien utile. Je pensais donc mettre en place une sorte d'enveloppe de ma classe Attribute pour pouvoir utilise Attribute et non pas BaseAttribute.
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
|
class AttributeProxy
{
private:
Ogre::String mName;
shared_ptr<BaseAttribute> mAttribute;
public:
AttributeProxy(const Ogre::String& _name, shared_ptr<BaseAttribute> _attribute):
mName(_name),
mAttribute(_attribute)
{}
~AttributeProxy() {}
Ogre::String getName(void) const
{
return mName;
}
template<class T> shared_ptr<T> getAttribute()
{
return dynamic_pointer_cast<T>(mAttribute);
}
}; |
Donc mes objet-fonctions ne prendrait plus en paramètre (dans la méthode handle) un shared_ptr<BaseAttribute> mais un shared_ptr<AttributeProxy>. Du coup avec ma méthode getAttribute je peux récupérer le bon type d'attribut grâce au cast
Est-ce conceptionnellement correct ?
