Changeset 14887 for lang/cplusplus/reflection

Timestamp:

06/30/08 07:41:07 (5 years ago)

Author:

kazuho

Message:

change API signatures

Location:

lang/cplusplus/reflection/trunk

Files:

• reflection.hpp (modified) (4 diffs)
• test.cpp (modified) (2 diffs)

lang/cplusplus/reflection/trunk/reflection.hpp

@@ -3 +3 @@
 
 #include <map>
+#include <stdexcept>
 #include <string>
 #include <typeinfo>
@@ -12 +13 @@
     virtual ~member() {}
     virtual char T::*ptr() const = 0;
-    virtual void set(T *, const void *, const std::type_info &) const = 0;
+    virtual void set(T &, const void *, const std::type_info &) const = 0;
     template <typename Vt> Vt T::*ptr(Vt*) const {
       return reinterpret_cast<Vt T::*>(ptr());
     }
-    template <typename Vt> Vt get(T *obj) const {
-      return mem_rebuild<Vt>(&(obj->*ptr()), this);
+    template <typename Vt> Vt get(const T &obj) const {
+      return mem_rebuild<Vt>(&(obj.*ptr()), this);
     }
-    template <typename Vt> void set(T *obj, const Vt &v) const {
+    template <typename Vt> void set(T &obj, const Vt &v) const {
       set(obj, &v, typeid(Vt));
     }
@@ -33 +34 @@
       return reinterpret_cast<char T::*>(p);
     }
-    virtual void set(T * obj, const void *s, const std::type_info &t) const {
-      obj->*p = mem_rebuild<Vt>(s, t);
+    virtual void set(T &obj, const void *s, const std::type_info &t) const {
+      obj.*p = mem_rebuild<Vt>(s, t);
     }
   };
   
-  template <class T, class C = typename T::reflection_definition> struct base
+  template <class T> struct def {
+    /*
+     * Specialize this template deriving from def_base to define a reflection
+     * table.  For example:
+     *
+     * struct def<std::pair<int, int> > : def_base<std::pair<int, int> > {
+     *   def() {
+     *     REFLECTION(first);
+     *     REFLECTION(second);
+     *   }
+     * };
+     */
+  private:
+    def(); // intentionally made private to require specialization
+  };
+  
+  template <class T> struct def_base
     : public std::map<std::string, member<T>*> {
     typedef T Klass;
-    static C map;
+    static def<T> map;
     template <typename Vt>
     void register_(const std::string &name, Vt T::*p) {
@@ -48 +65 @@
   };
   
-  template <class T, class C> C base<T, C>::map;
-
-  template <class T, typename Vt>
-  bool get(const T& obj, const std::string &n, Vt* v) {
-    typename T::reflection_definition::const_iterator i
-      = T::reflection_definition::map.find(n);
-    if (i == T::reflection_definition::map.end()
-        || ! i->second->type_is(typeid(*v)))
-      return false;
-    *v = obj.*i->second->ptr((Vt*)NULL);
-    return true;
+  template <class T> def<T> def_base<T>::map;
+  
+  struct member_not_found_error : public std::domain_error {
+    std::string _name;
+    member_not_found_error(const std::string& n)
+      : std::domain_error("member not found"), _name(n) {}
+    ~member_not_found_error() throw() {}
+    std::string name() const {
+      return _name;
+    }
+  };
+  
+  template <typename Vt, class T>
+  Vt get(const T &obj, const std::string &n) {
+    typename def<T>::const_iterator i = def<T>::map.find(n);
+    if (i == def<T>::map.end())
+      throw member_not_found_error(n);
+    return i->second->get<Vt>(obj);
   }
   
   template <class T, typename Vt>
-  bool set(T& obj, const std::string &n, const Vt& v) {
-    typename T::reflection_definition::const_iterator i =
-      T::reflection_definition::map.find(n);
-    if (i == T::reflection_definition::map.end()
-        || ! i->second->type_is(typeid(v)))
-      return false;
-    obj.*i->second->ptr((Vt*)NULL) = v;
-    return true;
+  void set(T &obj, const std::string &n, const Vt &v) {
+    typename def<T>::const_iterator i = def<T>::map.find(n);
+    if (i == def<T>::map.end())
+      throw member_not_found_error(n);
+    i->second->set(obj, v);
   }
   

lang/cplusplus/reflection/trunk/test.cpp

@@ -8 +8 @@
   int i;
   string s;
-  Foo() : i(), s() {}
-  
-  struct reflection_definition : public reflection::base<Foo> {
-    reflection_definition() {
+};
+
+namespace reflection {
+  template <> struct def<Foo> : public def_base<Foo> {
+    def() {
       REFLECTION(i);
       REFLECTION(s);
@@ -24 +25 @@
   f.i = 3;
   int i = 0;
-  i = Foo::reflection_definition::map["i"]->get<int>(&f);
-  Foo::reflection_definition::map["i"]->set(&f, lexical_cast<string>(i + 1));
-  Foo::reflection_definition::map["s"]->set(&f, string("hello world!"));
+  i = reflection::get<int>(f, "i");
+  reflection::set(f, "i", lexical_cast<string>(i + 1));
+  reflection::set(f, "s", string("hello world!"));
   
-  for (Foo::reflection_definition::const_iterator i
-         = Foo::reflection_definition::map.begin();
-       i != Foo::reflection_definition::map.end();
+  for (reflection::def<Foo>::const_iterator i
+         = reflection::def<Foo>::map.begin();
+       i != reflection::def<Foo>::map.end();
        ++i)
-    cout << i->first << " = " << i->second->get<std::string>(&f) << endl;
+    cout << i->first << " = " << i->second->get<std::string>(f) << endl;
   
   return 0;