Discussion :

[nouknouk]

Bonjour,

dans le cadre d'un petit outil pour le binding Js <=> C++, je voudrais écrire une fonction template pour convertir différents types natif depuis et vers JS.

J'ai donc un template par défaut défini comme suit (1):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
template<typename TYPE>
TYPE JsToNative(JsObj object) {
	throw new Exception("unhandled JsToNative conversion.");
}

Je spécialise ensuite ce template pour différents types de base (int, string, ...). Les paramètres d'entrées restent identique (JsObj) ; seul celui de retou diffère. Par exemple (2):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
template<>
std::string JsToNative(JsObj object) {
    if (object.isJsString())
        return std::string(object.toString());
    else
        throw new Exception("bad JsToNative conversion: JS object is not a string.");
}

Mon problème est que je voudrais maintenant définir une spécialisation 'générique' qui s'applique pour tout TYPE qui soit un pointeur vers une instance de classe. Quelque chose comme (3):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
template<>
TYPE* JsToNative(JsObj object) {
    if (object->isJsObject()) {
        TYPE* ptr = dynamic_cast<TYPE*>( object->getBoundDataPointer() );
        if (ptr) 
            return ptr;
    }
    throw new Exception("bad JsToNative conversion: JS object is not bound to a native instance.");
}

Problème: cette dernière implémentation (et les autres variantes testées) ne fonctionnent pas quand j'essaie de lui passer un pointeur ( JsToNative<MonType*>(myJsObj) ) : soit le compilo essaie d'utiliser (1) à la place de (3), soit j'ai un "call of overloaded template function is ambiguous".

Une idée ?

Merci d'avance

[Kalith]

On ne peut pas faire de spécialisation partielle pour des fonctions templates.
Mais tu peux faire une pirouette en utilisant une classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
template<typename TYPE>
TYPE JsToNative(JsObj object) {
    return JsToNativeImpl<TYPE>::Convert(object);
}
 
template<typename TYPE>
class JsToNativeImpl;
// Note : il vaut mieux ne pas donner d'implémentation par défaut.
// En faisant ça, on obtient une erreur dès la compilation si on veut convertir
// un type Java en un type natif non supporté (au lieu d'une exception au runtime).
 
template<>
class JsToNativeImpl<std::string> {
public :
    static std::string Convert(JsObj object) {
        if (object.isJsString())
            return std::string(object.toString());
        else
            throw new Exception("bad JsToNative conversion: JS object is not a string.");
    }
};
 
template<TYPE>
class JsToNativeImpl<TYPE*> {
public :
    static TYPE* Convert(JsObj object) {
        if (object->isJsObject()) {
            TYPE* ptr = dynamic_cast<TYPE*>( object->getBoundDataPointer() );
            if (ptr) 
                return ptr;
        }
        throw new Exception("bad JsToNative conversion: JS object is not bound to a native instance.");
    }
};

Edit : correction du code (cf. post suivant).

[nouknouk]

Merci pour ta réponse rapide. A une ou deux typos près (forward déclaration de la classe, fonction statique publique, ...) c'est juste parfait.

Une petite question subsidiaire au passage ; l'utilisation de struct en lieu et place d'une classe poserait-elle un problème ?

[Kalith]

De rien !

Une petite question subsidiaire au passage ; l'utilisation de struct en lieu et place d'une classe poserait-elle un problème ?

Pas du tout. J'ai tapé le code ci-dessus un peu vite, mais en temps normal j'aurai effectivement utilisé struct, juste pour éviter d'avoir à écrire le public : (que j'avais effectivement oublié ).