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 - 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
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;
 }