Changeset 14745

Timestamp:

06/28/08 08:10:39 (5 years ago)

Author:

kazuho

Message:

initial support for automatic type conversion

Location:

lang/cplusplus/reflection/trunk

Files:

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

lang/cplusplus/reflection/trunk/memrebuild.hpp

@@ -7 +7 @@
 namespace mem_rebuild_ns {
   
+  struct type_is_t {
+    virtual ~type_is_t() {}
+    virtual bool type_is(const std::type_info &) const = 0;
+  };
+  
   template <typename T>
   struct builder {
@@ -12 +17 @@
     virtual ~builder() {}
     virtual func_t get(const std::type_info &) const = 0;
+    virtual func_t get(const type_is_t *) const = 0;
     virtual bool equals(const std::type_info &) const = 0;
     virtual bool equals(const builder*) const = 0;
@@ -21 +27 @@
     get(const std::type_info &t) const {
       if (typeid(Source) != t)
+        return NULL;
+      return instantiate;
+    }
+    virtual typename builder<Target>::func_t get(const type_is_t *t) const {
+      if (! t->type_is(typeid(Source)))
         return NULL;
       return instantiate;
@@ -108 +119 @@
 
 #undef MEM_REBUILD_
+
+  template <typename T, typename TI> T core(const void *p, TI t)
+  {
+    typedef mem_rebuild_ns::builder_map<T> map;
+    for (typename map::const_iterator i = map::m.begin();
+         i != map::m.end();
+         ++i) {
+      typename mem_rebuild_ns::builder<T>::func_t instantiate;
+      if ((instantiate = (*i)->get(t)) != NULL)
+        return (*instantiate)(p);
+    }
+    throw std::bad_cast();
+  }
+
 };
 
 template <typename T> T mem_rebuild(const void *p, const std::type_info &t)
 {
-  typedef mem_rebuild_ns::builder_map<T> map;
-  for (typename map::const_iterator i = map::m.begin();
-       i != map::m.end();
-       ++i) {
-    typename mem_rebuild_ns::builder<T>::func_t instantiate;
-    if ((instantiate = (*i)->get(t)) != NULL)
-      return (*instantiate)(p);
-  }
-  throw std::bad_cast();
+  return mem_rebuild_ns::core<T, const std::type_info&>(p, t);
+}
+
+template <typename T> T mem_rebuild(const void *p,
+                                    const mem_rebuild_ns::type_is_t *t)
+{
+  return mem_rebuild_ns::core<T, const mem_rebuild_ns::type_is_t*>(p, t);
 }
 

lang/cplusplus/reflection/trunk/reflection.hpp

@@ -5 +5 @@
 #include <string>
 #include <typeinfo>
+#include "memrebuild.hpp"
 
 namespace reflection {
   
-  struct type_info {
-    virtual ~type_info() {}
-    virtual type_info* clone() const = 0;
-    virtual bool equal(const std::type_info &) const = 0;
-  };
-
-  bool operator==(const type_info* x, const std::type_info &y) {
-    return x->equal(y);
-  }
-  
-  bool operator==(const std::type_info &x, const type_info* y) {
-    return y == x;
-  }
-  
-  bool operator!=(const type_info *x, const std::type_info &y) {
-    return ! (x == y);
-  }
-  
-  bool operator!=(const std::type_info &x, const type_info* y) {
-    return ! (x == y);
-  }
-  
-  template <class T> struct type_info_t : public type_info {
-    virtual type_info_t *clone() const { return new type_info_t<T>(); }
-    virtual bool equal(const std::type_info &x) const { return typeid(T) == x; }
+  template <class T> struct member : public mem_rebuild_ns::type_is_t {
+    virtual ~member() {}
+    virtual char T::*ptr() 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> void set(T *obj, const Vt &v) const {
+      set(obj, &v, typeid(Vt));
+    }
   };
   
-  template <class T> struct member {
-    char T::*_ptr;
-    type_info *type;
-    member(char T::*p, const type_info &t) : _ptr(p), type(t.clone()) {}
-    member(const member<T>& x) : _ptr(x._ptr), type(x.type->clone()) {}
-    ~member() { delete type; }
-    member& operator=(const member<T>& x) {
-      if (this == &x) return *this;
-      _ptr = x._ptr;
-      delete type;
-      type = x.type->clone();
-      return *this;
+  template <class T, typename Vt> struct member_t : public member<T> {
+    Vt T::*p;
+    member_t(Vt T::*_p) : p(_p) {}
+    virtual bool type_is(const std::type_info &x) const {
+      return typeid(Vt) == x;
     }
-    template <typename Vt> Vt T::*ptr(Vt*) const {
-      return reinterpret_cast<Vt T::*>(_ptr);
+    virtual char T::*ptr() const {
+      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);
     }
   };
   
   template <class T, class C = typename T::reflection_definition> struct base
-    : public std::map<std::string, member<T> > {
+    : public std::map<std::string, member<T>*> {
     typedef T Klass;
     static C map;
     template <typename Vt>
     void register_(const std::string &name, Vt T::*p) {
-      insert(std::make_pair(name,
-                            member<T>(reinterpret_cast<char T::*>(p),
-                                      type_info_t<Vt>())));
+      insert(std::pair<std::string, member<T>*>(name, new member_t<T, Vt>(p)));
     }
   };
@@ -72 +55 @@
       = T::reflection_definition::map.find(n);
     if (i == T::reflection_definition::map.end()
-        || typeid(*v) != i->second.type)
+        || ! i->second->type_is(typeid(*v)))
       return false;
-    *v = obj.*i->second.ptr((Vt*)NULL);
+    *v = obj.*i->second->ptr((Vt*)NULL);
     return true;
   }
@@ -82 +65 @@
     typename T::reflection_definition::const_iterator i =
       T::reflection_definition::map.find(n);
-    if (i == T::reflection_definition::map.end() || typeid(v) != i->second.type)
+    if (i == T::reflection_definition::map.end()
+        || ! i->second->type_is(typeid(v)))
       return false;
-    obj.*i->second.ptr((Vt*)NULL) = v;
+    obj.*i->second->ptr((Vt*)NULL) = v;
     return true;
   }

lang/cplusplus/reflection/trunk/test.cpp

@@ -3 +3 @@
 
 using namespace std;
+using namespace boost;
 
 struct Foo {
@@ -23 +24 @@
   f.i = 3;
   int i = 0;
-  reflection::get(f, "i", &i);
-  ++i;
-  reflection::set(f, "i", i);
-  reflection::set(f, "s", string("hello world!"));
+  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!"));
   
   for (Foo::reflection_definition::const_iterator i
          = Foo::reflection_definition::map.begin();
        i != Foo::reflection_definition::map.end();
-       ++i) {
-    cout << i->first << " = ";
-    if (i->second.type == typeid(int)) {
-      cout << f.*i->second.ptr((int*)NULL);
-    } else if (i->second.type == typeid(std::string)) {
-      cout << f.*i->second.ptr((std::string*)NULL);
-    }
-    cout << endl;
-  }
+       ++i)
+    cout << i->first << " = " << i->second->get<std::string>(&f) << endl;
   
-  return f.i;
+  return 0;
 }