Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

CAMP, nouvelle bibliothèque libre de réflexion pour C++.
La réflexion est-elle un besoin dans vos développements ?

Le , par Laurent Gomila

0PARTAGES

3  0 
Bonjour à tous

Tegesoft vient de publier la première version publique de CAMP, une bibliothèque libre permettant d'étendre les classes C++ pour leur donner des capacités d'introspection.

CAMP permet de binder classes, propriétés, fonctions et objets de manière complètement non-intrusive, afin de pouvoir les manipuler de manière homogène en runtime. Cela permet par exemple d'utiliser ses propres classes dans des scripts (Python, Lua, ...), de les sérialiser automatiquement via des formats textuels ou binaires, de les envoyer sur le réseau, de construire des éditeurs de propriétés, etc.

Le système est fortement inspiré de boost.python ou encore de luabind, sauf qu'il est plus abstrait et peut ensuite être exploité pour n'importe quelle utilisation, pas seulement dans un cadre particulier (un langage de script pour les exemples cités).

CAMP est distribué sous licence LGPL v3.

Un petit exemple d'utilisation sera plus parlant qu'un long discours :
Code : Sélectionner tout
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
 #include <camp/camptype.hpp>
 #include <camp/class.hpp>
 #include <string>
 #include <iostream>
 
 // Let's define a class for handling persons
 class Person
 {
 public:
 
     // Construct a person from its name
     Person(const std::string& name) : m_name(name), m_age(0)
     {
     }
 
     // Retrieve the name of a person
     std::string name() const
     {
         return m_name;
     }
 
     // Retrieve the age of a person
     unsigned int age() const
     {
         return m_age;
     }
 
     // Set the age of a person
     void setAge(unsigned int age)
    {
         m_age = age;
     }
 
     // Make a person speak (tell about its name and age)
     void speak()
     {
         std::cout << "Hi! My name is " << m_name << " and I'm " << m_age << " years old." << std::endl;
     }
 
 private:
 
     std::string m_name;
     unsigned int m_age;
 };
 
 // Make the Person type available to CAMP
 CAMP_TYPE(Person);
 
 
 int main()
 {
     // Bind our Person class to CAMP
     camp::Class::declare<Person>("Person")
         .constructor1<std::string>()
         .property("name", &Person::name)
         .property("age", &Person::age, &Person::setAge)
         .function("speak", &Person::speak);
 
     // Retrieve it by its name
     const camp::Class& metaclass = camp::classByName("Person");
 
     // Construct a new person named John
     Person* john = metaclass.construct<Person>(camp::Args("John"));
 
     // Print its name
     std::string name = metaclass.property("name").get(john);
     std::cout << "John's name is: " << name << std::endl;
 
     // Set its age to 24
     metaclass.property("age").set(john, 24);
 
     // Make John say something
     metaclass.function("speak").call(john);
 
     // Kill John
     metaclass.destroy(john);
 
     return 0;
 }

Une erreur dans cette actualité ? Signalez-le nous !

Avatar de Laurent Gomila
Rédacteur https://www.developpez.com
Le 14/06/2010 à 15:22
Ca a pris un peu plus de temps que prévu, mais nous avons enfin un site fonctionnel et complet pour le projet :

http://dev.tegesoft.com/projects/camp

Le site (basé sur redmine) est assez complet : il y a un wiki avec des tutoriels, une roadmap, un système de tickets pour rapporter des bugs/fonctionnalités, un dépôt contenant les fichiers de toutes les versions.

Nous en avons également profité pour publier officiellement la version 0.7.0 sous licence LGPL. Nous travaillons d'ores et déjà activement sur la prochaine release.

N'hésitez pas à venir vous enregistrer pour donner votre avis

Maintenant que tout est prêt pour la communauté, j'espère vraiment que cette bibliothèque pourra servir à pas mal de monde et évoluer.
1  0 
Avatar de Goten
Membre chevronné https://www.developpez.com
Le 18/06/2010 à 12:16
Ou comment faire du java en C++.. autant lancé netbeans / eclipse et faire du java ..
1  0 
Avatar de
https://www.developpez.com
Le 02/09/2009 à 18:09
ca ressemble un peu a ce que je fais
Code : Sélectionner tout
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
class RTTIEXPORT Test : public BugEngine::Object
{
private:
    int m_value;
    refptr<Test> m_other;
public:
    Test();
    ~Test();

    u8& prop() const;
    void setProp(u8 value);
    void setValue(int v);
    void setValue2(const int& v);

    void test(const std::string& str) const;

    be_metaclass(RTTIEXPORT,Test,BugEngine::Object)
        void doStuff(const std::string& arg);
    be_properties
        be_property(Value)
            [be_read(m_value)]
            [be_write(m_value)];

        be_property(Value2)
            [be_read(m_value)]
            [be_set(setValue)];

        be_property(prop)
            [be_get(prop)]
            [be_set(setProp)];

        be_method(test);
        be_classmethod(doStuff);
    be_end
};
j'ai juste été embeté par le RTTIEXPORT qui est le classique declspec(dllimport)/dllexport. j'ai été obligé de le coller dans ma macro et ca c'est moche.
0  0 
Avatar de Alp
Expert éminent sénior https://www.developpez.com
Le 02/09/2009 à 18:24
@screetch : ce que je trouve super avec CAMP, c'est que l'on a rien à faire depuis la classe elle-même. On pourrait faire, si l'on voulait, l'introspection de la SL avec

Certes on doit déclarer à l'engine les attributs/fonctions qu'on veut "introspecter", mais ça peut se faire à l'extérieur. C'est possible aussi avec ton code d'introspection ?
0  0 
Avatar de Davidbrcz
Rédacteur https://www.developpez.com
Le 02/09/2009 à 20:52
C'est du très beau travail. Plus le temps passe et plus je me dis que le C++ a de moins de chose à envier à Java du coté introspection/choses dynamiques.

Mais il me reste une question (de noob): en pratique, a quoi ca peut servir ?(l'introspection en général).

Merci.
0  0 
Avatar de ram-0000
Rédacteur https://www.developpez.com
Le 02/09/2009 à 20:57
Citation Envoyé par Davidbrcz Voir le message
Mais il me reste une question (de noob): en pratique, a quoi ca peut servir ?(l'introspection en général).
J'avoue que je me le demande aussi.

Si quelqu'un avait une explication simple avec un exemple concret à proposer, je lui en serait éternellement reconnaissant.
0  0 
Avatar de Alp
Expert éminent sénior https://www.developpez.com
Le 02/09/2009 à 20:59
L'autre bibliothèque de Tegesoft, GICS, utilise CAMP.
Cf :
Dependencies Qt >= 4.5.0
CAMP >= 0.6.0
http://www.tegesoft.com/products/gics
0  0 
Avatar de CedricMocquillon
Membre averti https://www.developpez.com
Le 02/09/2009 à 21:13
Perso je m'étais servis de l'introspection (en java) dans un de mes cours sur le calcul réparti:

Un client demande un objet à un serveur, cet objet est crée coté serveur et une "interface" est envoyée au client. Le client peut alors appeler les méthodes de l'interface qui se charge de transférer au serveur la classe, la méthode et les paramètres. Le serveur récupère le tout et utilise l'introspection pour invoquer la méthode sur l'objet.

Au final ça permet de réaliser les calculs côté serveur avec l'impression pour le client que tout se passe en local (la syntaxe notamment est la même).

L'idée était de leur faire redévelopper une architecture de type CORBA, JNI ou encore DCOM.
0  0 
Avatar de JolyLoic
Rédacteur/Modérateur https://www.developpez.com
Le 02/09/2009 à 21:20
Parmi les applications classiques :
- La sérialisation automatique ou semi-automatique des données (pour sauvegarde ou application répartie)
- L'écriture simplifiée et haut niveau d'outils autour de langage (par exemple générer automatiquement une boîte de propriétés pour un composant graphique dans un éditeur de boîtes de dialogue, la génération de wrapper pour interfacer le code avec un autre langage...)
0  0 
Avatar de Aurelien.Regat-Barrel
Expert éminent sénior https://www.developpez.com
Le 03/09/2009 à 0:42
Citation Envoyé par Alp Voir le message
L'autre bibliothèque de Tegesoft, GICS, utilise CAMP.
Cf :
Dependencies Qt >= 4.5.0
CAMP >= 0.6.0
http://www.tegesoft.com/products/gics
Ce que je me demande perso, c'est qu'est-ce qu'apporte CAMP par rapport à Qt qui propose déjà quelque chose d'assez évolué (surtout s'il y a la dépendance à Qt) ?

Au niveaux des utilités du truc, ça peut être très utile pour s'interfacer avec un interpréteur de script et rendre facilement ses objets C++ utilisables depuis un langage de script. C'est d'ailleurs ce que permet de faire Qt avec QtScript. Ca économise le processus de wrapping avec SWIG par exemple.
0  0