Delirium Corp

À coup d'essais et d'erreurs, j'y suis arrivé! Enfin, presque. J'utilise, pour faire simple, un objet global. Je sais, c'est laid, mais ce n'est que pour des fins de tests.

Bon! Il faut d'abord savoir que V8 fonctionne à coup de callbacks. Et un callback V8, pour une fonction (les objets utilisent des "accesseurs" et des "intercepteurs", qui ont une signature différente), eh bien, c'est une fonction qui a le prototype suivant (remplacez "callback" par le nom de votre choix):

v8::Handle<v8::Value> callback(const v8::Arguments &args);

Un tel prototype nous apprend deux choses:

1. Une fonction JS peut prendre un nombre arbitraire de paramètres (args encapsulant en fait un conteneur quelconque)


2. Une fonction JS retourne toujours une valeur. Il n'existe pas de fonction "void"

M'inspirant donc de l'exemple shell.cc, j'ai créé une fonction print qui sera appelée lorsqu'un script appellera une fonction JS nommée print:

v8::Handle<v8::Value> print(const v8::Arguments &args)
{
    if(args.Length() == 1) // On ne veut qu'un seul paramètre
    {
        v8::HandleScope handleScope; // On définit une portée pour nos Handle
        v8::String::Utf8Value str(args[0]); // On obtient la valeur du premier paramètre
        std::cout << *str << std::endl; // On l'affiche ainsi qu'un retour de ligne
    }
    return v8::Undefined(); // Les fonctions "void" sont en fait des fonctions qui retournent undefined
}

Cette fonction permettra donc à quelqu'un d'envoyer des données dans cout à travers un script JS.

Voici le concept: on veut créer un objet JS global nommé "collection" qui supportera deux méthodes: getObjectById(string), qui retourne un entier correspondant à la clé passée en paramètre (ou null si la clé n'existe pas), et setObject(string, int) qui assigne une valeur à une clé (ou la créé si la clé n'existe pas).

J'ai donc commencé par créer une classe TestCollection (un enrobage autour de std::map, en fait):

#include <map>
#include <exception>

template<class K, class V>
class TestCollection
{
public:
    typedef K key_type;
    typedef V value_type;
private:
    std::map<key_type, value_type> collection_;
public:
    value_type getObjectById(const key_type & id) const
    {
        std::map<key_type, value_type>::const_iterator itt = collection_.find(id);
        if(itt != collection_.end())
        {
            return itt->second;
        }
        else
        {
            throw std::exception("Object not found");
        }
    }
    void setObject(key_type id, value_type val)
    {
        collection_[id] = val;
    }
};

Définissons nous ensuite un objet global (oui, je sais, c'est laid):

TestCollection<std::string, int> collection;

Puis, créons les deux callbacks:

v8::Handle<v8::Value> setObject(const v8::Arguments &args)
{
    if(args.Length() == 2)
    {
        v8::HandleScope handleScope;
        v8::String::Utf8Value key(args[0]); // La clé, c-a-d une string
        v8::Local<v8::Value> value(args[1]); // La valeur, c-a-d un int
        collection.setObject(*key, value->Int32Value()); // On appelle la méthode setObject de l'objet
    }
    return v8::Undefined();
}

v8::Handle<v8::Value> getObjectById(const v8::Arguments &args)
{
    if(args.Length() == 1)
    {
        v8::HandleScope handleScope;
        v8::String::Utf8Value str(args[0]); // On va chercher la clé
        try
        {
            const std::string key(*str); // On créé une std::string à partir de la clé
            int i = collection.getObjectById(key); // On va chercher la valeur
            return v8::Int32::New(i); // On la retourne
        }
        catch(std::exception e)
        {
            // L'objet n'a pas été trouvé, on affiche le message
            std::cout << e.what();
        }
    }
    return v8::Null();
}

Ces deux fonctions ne sont en fait que des interfaces pour les méthodes du vrai objet.

int main()
{
    v8::HandleScope handleScope;
     // On créé l'objet global
    v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();
    // On créé la fonction print
    global->Set("print", v8::FunctionTemplate::New(print));
    // On créé la collection
    v8::Handle<v8::ObjectTemplate> collection = v8::ObjectTemplate::New(); 
     // On créé les deux méthodes de la collection
    collection->Set("getObjectById", v8::FunctionTemplate::New(getObjectById));
    collection->Set("setObject", v8::FunctionTemplate::New(setObject));         
    // On assigne la collection comme appartenant à global
    global->Set("collection", collection); 
    // On créé le contexte en spécifiant l'objet global
    v8::Handle<v8::Context> context = v8::Context::New(0, global); 
    // On exécute le script
    JSScript script("script.js", context); 
    script.run();

    system("pause");
} 

Tout d'abord, l'objet global. Lorsque l'on appelle une fonction libre ou que l'on accède à une variable globale, en JS, en fait, on appelle une méthode ou on accède à un attribut de l'objet global. Cet objet est créé comme n'importe quel objet, à l'aide d'un ObjectTemplate.
Même chose pour l'objet collection: celui-ci est en fait un ObjectTemplate auquel on ajoute deux méthodes (lesquelles sont des FunctionTemplate) à l'aide de la méthode Set. On ajoute ensuite collection à global à l'aide de Set, et on créé le contexte en informant celui-ci qu'il devra utiliser un objet global déja créé (par défaut, il créé un objet vide).
Voilà.
Ah, oui, JSScript est une petite classe que j'ai créée pour automatiser la logique de création et d'exécution d'un script. Son contenu est trivial alors je ne la dévoilerai pas ici.

Pour ceux que ça intéresse, voici le contenu de script.js:

collection.setObject("test", 2);
collection.setObject("test2", collection.getObjectById("test") + 2);
print(collection.getObjectById("test"));
print(collection.getObjectById("test2"));

Ce qui affiche 2 et 4.

D'ailleurs, je crois avoir compris pourquoi la doc est si mince sur V8: j'ai obtenu le code sur leur SVN, et le numéro de version est 0.4.7. C'est donc une beta. J'ai passé leur code dans Doxygen, mais celui-ci est si peu documenté que ça ne donne pas grand chose.



Prochaine étape: se débarrasser de cet horrible objet global.

Libellés : c++, v8