Solution plus élégante possible ou pas ?

Version imprimable

Salut, alors je vais essayé d'expliqué ma solution.

J'écris des données de tout type d'objets dans un fichier à l'aide de quelque classes et une macro qui associe un type de base à ses types dérivé en déclarant une structure qui hérite d'un sérialiseur qui contient un tuple avec un pointeur sur l'objet dérivé et un pointeur sur l'objet de base.

Cette macro ajoute donc la déclaration de cette structure dans la classe de base ainsi qu'un objet de cette structure en variable membre à la classe de base. (j'appelle cet objet, la clé)

Le sérialiseur contient plusieurs fonctions utiles :

-Une pour rechercher le type réel de l'objet et appeler la fonction de sérialisation sur le type réel de l'objet en faisant une recherche à l'aide de typeid dans le tuple.
-Une autre pour retourner l'index du pointeur sur le type réel de l'objet dans le tuple.
-Et enfin, une autre pour pouvoir allouer le pointeur sur l'objet de base avec le type réel de l'objet à la lecture. (Pour connaître le type réel de l'objet j'écris juste l'id du type réel de base de l'objet dans un fichier)

Le problème est que le compilateur n'a pas l'air d'aimer cela, bref, voici une solution que j'ai mis en place et qui marche avec l'option -fpermissive :

Voici le sérialiseur qui contient le tuple et qui contient quelque fonctions/structure utilitaire d'allocation, de recherche d'index et de type ainsi que d'appel de la fonction sur le type réel de l'objet à l'exécution.

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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
#ifndef ODFAEG_SERIALIZATION
#define ODFAEG_SERIALIZATION
#include <iostream>
#include <typeinfo>
#include "tuple.h"
#include <tuple>
namespace odfaeg {
template <int N, typename B, typename T, typename A>
struct serializer {
    static void checkType (B* base, T tuple, A & ar) {
        if (std::get<N>(tuple) != nullptr && typeid(*base) == typeid(*std::get<N>(tuple))) {
            std::get<N>(tuple)->serialize(ar);
        }
        serializer<N-1, B, T, A>::checkType(base, tuple, ar);
    }
};
template <typename B, typename T, typename A>
struct serializer <0, B, T, A> {
    static void checkType (B* base, T tuple, A & ar) {
        if (std::get<0>(tuple) != nullptr && typeid(*base) == typeid(*std::get<0>(tuple))) {
            std::get<0>(tuple)->serialize(ar);
        } else if (base != nullptr) {
            base->serialize(ar);
        }
 
    }
};
template <int N, typename B, typename T>
struct sallocator {
    static B* instanciate (int index, T tuple) {
        if (N == index) {
            using D = typename std::remove_pointer<typename std::tuple_element<N, T>::type>::type;
            return new D();
        }
        sallocator<N-1, B, T>::instanciate(index, tuple);
    }
};
template <typename B, typename T>
struct sallocator <0, B, T> {
    static B* instanciate (int index, T tuple) {
        using D = typename std::remove_pointer<typename std::tuple_element<0, T>::type>::type;
        return new D();
    }
};
template <int N, typename B, typename T>
struct sindex {
    static int getIndex (B* base, T tuple) {
        if (std::get<N>(tuple) != nullptr && typeid(*base) == typeid(*std::get<N>(tuple))) {
            return N;
        }
        sindex<N-1, B, T>::getIndex(base, tuple);
    }
};
template <typename B, typename T>
struct sindex <0, B, T> {
    static int getIndex (B* base, T tuple) {
        using D = typename std::remove_pointer<typename std::tuple_element<0, T>::type>::type;
        D* derived = new D();
        if (std::get<0>(tuple) != nullptr && typeid(*base) == typeid(*std::get<0>(tuple))) {
            return 0;
        }
        return -1;
    }
};
 
template <class B, class... D>
class Serializer {
    public :
    Serializer() {
        baseObject = nullptr;
    }
    Serializer(B* baseObject) : baseObject(baseObject) {
        fillTuple(derivedClasses);
    }
    void setObject(B* baseObject) {
        this->baseObject = baseObject;
        fillTuple(derivedClasses);
    }
    template<int... S>
    void fillTuple(std::tuple<D*...> types) {
        fillTuple(typename helper::gens<sizeof...(D)>::type(), types);
    }
    template<int... S>
    void fillTuple(helper::seq<S...>, std::tuple<D*...> params) {
         derivedClasses = std::forward_as_tuple(dynamic_cast<typename std::remove_reference<decltype(std::get<S>(params))>::type> (baseObject)...);
    }
    template <typename Archive>
    void serialize(Archive & ar) {
        if (std::tuple_size<decltype(derivedClasses)>::value > 0)
            serializer<std::tuple_size<decltype(derivedClasses)>::value-1, B, decltype(derivedClasses), Archive>::checkType(baseObject, derivedClasses, ar);
        else
            baseObject->serialize(ar);
    }
    virtual void onSave() {
    }
    virtual void onLoad() {
    }
    B* sallocate(int index) {
        if (std::tuple_size<decltype(derivedClasses)>::value > 0)
            return sallocator<std::tuple_size<decltype(derivedClasses)>::value-1, B, decltype(derivedClasses)>::instanciate(index, derivedClasses);
 
    }
    int getIndex() {
        if (std::tuple_size<decltype(derivedClasses)>::value > 0)
            return sindex<std::tuple_size<decltype(derivedClasses)>::value-1, B, decltype(derivedClasses)>::getIndex(baseObject, derivedClasses);
        return -1;
    }
    private :
    B* baseObject;
    std::tuple<D*...> derivedClasses;
};
}
#endif // SERIALIZATION

Si le type statique de l'objet est le même que le type dynamique de l'objet, alors je retourne -1 comme index.

Voici le contenu de mon autre fichier qui n'est rien d'autre qu'une macro qui va inclure le tout dans le fichier.h de la classe de base pour que je puisse avoir accès à la clé dans l'archive :

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
 
#include "serialization.h"
#ifndef SERIALIZATION_CPP
#define SERIALIZATION_CPP
#define REGISTER_KEY(KEY, TYPE, TYPES...)  \
struct KEY : public  odfaeg::Serializer<TYPE, TYPES> { \
    public : \
    KEY () {} \
    void register_object (TYPE* object) { \
        setObject(object); \
    } \
    TYPE* allocate_object(int index) { \
        return sallocate(index); \
    } \
    int getTypeIndex () { \
        return odfaeg::Serializer<TYPE, TYPES>::getIndex(); \
    } \
    template <typename Archive> \
    void serialize_object (Archive & ar, int) { \
        odfaeg::Serializer<TYPE, TYPES>::serialize(ar); \
    } \
}; \
KEY key; \
static TYPE* allocate (int index) { \
    static KEY aKey; \
    return aKey.allocate_object(index); \
}
#endif // SERIALIZATION_CPP

Et enfin dans l'archive je n'ai plus qu'à accéder à la clé, afin d'écrire tout ça :

Si l'objet possède un pointeur de fonction prenant une archive et un int, alors, cela veut dire que il est possible que l'objet soit polymoprhique, sinon, j'appelle directement la fonction serialize contenue dans la classe de l'objet. (J'ai deux fonction, une contenue dans la classe de l'objet et une autre contenue dans la définition de la clé), le int dans la fonction elle même ne sert donc à rien, il me sert juste à appliquer le principe de SFINAE.

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
 
template <class O,
              class... D,
              class = typename std::enable_if<std::is_member_function_pointer<void(O::*)(OTextArchive&)>::value>::type,
              class = typename std::enable_if<std::is_member_object_pointer<decltype(&O::key)>::value>::type,
              class = typename std::enable_if<!std::is_same<O, std::string>::value>::type,
              class = typename std::enable_if<!sizeof...(D)>::type>
void operator() (O* object, D...) {
        std::map<unsigned long long int, unsigned long long int>::iterator it = adresses.find(reinterpret_cast<unsigned long long int>(object));
        if (it != adresses.end()) {
            buffer<<it->second<<" ";
        } else {
            int index = -1;
            std::pair<unsigned long long int, unsigned long long int> newAddress (reinterpret_cast<unsigned long long int>(object), nbSerialized);
            adresses.insert(newAddress);
            if (typeid(decltype(*object)) == typeid(*object)) {
                std::cout<<"non polymoprhic version"<<std::endl;
                buffer<<newAddress.second<<" ";
                buffer<<index<<" ";
                object->serialize(*this);
            } else {
                std::cout<<"polymoprhic version"<<std::endl;
                object->key.register_object(object);
                index = object->key.getTypeIndex();
                buffer<<newAddress.second<<" ";
                buffer<<index<<" ";
                object->key.serialize_object(*this, 0);
            }
            nbSerialized++;
        }
    }

Je sauve donc l'index du type dynamique de l'objet. (-1 si le type dynamique est le même que le type statique)

Cette solution marche extrêmement bien et me permet de définir ce que je veux sérialiser dans le fichier.h de la classe de base et même redéfinir ça dans le main si le fichier.h est contenu dans une librairie pour ne pas avoir à modifer le .h de la librairie si je rajoute des classes dérivées.

Cependant il y a un petit problème à la lecture :

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
 
void operator() (O** object, D...) {
 
        unsigned long long int id;
        int index;
        buffer>>id;
        buffer>>index;
        std::map<unsigned long long int, unsigned long long int>::iterator it = adresses.find(id);
        if (it != adresses.end()) {
            *object = reinterpret_cast<O*>(it->second);
        } else {
            if (index == -1) {
                 std::cout<<"non polymorphic version"<<std::endl;
                 *object = new O();
                (*object)->serialize(*this);
                std::pair<unsigned long long int, unsigned long long int> newAddress (id, reinterpret_cast<unsigned long long int>(object));
                adresses.insert(newAddress);
            } else {
                std::cout<<"polymorphic version"<<std::endl;
                *object = O::allocate(index);
                (*object)->key.register_object(*object);
                (*object)->key.serialize_object(*this, 0);
                std::pair<unsigned long long int, unsigned long long int> newAddress (id, reinterpret_cast<unsigned long long int>(object));
                adresses.insert(newAddress);
            }
            nbDeserialized++;
        }
    }

Que voici :

Code:

1
2
3
4
5
6
7
8
9
 
||=== Build: Debug in ODFAEG-DEMO (compiler: GNU GCC Compiler) ===|
/home/laurent/Développement/Projets-c++/ODFAEG-DEMO/main.cpp|9|warning: "G2DEKEY" redefined [enabled by default]|
/usr/local/include/odfaeg/Graphics/2D/entity.h|13|note: this is the location of the previous definition|
/home/laurent/Développement/Projets-c++/ODFAEG-DEMO/main.cpp|36|warning: "/*" within comment [-Wcomment]|
/usr/local/include/odfaeg/Core/archive.h||In instantiation of ‘void odfaeg::ITextArchive::operator()(O**, D ...) [with O = odfaeg::BoundingBox; D = {}; <template-parameter-1-3> = void; <template-parameter-1-4> = void; <template-parameter-1-5> = void; <template-parameter-1-6> = void]’:|
/home/laurent/Développement/Projets-c++/ODFAEG-DEMO/main.cpp|65|required from here|
/usr/local/include/odfaeg/Core/archive.h|513|error: invalid conversion from ‘odfaeg::BoundingVolume*’ to ‘odfaeg::BoundingBox*’ [-fpermissive]|
||=== Build failed: 1 error(s), 4 warning(s) (0 minute(s), 5 second(s)) ===|

J'ai donc rajouté l'option -fpermissive pour que gcc me foute la paix car de toute façon il n'ira jamais dans le else si le type dynamique est diffférent du type statiqque, mais je ne sais pas si c'est la meilleur solution.

27/08/2014, 12h00
Astraya

J'ai rien compris :aie:

Mais une simple surcharge de l'opérateur de flux << et >> ne suffit pas? Si c'est juste de la sérialisation tu te complique vraiment la vie.

Sinon un manière élégante et plus complexe que les flux est de créer un Custom RTTI, je te laisse cherche sur Google

Pour commencer, chaque warning devrait être corrigé...

Citation:

error: invalid conversion from ‘odfaeg::BoundingVolume*’ to ‘odfaeg::BoundingBox*’

il te hurle (error) qu'un odfaeg::BoundingVolume* n'est pas un ‘odfaeg::BoundingBox*.
C'est à dire qu'a priori, BoundingVolume n'hérite pas de BoundingBox
C'est d'ailleurs très probablement le contraire.

La solution est un down cast, qui je crois s'écrit avec std::dynamic_cast.
Et c'est toujours une erreur.

Le code utilisateur de ta sérialisation devrait pouvoir agir de la même manière qu'avec std::cout.
Je m'explique:

Si je veux écrire une classe Bidule sur cout, j'ai le code suivant:
Code:

1 2 3 4 5 class Bidule{} std::ostream& operator<<(std::ostream & os, Bidule const& that) {//avec un warning sur that unused, je sais... return os <<"un bidule quelconque"; }
Je suis obligé d'écrire une fonction supplémentaire ayant un nom et une signature précis.

cela sous entends qu'on a dans <iostream> les choses suivantes:
Code:

1 2 3 4 5 6 7 class ostream{ //... ostream& operator<<(int); ostream& operator<<(char); ostream& operator<<(double); ostream& operator<<(const void*); };
(voir une spec)

Tu pourrais faire pareil:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 namespace serializer{ classe Serializer{ Serializer& operator<<(int); Serializer& operator<<(char); Serializer& operator<<(double); Serializer& operator<<(const void*); }; } namespace lib { class BoundingVolume{...}; Serializer& operator<<(Serializer&, BoundingVolume const&); }
et t'attendre à ce que ton utilisateur écrive ceci:
Code:

1 2 3 4 5 6 7 8 9 10 class Bidule : public BoundingVolume{...}; Serializer& operator<<(Serializer&, Bidule const&); int main () { serializer::Serializer output; lib::BoundingVolume *box = new lib::BoundingBox(), *bidule = new Bidule(...); output<<*box << *bidule; return 0; }
J'ai volontairement pris operator<<, parce qu'il y a une souplesse avantageuse: il peut être défini comme fonction membre ou comme fonction libre.
Les fonctions membres pour les primitifs, car Serializer est le seul à savoir qu'en faire.
Les fonctions libres pour les autres types, ce qui permet de les faire définir par l'utilisateur.

Ce qu'il nous manque pour t'aider enfin, c'est une spécification du format d'archivage.
Ca ressemble à la version fichier d'un vector< pair<string type, string serialform> >
auquel cas, il te suffit de définir des fonctions qui produit les pair<string type, string serialform> correspondant à chaque type.

Si je comprends bien, ton problème se résume à avoir une classe permettant de stocker des pointeurs de fonction de traduction.
Quelque chose qui réponde au besoin logique suivant :

Code:

template <class C extends serializable> Archive& Archive::operator<<(C const&);

il existe type_info, j'imagine que ceci est presque possible (je n'ai pas vraiment essayé)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class Archive { public: typedef Archive& (*serialize_t)(Archive&, serializable const&); private: map<type_info, serialize_t> helpers; public: void register(type_info const& type, serialize_t helper) { if ( ! /*validation de type*/ ) throw std::illegal_argument(); helpers.emplace(type, helper); } Archive& operator<<(serializable const& that) { return helpers[/*je ne sais plus obtenir le type_info de that*/](*this, that); } };

27/08/2014, 13h07
iNaKoll

Citation:

Envoyé par Lolilolight

Salut, alors je vais essayé d'expliqué ma solution.

J'écris des données de tout type d'objets dans un fichier à l'aide de quelque classes et une macro qui associe un type de base à ses types dérivé en déclarant une structure qui hérite d'un sérialiseur qui contient un tuple avec un pointeur sur l'objet dérivé et un pointeur sur l'objet de base.

FAIL. Pourquoi faire simple quand on peut faire compliqué
27/08/2014, 14h36
Invité

Salut.

Finalement j'ai réussi à avoir un code qui compile, sans devoir rajouté d'option, je m'étais, en effet trompé et il fallait que je spécifie une surcharge de fonction supplémentaire.

Je ne veux en effet ne pas passer par un système de "custom RTTI" qui compliquerai les choses.

Je veux avoir un truc simple.

Le problème des opérateurs << et >>, c'est qu'il ne peuvent prendre qu'un (ou deux si ce n'est pas une fonction membres) arguments supplémentaire, je ne peux pas utiliser SFINAE donc.
27/08/2014, 14h40
Astraya

Citation:

Le problème des opérateurs << et >>, c'est qu'il ne peuvent prendre qu'un (ou deux si ce n'est pas une fonction membres) arguments supplémentaire, je ne peux pas utiliser SFINAE donc.

Bas tu créer juste une class serialize, tu ajoutes des fonctions read write et tu les surcharges dans chaque classe enfant. je comprends pas pourquoi tu as fais si compliqué
27/08/2014, 14h50
the Hound

Citation:

Envoyé par Lolilolight

Je veux avoir un truc simple.

8O
27/08/2014, 15h53
Invité

Salut.

Je ne peux malheureusement pas surcharger une fonction template. :/

Et puis j'ai voulu partir sur un système similaire à celui de boost pour des raisons de compatibilité.
27/08/2014, 16h05
Invité
Ce code :
Code:

1 2 template <class C extends serializable> Archive& Archive::operator<<(C const&);
Ne fonctionne que en java non ?

Avec typeinfo je crains que cela ne soit pas possible, il faut appeler l'operateur<< sur le bon type, donc, je dois doit pouvoir stocker le bon type en compilation et le rechercher à l'exécution pour appeler la fonction de la bonne classe.

Je trouve pas ças très pratique de devoir redéfinir l'operator<< pour tout les types primitifs.
27/08/2014, 16h07
Astraya

Citation:

Je ne peux malheureusement pas surcharger une fonction template. :/

Mais tu peux ne pas faire de template ^^
27/08/2014, 16h10
Invité

Mmm, ça ne va pas être très pratique de ne pas faire de template (à vrai dire je ne suis pas très convaincu par cette possibilité), surtout que j'ai pleins de type différents à sérialiser, et en plus, il peut y avoir aussi plusieurs type d'archives différentes.
27/08/2014, 17h58
ternel

Citation:

Envoyé par Lolilolight

Ce code :
template <class C extends serializable> Archive& Archive::operator<<(C const&);Ne fonctionne que en java non ?

c'est pourquoi que je parlais de besoin logique.

Citation:

Envoyé par Lolilolight

Avec typeinfo je crains que cela ne soit pas possible, il faut appeler l'operateur<< sur le bon type, donc, je dois doit pouvoir stocker le bon type en compilation et le rechercher à l'exécution pour appeler la fonction de la bonne classe.

Je trouve pas ças très pratique de devoir redéfinir l'operator<< pour tout les types primitifs.

L'écriture d'une classe doit être pratique pour son utilisateur, pas son concepteur.
Et les types primitifs sont peu nombreux, 13 si j'en crois ostream.

En plus, tu as l'avantage de pouvoir compter sur les conversions.
Tu peux te contenter dans un premier temps de const char*, void*, bool, char, long, et double

C'est l'intérêt de ma suggestion.
Une classe n'est toujours qu'un type précis et une suite de variables de types primitifs, regroupées potentiellement en sous-structures.
Quelque soit l'archive elle doit aisément savoir sauvegarder les types primitifs, et les chaines de caractères.

Il te reste à fournir aux créateurs de classes de dire dans quel ordre sérialiser leurs membres.

Il existe des bibliothèques qui utilise propose la création de zip, de sockets, etc via des classes héritant de ostream.
Je ne vois pas ce qui t’empêche d'en faire autant.

Tu ne peux pas espérer magiquement sauvegarder une classe que tu ne connais pas sans demander à son fournisseur un minimum de travail.
27/08/2014, 18h23
Invité

Ok, béh je pense que je vais essayer ça hein.

Donc je n'ai qu'à appelé l'operateur<< sur l'archive qui va prendre, un objet. (ou un type primitif donc)

Et surcharger les opérateurs << et >> dans les classes dérivée si il y en a, c'est ça ?

Alors je devrai en plus faire hériter chaque classe d'une classe de base commune que je vais passer à l'opérateur de flux.

Mmm, je ne sais pas si c'est très pratique pour l'utilisateur de faire cela, faire hériter chaque classe de serializable.

Ici il ne fait que de redéfinir une méthode et utiliser une macro dans la classe de base, donc, il ne faut modifier que la classe de base et redéfinir la méthode serialize dans chaque classes, avec ton système, il faudrait faire hériter toutes les classe du serializer, je préfère quand même lorsque l'utilisateur ne doit pas faire d'héritage, ne penses tu pas que ça serait plus simple ?

Maintenant il y a aussi un inconvénient avec la macro ce sont les problèmes liés aux forwards déclaration. (Le serializer a besoin de la définition complète de la classe dérivée hors il ne la connaît pas.)

Mais ce qui me surprend c'est que avec la classe BoundingBox ça compile sans que le serializer aie besoin de la définition complète de la classe, avec la classe Tile, ça me fou une erreur de compilation.

J'ai du loupé quelque chose mais je ne vois pas quoi...

Il me semble que j'avais déjà essayé ta solution avec les operateurs << que je redéfinissais sur les archives, mais, ça ne marchera pas, l'opérateur doit retourner un objet de type ostream. (Et pas un objet de type Archive&)
27/08/2014, 19h59
Invité

Bon je pense que je vais faire comme tu dis finalement, je ne vois pas d'autres solution, j'en ai marre de ses erreurs de compilations due aux forward déclarations et ça devient in maintenable.

J'espère simplement que ta solution va fonctionner.
27/08/2014, 20h01
Invité

Ha oui, il y a aussi un autre inconvénient, je dois redéfinir les opérateur << et >> donc deux opérateur au lieu d'un seul.
27/08/2014, 20h25
ternel

C'est aussi vrai avec cin cout...
La magie n'existe pas, on a rien sans rien.
27/08/2014, 20h45
Invité

Ok bah je vais essayer de faire cela.

Avec l'opérateur& peut être que, il y a moyen de faire qu'un seul opérateur.

Je vais voir...
27/08/2014, 21h35
ternel

Oui, mais non, parce que chaque classe se sérialize différemment.

Et tu n'as pas des douzaines de classes différentes. Si?

Ouais par contre, je ne vois pas comment faire quelque chose comme ceci :

Code:

1
2
 
template <typename D extends B> operator<<(std::ostream& out, Serializable &o)

Peut être en faisant une classe de base nommée Archive et la faire dérivé.

Ma solution utilisant une classe de trait ne fonctionne pas, pourtant, je ne pense pas qu'il aie besoin du type complet de la classe ici, si ?

Code:

1
2
3
4
5
6
7
8
9
10
 
struct sallocator {
    static B* instanciate (int index, T tuple) {
        if (N == index) {
            using D = typename std::remove_pointer<typename std::tuple_element<N, T>::type>::type;
            return new D();
        }
        sallocator<N-1, B, T>::instanciate(index, tuple);
    }
};

Ou alors peut être pour connaître la taille de la classe.
Pareil pour le dynamic cast il a besoin de connaître la définition complète de la classe.

Code:

1
2
 
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Graphics/2D/../../../../include/odfaeg/Graphics/2D/../../Math/../Core/serialization.h|56|error: invalid use of incomplete type ‘using D = std::__remove_pointer_helper<odfaeg::g2d::Tile*, odfaeg::g2d::Tile*>::type {aka class odfaeg::g2d::Tile}’|

En fait ce que je voudrais faire c'est allouer le pointeur avec le type dynamique de l'objet (lors de la lecture), mais je ne vois pas du tout comment faire, en plus, j'ai un problème, c'est que je dois connaître la définition complète de la classe de l'objet pour pouvoir l'allouer.

Donc, je ne peut pas stocker un wrapper dans la classe de base de l'objet, car dans la classe de base je n'ai pas la définition complète des classes dérivée, et, je ne vois pas du tout comment je pourrai réglé se problème. :/

Si quelqu'un à une solution je suis preneur, j'ai essayé d'inclure les .h des classes dérivées dans le wrapper, mais ça ne marche pas, j'ai alors une autre erreur :

Code:

1
2
 
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Core/../../../include/odfaeg/Core/../Graphics/../Physics/../Core/../Graphics/2D/../transformable.h|17|error: ‘BoundingBox’ does not name a type|

A cause de la forward déclaration ici :

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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
#ifndef ODFAEG_ENTITY_2D_HPP
#define ODFAEG_ENTITY_2D_HPP
#include "../transformable.h"
#include "../drawable.h"
#include "../../Physics/boundingVolume.h"
#include "../../Core/state.h"
#include "../../Core/stateExecutor.h"
#include "../renderTarget.h"
#include "../face.h"
#include "../../Math/computer.h"
#include <vector>
namespace odfaeg {
    namespace g2d {
    class Tile;
/**Class entity by Laurent Duroisin (all right reserved)
 * this abstract class is the base of all drawable and transformable's entities of the framework.
 * this class inherits from the transformable and the drawable class.
 * entities are components, then, they can have parent entities and children entities.
 * (CF : Design pattern component)
 */
class ODFAEG_GRAPHICS_API Entity : public Transformable, public Drawable {
    public :
        /** position : the position of the top left corner of the entity
         * size : the size of the entity
         * origin : the origin of the entity's position wich is local to the entity's position.
         * zOrder : the layer's position of the entity
         * type : the type of the entity. (the type can be anything (model, floor, light, shadow, etc...))
         * the type should describe the kind of the entity.
         * parent : the parent of the entity, the value is null if the entity doesn't have a parent.
         */
        Entity (Vec3f position, Vec3f size, Vec3f origin, std::string type, Entity* parent = nullptr);
        //Get the number of entities created with the application.
        static int getNbEntities ();
        //Get teh type of the entity.
        std::string getType() const;
        //Get the type's id of the entity.
        int getTypeInt ();
        //Get the type corresponding to the given id.
        static std::string getTypeOfInt (int type);
        //Get the id corresponding to the given type.
        static int getIntOfType (std::string type);
        //Get the radius of the entity.
        int getRadius ();
        std::string getRootType();
        //Init the map who is a correspondance between a type of an entity and the id of it's type.
        static std::map<int, std::string>* initTypes () {
            if (types == nullptr) {
                static std::map<int, std::string> *t = new std::map<int, std::string> ();
                return t;
            }
            return types;
        }
        //Return the id of the entity.
        int& getId();
        //Set an id to the entity.
        void setId (int id);
        //This method have to be redifinied to determine when two entity's are equals.
        //This can avoid to have two equqls entity's at the same place.
        virtual bool operator== (Entity& other) = 0;
        void draw (RenderTarget &target, RenderStates states);
        virtual void onDraw(RenderTarget &target, RenderStates states) const {}
        virtual void onMove(Vec3f &t);
        virtual void onScale(Vec3f &s);
        virtual void onRotate(float angle);
        //Return the parent of the entity.
        Entity* getParent() const;
        //Set the parent's entity of the entity.
        void setParent (Entity *parent);
        //Add a children to the entity.
        void addChild (Entity *child);
        //Remove a children to the entity.
        void removeChild (Entity *child);
        //Return the children of the entities.
        std::vector<Entity*> getChildren() const;
 
        //Return the number of entity's children.
        unsigned int getNbChildren ();
        //Determine if the entity is animated.
        virtual bool isAnimated() const = 0;
        //Determine if the entity have a shadow.
        virtual bool isModel() const = 0;
        virtual bool selectable() const = 0;
        virtual bool isLight() const = 0;
        virtual bool isShadow() const = 0;
        virtual bool isLeaf() const = 0;
        //Set the type of the entity.
        void setType (std::string type);
        //Destructor.
        template <typename T> bool addAttribute (std::string name, T value) {
            return entityState.addParameter(name, value);
        }
        template <typename T> bool addAttribute (std::string name, T* value) {
            return entityState.addParameter(name, value);
        }
        const StateParameter& getAttribute (const std::string name) throw (odfaeg::Erreur) {
               return entityState.getParameter(name);
        }
        template <typename T> void changeAttribute (const std::string name, T value) {
           entityState.changeParameter(name, value);
        }
        bool removeAttribute (std::string name) {
            entityState.removeParameter(name);
        }
        bool interact(StateExecutor *se) {
            entityState.setExecutor(se);
            return entityState.doActionState();
        }
        bool uninteract (StateExecutor *se) {
            entityState.setExecutor(se);
            return entityState.undoActionState();
        }
        void setCollisionVolume (BoundingVolume* volume) {
            this->collisionVolume = volume;
        }
        BoundingVolume* getCollisionVolume () const {
            return collisionVolume;
        }
        void addFace(Face* face);
        std::vector<Face*> getFaces() const;
        template <typename Archive>
        void serialize(Archive & ar) {
            Transformable::serialize(ar);
            ar(id);
            ar(faces);
            ar(type.first);
            ar(type.second);
            ar(children);
            ar(parent);
            ar(children);
            ar(collisionVolume);
        }
        void onLoad() {
            types = initTypes();
            int iType = getIntOfType(getType());
            if (iType == -1) {
                type = std::pair<int, std::string> (nbEntitiesTypes, getType());
                types->insert(type);
                nbEntitiesTypes++;
            }
            nbEntities++;
        }
        virtual ~Entity();
    protected :
        std::vector<Face*> faces;
        static std::map<int, std::string> *types;
        std::pair<int, std::string> type;
        std::vector<Entity*> children;
        Entity* parent;
        int id;
        static int nbEntities, nbEntitiesTypes;
        State entityState;
        BoundingVolume *collisionVolume;
        REGISTER_KEY(G2DENTITY, Entity, Tile)
};
}
}
#endif

Bref j'arrive pas à trouver une solution pour passer outre de ses problèmes de forward déclaration.

28/08/2014, 13h53
Invité

Je pense que j'ai trouvé une autre solution, je vais essayer passer les clés dans les classes OTextArchive et ITextArchive comme le fait boost et non plus dans la classe de base de l'objet ainsi fini les problèmes il suffira que j'inclus les classes dérivée avant d'inclure l'archive mais actuellement je ne vois pas de trop comment exporter les clés dans les archives.
29/08/2014, 09h06
Invité

J'ai essayé de sortir le dynamic_cast du serializer, et de le mettre dans l'archive mais j'ai alors des problèmes d'incomplete type avec les std::tuple_element. (Même en incluant les header des classes dérivée dans le fichier archive.h)

Donc faut absolument que le tuple aie la définition complète des classes dérivée. :/

Pas pratique. :/
29/08/2014, 11h27
Astraya

Non mais sérieusement revois ta logique sur la sérialisation. C'est d'un complexe sans nom. Un objet est responsable de sa propre lecture/écriture. Donc un objet qui doit être serialisable à des méthode read/write ou les opérateurs << et >>. Tu complexifie un problème qui peut se résoudre simplement. Tu ne fais que ajouter de la complexité sans rien apporter.
Revois tout ça, sinon je te pari que dans 2 semaines tu y es encore.

Sans blague, quand google donne un demi million de résultats (a priori) pour ostream zip, et que les premiers résultats sont des libs completes en quelques pages de code, je ne vois pas comment tu n'arrives pas à en faire autant.

ton problème est divisible en trois partie:
produire du binaire pour chaque type, et donner un nom unique à ce type.
Il suffit alors d'hériter d'une classe telle que:
Code:

1 2 3 4 struct serializable { virtual std::string asBinary() const = 0; virtual std::string typename() const = 0;//please use fully qualified type name such as "std::string" };
.
créer un format quelconque enchainant identifiant de type et binaire correspondant.
Sans compression, je coderai ca comme ceci:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 namespace serializing{ class Archive { private: multimap<std::string/*type_id*/, std::string /*serial form*/> data; public: Archive& operator <<(serializable const& that) { data.emplace(that.typename(), that.asBinary()); return *this; } void toFile(const char* filename) { std::fstream file(filename); for(auto item : data) { file<<item.first << item.second << '\n'; } } }; }
Pour la deserialization, tu sais ce que tu veux obtenir, sinon, tu ne le demanderai pas. Utilise des factory et constructeur explicite depuis une string.

29/08/2014, 15h18
Invité

Citation:

Pour la deserialization, tu sais ce que tu veux obtenir, sinon, tu ne le demanderai pas. Utilise des factory et constructeur explicite depuis une string.

C'est plutôt au niveau de la désérialization que je sèche.

Je ne vois pas comment allouer un pointeur sur un type, hors que je n'ai pas la définition complète de la classe pour ce type.

Utiliser une factory tu me dis ?

Ok, je vais essayer!

Pour désérialiser un objet précis, il faut que ta classe archive (de ta bibliothèque) donne (une copie de) la forme sérialisée de l'objet demandé.
C'est au code utilisateur d'en faire ce qu'il veut.
à lui d'écrire la fonction de conversion, de la même façon que c'était à lui de fournir la fonction de sérialisation.

Quitte à passer par une spécialisation de template pour uniformiser un peu le code.

Peut être quelque chose comme:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 //archive.hpp #include <string> namespace serializing{ struct undeserializable{} typedef std::string serial_form; class archive{ private: serial_form sourceOf(id) const; template<typename T> T make<T>(serial_form serial) const {throw undeserializable();} public: template<typename T> get(id id) const { return make<T>(serialOf(id)); } // ... }; }//serializing::
Code:

1 2 3 4 5 6 7 8 9 //camion.hpp #include "archive.hpp" class Camion{ Camion(serializing::serial_form); }; template<> Camion serializing::Archive::make<Camion>(serializing::serial_form serial) const { return Camion(serial); }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include <iostream> #include "archive.hpp" #include "camion.hpp" using serializing::Archive; using namespace std; int main() { Archive archive; //probablement du code de chargement Camion monJoliCamion = archive.get<Camion>(17); cout << monJoliCamion<<endl; return 0; }
Bien évidemment, il y aura au fond de la bibliothèque un fichier archive.cpp qui implémente la map<id, serializing::serial_form> que constitue Archive, ainsi que les accès fichiers correspondant.

Ok, bon, j'ai créer une factory pour enregistrer tout les types, ainsi que toutes les version des fonctions à appeler dans le main.

Je me sert du type de base comme référence pour la factory.

Et je prend comme id le type dynamique de l'objet pour appeler la bonne fonction.

Premièrement donc j'ai du faire une factory, celle-ci permet d'enregister des fonctions et des types, je défini dans chaque classe dérivée une fonction pour aller un objet avec le type dynamique.

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
 
template <typename B>
class BaseFact {
    public :
    static void register_type(std::string typeName, B*(*func)()) {
        typename std::map<std::string, B*(*)()>::iterator it = types.find(typeName);
        if (it == types.end())
            types[typeName] = func;
    }
    static void register_function(std::string typeName, FastDelegate<void> delegate) {
        typename std::map<std::string, FastDelegate<void>>::iterator it = functions.find(typeName);
        if (it == functions.end())
            functions[typeName] = delegate;
    }
    template <typename... A>
    static void callFunction(std::string typeName, A... args) {
        typename std::map<std::string, FastDelegate<void>>::iterator it = functions.find(typeName);
            if (it == functions.end()) {
                it->second.setParams(args...);
                (it->second)();
            }
    }
    static B* create (std::string typeName) {
        typename std::map<std::string, B*(*)()>::iterator it = types.find(typeName);
        if (it != types.end())
            return types[typeName]();
        return nullptr;
    }
    static std::string getTypeName (B* type) {
        typename std::map<std::string, B*(*)()>::iterator it = types.find(typeid(*type).name());
        if (it != types.end())
            return it->first;
    }
    private :
    static std::map<std::string, B*(*)()> types;
    static std::map<std::string, FastDelegate<void>> functions;
};

Ainsi je n'ai plus qu'à passer le type à l'exécution, et à créer l'objet, ou bien, appeler une fonction dessus, ça marche aussi pour les fonctions template à condition d'enregister chaque spécialisation possible pour la fonction template, l'utilité du delegate (contrairement à std::function) est que même si je ne connais pas le type dynamique de l'objet en compilation lors de l'appel de la fonction, je peux fournir un pointeur sur la fonction membre de la classe dérivée, le delegate va faire un down cast sur le type statique de l'objet que je lui passe pour avoir le type dynamique de l'objet avant d'appeler la fonction. (Lors de l'appel de la fonction setParams)
Ceci me permet de simuler un système de fonctions templates virtuelles.

Pour simplifier l'enregistrement des types et des fonctions, j'ai créer plusieurs macros, la 1ère ajoute juste une fonction non membre create dans le fichier.h d'une classe dérivée :

Macro à appeler à la fin du fichier.h de chaque classe dérivées.

Code:

1
2
3
4
5
 
#define REGISTER_DERIVED(ID, BASE, TYPE) \
BASE* create##ID() { \
    return new TYPE(); \
}

La seconde enregistre un type dérivé dans la factory :

Code:

1
2
3
 
#define REGISTER_TYPE(ID, BASE, TYPE) \
odfaeg::BaseFact<BASE>::register_type(typeid(TYPE).name(), &create##ID);

Et la 3ème enregistre une fonction dans la factory, je suis obligé d'utiliser le suffixe vt (virtual template) devant le nom de la fonction car la macro ne peut pas concaténer le texte avec l'opérateur :: ce qui me donne ceci :

Code:

1
2
3
4
 
#define REGISTER_FUNC(ID, funcName, BASE, TYPE, args...) \
odfaeg::FastDelegate<void> delegate##ID (&TYPE::vt##funcName, args); \
odfaeg::BaseFact<BASE>::register_function(typeid(TYPE).name(), delegate##ID);.

Voilà et j'appelle ces 2 dernières macro au tout début du main pour enregistrer les fonctions et les types et pouvoir ainsi les appeler en fonction de leur type à l'exécution.

Cependant il y a un soucis au linkage, le compilateur me ressors cette erreur :

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
 
||=== Build: Debug in ODFAEG-DEMO (compiler: GNU GCC Compiler) ===|
/usr/local/include/odfaeg/Physics/boundingBox.h|172|définitions multiples de « createBoundingBox() »|
obj/Debug/caracter.o:/usr/local/include/odfaeg/Physics/boundingBox.h|172|défini pour la première fois ici|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Graphics/../../../include/odfaeg/Graphics/../Physics/boundingBox.h|172|définitions multiples de « createBoundingBox() »|
obj/Debug/caracter.o:/usr/local/include/odfaeg/Physics/boundingBox.h|172|défini pour la première fois ici|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Graphics/../../../include/odfaeg/Graphics/../Physics/boundingBox.h|172|définitions multiples de « createBoundingBox() »|
obj/Debug/caracter.o:/usr/local/include/odfaeg/Physics/boundingBox.h|172|défini pour la première fois ici|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Graphics/../../../include/odfaeg/Graphics/../Physics/boundingBox.h|172|définitions multiples de « createBoundingBox() »|
obj/Debug/caracter.o:/usr/local/include/odfaeg/Physics/boundingBox.h|172|défini pour la première fois ici|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Graphics/2D/../../../../include/odfaeg/Graphics/2D/../../Physics/boundingBox.h|172|définitions multiples de « createBoundingBox() »|
obj/Debug/caracter.o:/usr/local/include/odfaeg/Physics/boundingBox.h|172|défini pour la première fois ici|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Graphics/2D/../../../../include/odfaeg/Graphics/2D/../../Physics/boundingBox.h|172|définitions multiples de « createBoundingBox() »|
obj/Debug/caracter.o:/usr/local/include/odfaeg/Physics/boundingBox.h|172|défini pour la première fois ici|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Graphics/2D/../../../../include/odfaeg/Graphics/2D/../../Physics/boundingBox.h|172|définitions multiples de « createBoundingBox() »|
obj/Debug/caracter.o:/usr/local/include/odfaeg/Physics/boundingBox.h|172|défini pour la première fois ici|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Graphics/../../../include/odfaeg/Graphics/../Physics/boundingBox.h|172|définitions multiples de « createBoundingBox() »|
obj/Debug/caracter.o:/usr/local/include/odfaeg/Physics/boundingBox.h|172|défini pour la première fois ici|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Graphics/../../../include/odfaeg/Graphics/../Physics/boundingBox.h|172|définitions multiples de « createBoundingBox() »|
obj/Debug/caracter.o:/usr/local/include/odfaeg/Physics/boundingBox.h|172|défini pour la première fois ici|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Graphics/../../../include/odfaeg/Graphics/../Physics/boundingBox.h|172|définitions multiples de « createBoundingBox() »|
obj/Debug/caracter.o:/usr/local/include/odfaeg/Physics/boundingBox.h|172|défini pour la première fois ici|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Physics/../../../include/odfaeg/Physics/boundingSphere.h|120|définitions multiples de « createBoundingSphere() »|
obj/Debug/main.o:/usr/local/include/odfaeg/Physics/boundingSphere.h|120|défini pour la première fois ici|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Physics/../../../include/odfaeg/Physics/boundingBox.h|172|définitions multiples de « createBoundingBox() »|
obj/Debug/caracter.o:/usr/local/include/odfaeg/Physics/boundingBox.h|172|défini pour la première fois ici|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Physics/../../../include/odfaeg/Physics/boundingSphere.h|120|définitions multiples de « createBoundingSphere() »|
obj/Debug/main.o:/usr/local/include/odfaeg/Physics/boundingSphere.h|120|défini pour la première fois ici|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Physics/../../../include/odfaeg/Physics/boundingBox.h|172|définitions multiples de « createBoundingBox() »|
obj/Debug/caracter.o:/usr/local/include/odfaeg/Physics/boundingBox.h|172|défini pour la première fois ici|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Physics/../../../include/odfaeg/Physics/boundingBox.h|172|définitions multiples de « createBoundingBox() »|
obj/Debug/caracter.o:/usr/local/include/odfaeg/Physics/boundingBox.h|172|défini pour la première fois ici|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Physics/../../../include/odfaeg/Physics/boundingSphere.h|120|définitions multiples de « createBoundingSphere() »|
obj/Debug/main.o:/usr/local/include/odfaeg/Physics/boundingSphere.h|120|défini pour la première fois ici|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Physics/../../../include/odfaeg/Physics/boundingSphere.h|123|définitions multiples de « createBoundingSphere() »|
obj/Debug/main.o:/usr/local/include/odfaeg/Physics/boundingSphere.h|120|défini pour la première fois ici|
/home/laurent/Développement/Projets-c++/ODFAEG/src/odfaeg/Physics/../../../include/odfaeg/Physics/boundingBox.h|172|définitions multiples de « createBoundingBox() »|
obj/Debug/caracter.o:/usr/local/include/odfaeg/Physics/boundingBox.h|172|défini pour la première fois ici|
||=== Build failed: 36 error(s), 0 warning(s) (0 minute(s), 5 second(s)) ===|

Pourtant, je n'appelle qu'une seule fois la macro REGISTER_DERIVED dans les classe dérivée, je ne comprend pas pourquoi il me dit que la fonction est définie plusieurs fois.

Voila merci d'avance pour votre aide. (Là j'ai le sentiment que je commence à avancer)

Bon il suffisait de déclarer la fonction inline ...

Et voilà ça fonctionne merci!!!

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
81
82
83
84
85
86
87
 
#ifndef ODFAEG_SERIALIZATION_HPP
#define ODFAEG_SERIALIZATION_HPP
#include <iostream>
#include <typeinfo>
#include "tuple.h"
#include <tuple>
#include <map>
#include "fastDelegate.h"
#define REGISTER_DERIVED(ID, BASE, TYPE) \
inline BASE* create##ID() { \
    return new TYPE(); \
}
#define REGISTER_TYPE(ID, BASE, TYPE) \
odfaeg::BaseFact<BASE>::register_type(typeid(TYPE).name(), &create##ID);
#define REGISTER_FUNC(ID, FID, funcName, BASE, TYPE, args...) \
odfaeg::FastDelegate<void> delegate##ID##FID (&TYPE::vt##funcName, args); \
odfaeg::BaseFact<BASE>::register_function(typeid(TYPE).name(), #FID, delegate##ID##FID);
 
namespace odfaeg {
template <typename B>
class BaseFact {
    public :
    static void register_type(std::string typeName, B*(*func)()) {
        typename std::map<std::string, B*(*)()>::iterator it = types.find(typeName);
        if (it == types.end()) {
            types[typeName] = func;
        }
    }
    static void register_function(std::string typeName, std::string funcName, FastDelegate<void> delegate) {
        typename std::map<std::string, FastDelegate<void>>::iterator it = functions.find(typeName + funcName);
        if (it == functions.end())
            functions[typeName+funcName] = delegate;
    }
    template <typename... A>
    static void callFunction(std::string typeName, std::string funcName, A... args) {
        typename std::map<std::string, FastDelegate<void>>::iterator it = functions.find(typeName+funcName);
            if (it != functions.end()) {
                it->second.setParams(args...);
                (it->second)();
            }
    }
    static B* create (std::string typeName) {
        typename std::map<std::string, B*(*)()>::iterator it = types.find(typeName);
        if (it != types.end()) {
            return (it->second)();
        }
        return nullptr;
    }
    static std::string getTypeName (B* type) {
        typename std::map<std::string, B*(*)()>::iterator it = types.find(typeid(*type).name());
        if (it != types.end())
            return it->first;
    }
    private :
    static std::map<std::string, B*(*)()> types;
    static std::map<std::string, FastDelegate<void>> functions;
};
template <typename B>
std::map<std::string, B*(*)(void)> BaseFact<B>::types = std::map<std::string, B*(*)(void)>();
template <typename B>
std::map<std::string, FastDelegate<void>> BaseFact<B>::functions = std::map<std::string, FastDelegate<void>>();
 
template <class B>
class Serializer : public BaseFact<B> {
    public :
    Serializer() : BaseFact<B>() {
        baseObject = nullptr;
    }
    void setObject(B* baseObject) {
        this->baseObject = baseObject;
    }
    template <typename Archive>
    void serialize(std::string funcName, Archive * ar) {
        BaseFact<B>::callFunction(typeid(*baseObject).name(), funcName, baseObject, ar);
    }
    B* sallocate(std::string typeName) {
        return BaseFact<B>::create(typeName);
    }
    std::string getTypeName() {
        return BaseFact<B>::getTypeName(baseObject);
    }
    private :
    B* baseObject;
};
}
#endif // SERIALIZATION

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
 
#ifndef SERIALIZATION_IMPL
#define SERIALIZATION_IMPL
#include "serialization.h"
#define REGISTER_BASE(KEY, TYPE) \
struct KEY : public Serializer<TYPE> { \
    public : \
    KEY() : Serializer<TYPE>() {} \
    void register_object (TYPE* object) { \
        setObject(object); \
    } \
    TYPE* allocate_object(std::string typeName) { \
        return sallocate(typeName); \
    } \
    std::string getTypeName () { \
        return Serializer<TYPE>::getTypeName(); \
    } \
    template <typename Archive> \
    void serialize_object (std::string funcName, Archive * ar) { \
        serialize(funcName, ar); \
    } \
}; \
public : \
KEY key; \
typedef KEY KEYTYPE; \
virtual void foo() {} \
static TYPE* allocate (std::string typeName) { \
    static KEY aKey; \
    return aKey.allocate_object(typeName); \
}
#endif

Dans la classe de base je met juste le type de base et l'id. (Et non plus la liste des types dérivés)

Code:

1
2
 
REGISTER_BASE(BOUNDINGVOLUMEKEY, odfaeg::BoundingVolume)

Par contre je dois enregistrer les types dérivés à la fin des fichiers.h des classes dérivée :

Code:

1
2
 
REGISTER_DERIVED(BoundingSphere, odfaeg::BoundingVolume, odfaeg::BoundingSphere)

Dans l'archive je n'ai plus qu'à faire ceci lors de l'écriture :

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
 
//Dynamic objects.
    template <class O,
              class... D,
              class = typename std::enable_if<!std::is_fundamental<O>::value>::type,
              class = typename std::enable_if<!std::is_same<O, std::string>::value>::type,
              class = typename std::enable_if<has_typedef_key<O>::value>::type,
              class = typename std::enable_if<!sizeof...(D)>::type>
    void operator() (O& object, D...) {
        if (typeid(decltype(object)) == typeid(object)) {
            object.vtserialize(this);
        } else {
            object.key.register_object(&object);
            object.key.serialize_object("OTextArchive", this);
        }
    }
    template <class O,
              class... D,
              class = typename std::enable_if<!std::is_fundamental<O>::value>::type,
              class = typename std::enable_if<!std::is_same<O, std::string>::value>::type,
              class = typename std::enable_if<has_typedef_key<O>::value>::type,
              class = typename std::enable_if<!sizeof...(D)>::type>
    void operator() (O* object, D...) {
        std::map<unsigned long long int, unsigned long long int>::iterator it = adresses.find(reinterpret_cast<unsigned long long int>(object));
        if (it != adresses.end()) {
            buffer<<it->second<<" ";
        } else {
            std::string typeName = "BaseType";
            std::pair<unsigned long long int, unsigned long long int> newAddress (reinterpret_cast<unsigned long long int>(object), nbSerialized);
            adresses.insert(newAddress);
            if (typeid(decltype(*object)) == typeid(*object)) {
                buffer<<newAddress.second<<" ";
                buffer<<typeName<<std::endl;
                object->vtserialize(this);
            } else {
                object->key.register_object(object);
                typeName = object->key.getTypeName();
                buffer<<newAddress.second;
                buffer<<typeName<<std::endl;
                object->key.serialize_object("OTextArchive", this);
            }
            nbSerialized++;
        }
    }

Et lors de la lecture :

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
 
 //Dynamic objects.
    template <class O,
              class... D,
              class = typename std::enable_if<!std::is_fundamental<O>::value>::type,
              class = typename std::enable_if<!std::is_same<O, std::string>::value>::type,
              class = typename std::enable_if<has_typedef_key<O>::value>::type,
              class = typename std::enable_if<!sizeof...(D)>::type>
    void operator() (O& object, D...) {
        if (typeid(decltype(object)) == typeid(object)) {
            object.vtserialize(this);
        } else {
            object.key.register_object(&object);
            object.key.serialize_object("ITextArchive", this);
        }
    }
    template <class O,
              class... D,
              class = typename std::enable_if<!std::is_fundamental<O>::value>::type,
              class = typename std::enable_if<!std::is_same<O, std::string>::value>::type,
              class = typename std::enable_if<has_typedef_key<O>::value && !std::is_abstract<O>::value>::type,
              class = typename std::enable_if<!sizeof...(D)>::type>
    void operator() (O*& object, D...) {
 
        unsigned long long int id;
        std::string typeName;
        buffer>>id;
        getline(buffer, typeName);
        std::map<unsigned long long int, unsigned long long int>::iterator it = adresses.find(id);
        if (it != adresses.end()) {
            object = reinterpret_cast<O*>(it->second);
        } else {
            if (typeName == "BaseType") {
                 object = new O();
                 object->vtserialize(this);
                std::pair<unsigned long long int, unsigned long long int> newAddress (id, reinterpret_cast<unsigned long long int>(object));
                adresses.insert(newAddress);
            } else {
                object = O::allocate(typeName);
                object->key.register_object(object);
                object->key.serialize_object("ITextArchive", this);
                std::pair<unsigned long long int, unsigned long long int> newAddress (id, reinterpret_cast<unsigned long long int>(object));
                adresses.insert(newAddress);
            }
            nbDeserialized++;
        }
    }
    template <class O,
              class... D,
              class = typename std::enable_if<!std::is_fundamental<O>::value>::type,
              class = typename std::enable_if<!std::is_same<O, std::string>::value>::type,
              class = typename std::enable_if<has_typedef_key<O>::value>::type,
              class = typename std::enable_if<std::is_abstract<O>::value>::type,
              class = typename std::enable_if<!sizeof...(D)>::type>
    void operator() (O*& object, D...) {
        std::string typeName;
        unsigned long long int id;
        buffer>>id;
        getline(buffer, typeName);
        std::map<unsigned long long int, unsigned long long int>::iterator it = adresses.find(id);
        if (it != adresses.end()) {
            object = reinterpret_cast<O*>(it->second);
        } else {
            object = O::allocate(typeName);
            object->key.register_object(object);
            object->key.serialize_object("ITextArchive", this);
            std::pair<unsigned long long int, unsigned long long int> newAddress (id, reinterpret_cast<unsigned long long int>(object));
            adresses.insert(newAddress);
            nbDeserialized++;
        }
    }

Et enfin, dans le main, je n'ai plus qu'à enregistrer tout les types dérivés et toutes les fonctions que j'appelle pour sérialiser tout les types dérivés dans toutes les types d'archives :

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
 
REGISTER_TYPE(BoundingBox, odfaeg::BoundingVolume, odfaeg::BoundingBox)
    REGISTER_TYPE(BoundingSphere, odfaeg::BoundingVolume, odfaeg::BoundingSphere)
    sf::VideoMode mode(800, 600);
    sf::ContextSettings settings(0, 0, 4, 3, 0);
 
    odfaeg::RenderWindow window(mode, "test", sf::Style::Default, settings);
    odfaeg::Texture tex, tex2;
    tex.loadFromFile("tilesets/herbe.png");
    std::ostringstream oss;
    std::string text = "Ceci est un texte.";
    std::ofstream ofss("FichierDeSerialization.tex");
    {
        odfaeg::OTextArchive oa(ofss);
        oa(tex);
        //oa<<ofss;
    }
    ofss.close();
    std::istringstream iss;
    std::ifstream ifss("FichierDeSerialization.tex");
    {
        odfaeg::ITextArchive ia(ifss);
        ia(tex2);
        //ia>>ifss;
    }
    ifss.close();
    odfaeg::BoundingVolume* b1 = new odfaeg::BoundingSphere(odfaeg::Vec3f(0, 0, 0), 100);
    odfaeg::BoundingVolume* b2;
 
    std::ofstream ofs("FichierDeSerialisation");
    odfaeg::OTextArchive oa(ofs);
    REGISTER_FUNC(BoundingBox, OTextArchive, serialize, odfaeg::BoundingVolume, odfaeg::BoundingBox, new odfaeg::BoundingBox(), &oa);
    REGISTER_FUNC(BoundingSphere, OTextArchive, serialize, odfaeg::BoundingVolume, odfaeg::BoundingSphere, new odfaeg::BoundingSphere(), &oa);
    oa(b1);
    ofs.close();
 
    std::ifstream ifs("FichierDeSerialisation");
    odfaeg::ITextArchive ia(ifs);
    REGISTER_FUNC(BoundingBox, ITextArchive, serialize, odfaeg::BoundingVolume, odfaeg::BoundingBox, new odfaeg::BoundingBox(), &ia);
    REGISTER_FUNC(BoundingSphere, ITextArchive, serialize, odfaeg::BoundingVolume, odfaeg::BoundingSphere, new odfaeg::BoundingSphere(), &ia);
    ia(b2);
    std::cout<<static_cast<odfaeg::BoundingSphere*>(b2)->getCenter()<<" "<<static_cast<odfaeg::BoundingSphere*>(b2)->getRadius()<<std::endl;
    ifs.close();

Et dans le fichier j'ai bien ceci :

Code:

1
2
3
4
 
0N6odfaeg14BoundingSphereE
bounding volume
0 0 0 1 100

J'utilise un pointeur sur l'archive car ma classe FastDelegate ne fonctionne pas avec les références. :/

Et voilà je n'ai plus qu'à lancer des exceptions si le développeur oublie d'enregistrer une fonction, ou bien un type dérivé.

30/08/2014, 15h15
ternel

Tant mieux!

Content de voir que ca marche enfin.
30/08/2014, 16h45
Invité

Ouais moi aussi!

Je me demande si il y aurait moyen d'enregistrer les types et les fonctions automatiquement, mais, je ne pense pas que ça soit possible, étant donné que je peux pas passer un pointeur sur la fonction courante comme le pointeurs this pour les objets. (Je ne pense pas que ça soit possible)

Dommage que gcc n'aie pas un système pour enregistrer les fonctions templates pour les objets polymorphiques et permettre de pouvoir définir ainsi des fonctions template virtuelles.