QScriptEngine et opération sur classe

Version imprimable

Salut!

Je viens vers vous concernant QScriptEngine.

J'ai defini une classe MyClass avec l operateur "+":

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
class MyClass
{
public:
    MyClass();
    MyClass(const double &value);
    MyClass(const MyClass &copy);
    MyClass operator+(const double &value);
    MyClass operator+(const QVariant &value);
    double m_value;
 
};
 
MyClass::MyClass()
{
}
 
MyClass::MyClass(const double &value)
{
    m_value = value;
}
 
MyClass::MyClass(const MyClass &copy)
{
    m_value = copy.m_value;
}
 
MyClass MyClass::operator+(const double &value)
{
    qDebug() << "MyClass::operator+ double";
    return MyClass(this->m_value + value);
}
 
MyClass MyClass::operator+(const QVariant &value)
{
    qDebug() << "MyClass::operator+ QVariant";
    return MyClass(this->m_value + value.toDouble());
}
 
// cette ligne permet d utiliser QVariant avec MyClass
Q_DECLARE_METATYPE(MyClass)

Test 1:
Donc le code suivant, fonctionne:

Code:

1
2
3
4
5
6
    MyClass inputB;
    inputB.m_value = 6;
    MyClass outputB;
    outputB = inputB+5;
    qDebug() << "input : " << inputB.m_value; // affiche 6
    qDebug() << "output: " << outputB.m_value; // affiche 11

J'essaie de faire la meme chose mais avec Qt Script.
La solution est d'utiliser QVariant() (ca fonctionne avec Q_DECLARE_METATYPE).

Test 2:
Donc le code suivant fonctionne (j evalue "A" tout seul):

Code:

1
2
3
4
5
6
    QScriptEngine engine;
    QScriptValue inputValue = engine.newVariant(QVariant::fromValue(inputB));
    engine.globalObject().setProperty("A",inputValue);
    outputB = engine.evaluate("A").toVariant().value<MyClass>();
    qDebug() << "input : " << inputB.m_value; // affiche 6
    qDebug() << "output: " << outputB.m_value; // affiche 6

Test 3:
Par contre, si je tente d'utiliser l operator +, ca ne fonctionne pas.

Code:

1
2
3
4
5
6
    QScriptEngine engine;
    QScriptValue inputValue = engine.newVariant(QVariant::fromValue(inputB));
    engine.globalObject().setProperty("A",inputValue);
    outputB = engine.evaluate("A+1").toVariant().value<MyClass>();
    qDebug() << "input : " << inputB.m_value; // affiche 6
    qDebug() << "output: " << outputB.m_value; // affiche 1.7952e-313 ou similaire

Je remarque que l’opérateur "MyClass::operator+(const QVariant &value)" n'est pas appelé dans le Test 3. Comment fonctionne l’évaluation en interne? Je suppose que c'est du au fait que QVariant utilise l'adresse. Mais alors, quelle est la solution?

Merci pour vos lumières!
Cordialement,

09/05/2012, 09h28
kmedghaith

Salut,

Ton operateur + ne peut pas marcher dans l'evaluateur de scripte car il n'est pas tagé Q_SLOT slot ou Q_INVOKABLE. (Il me semble que ça ne marche pas sur les operateurs de toute façon).
Ta classe n'hérite pas de QObject d'ailleurs.
Essaye de regarder

Code:

QScriptEngine::hasUncaughtException()

et

Code:

QScriptValue::isError()

pour avoir plus de détails sur ce qui ne marche pas.

MG.
09/05/2012, 12h34
RapotOR

Je ne suis pas fan de QObject dans ce cas.
J'ai quand meme fait un essai mais ce n'est pas concluant.
Je suis un peu déçu de la capacité de QtScript.
Le fonctionnement est un peu nébuleux. En plus, j'ai peur des copies en interne. L'utilisation de QVariant n'aide pas! Ca fait poupées russes entre ma classe, le QVariant et le fonctionnement interne QtScript...

Avant de découvrir QtScript, j'avais fait une classe d’interprétation de chaines basé sur "Reverse Polish notation" avec des fonctions et des variables. Pour finir, il fonctionne bien mieux. Mon but était le calcul d'expression avec la librairie armadillo. Ma solution boiteuse devrait être suffisante.

Merci quand même!
09/05/2012, 14h07
kmedghaith

Il y a un projet pas mal http://qt.gitorious.org/qt-labs/qtscriptgenerator qui permet de binder des types basiques (ceux de Qt du genre QPoint, QRect ...) sans avoir à hériter de QObject. Si tu as du temps, tu peux y jetter un coup d'oeil et t'en inspirer.
Mais c'est vrai que QtScript est utilisé étroitement avec les objets Qt. Personnellement je l'utilise principalement pour mes tests automatiques et ça marche plutôt bien. Tout dépend ce que tu veux faire après.

Pour la duplications des données, tu peux utiliser des pointeurs sur les données de tes classes, ça évitera de les dupliquer. Et si tu as le temps aussi, tu peux utliser le mécanismes de partage implicite pour robustifier ton code.

MG.
09/05/2012, 16h01
RapotOR

Merci pour les precisions.

J'avais déjà testé avec les pointeurs avec :

Code:

Q_DECLARE_METATYPE(double*)

Je n'ai malheureusement pas trouvé de solution viable.

Je vais plutôt utiliser ma classe d interprétation, elle est simple et rapide (à condition que l'interpretation reste juste :aie:). Je peux revenir la poster quand elle fonctionnera pile poil.

Par contre, ta remarque sur le partage implicite m'interresse fortement apres avoir lu quelques articles. Je vais creuser cette remarque qui peut être utile!

Merci.