Automatic downcasting of function return values (first cut -- multiple inheritance still not supported).

2 files changed, 146 insertions, 1 deletions

diff --git a/src/embind/embind.js b/src/embind/embind.js
index 504db37c..b50c7aca 100755
--- a/src/embind/embind.js
+++ b/src/embind/embind.js
@@ -493,15 +493,21 @@ function __embind_register_vector(
     });
 }
 
+// hang onto your hats, guys, we're going to try to make this one registration work for the class and all its
+// derived classes
 function __embind_register_class(
     classType,
     pointerType,
     constPointerType,
     name,
+    getDynamicPointerType,
     destructor
 ) {
     name = Pointer_stringify(name);
     destructor = FUNCTION_TABLE[destructor];
+    if (getDynamicPointerType) {
+        getDynamicPointerType = FUNCTION_TABLE[getDynamicPointerType];
+    }
     
     var Handle = createNamedFunction(name, function(ptr) {
         var h = function() {
@@ -562,6 +568,7 @@ function __embind_register_class(
 
     registerType(classType, name, {
         name: name,
+        pointerType: pointerType,
         constructor: constructor,
         Handle: Handle,
         fromWireType: function(ptr) {
@@ -576,6 +583,19 @@ function __embind_register_class(
     registerType(pointerType, pointerName, {
         name: pointerName,
         fromWireType: function(ptr) {
+            var dynamicType = getDynamicPointerType && getDynamicPointerType(ptr);
+            if (dynamicType === null || dynamicType === pointerType) {
+                return new Handle(ptr);
+            }
+            try {
+                dynamicType = requireRegisteredType(dynamicType);
+            } catch (err) {
+                return new Handle(ptr); // I suppose we could work our way up the inheritance tree...
+            }
+            dynamicType = requireRegisteredType(dynamicType.pointerType);
+            return dynamicType.fromWireTypeStatic(ptr);
+        },
+        fromWireTypeStatic: function(ptr) {
             return new Handle(ptr);
         },
         toWireType: function(destructors, o) {
@@ -586,6 +606,19 @@ function __embind_register_class(
     var constPointerName = name + ' const*';
     registerType(constPointerType, constPointerName, {
         name: constPointerName,
+        fromWireType: function(ptr) {
+            var dynamicType = getDynamicPointerType && getDynamicPointerType(ptr);
+            if (dynamicType === null || dynamicType === pointerType) {
+                return new Handle(ptr);
+            }
+            try {
+                dynamicType = requireRegisteredType(dynamicType);
+            } catch (err) {
+                return new Handle(ptr); // I suppose we could work our way up the inheritance tree...
+            }
+            dynamicType = requireRegisteredType(dynamicType.pointerType);
+            return dynamicType.fromWireType(ptr);
+        },
         toWireType: function(destructors, o) {
             return o.ptr;
         }
@@ -594,6 +627,112 @@ function __embind_register_class(
     exposePublicSymbol(name, constructor);
 }
 
+//function __embind_register_class(
+//    classType,
+//    pointerType,
+//    constPointerType,
+//    name,
+//    destructor
+//) {
+//    name = Pointer_stringify(name);
+//    destructor = FUNCTION_TABLE[destructor];
+//
+//    var Handle = createNamedFunction(name, function(ptr) {
+//        var h = function() {
+//            if(h.operator_call !== undefined) {
+//                return h.operator_call.apply(h, arguments);
+//            } else {
+//                throw new BindingError(name + ' does not define call operator');
+//            }
+//        };
+//
+//        h.count = {value: 1};
+//        h.ptr = ptr;
+//
+//        for(var prop in Handle.prototype) {
+//            var dp = Object.getOwnPropertyDescriptor(Handle.prototype, prop);
+//            Object.defineProperty(h, prop, dp);
+//        }
+//
+//        return h;
+//    });
+//
+//    Handle.prototype.clone = function() {
+//        if (!this.ptr) {
+//            throw new BindingError(classType.name + ' instance already deleted');
+//        }
+//
+//        var clone = Object.create(Handle.prototype);
+//        clone.count = this.count;
+//        clone.ptr = this.ptr;
+//
+//        clone.count.value += 1;
+//        return clone;
+//    };
+//
+//    Handle.prototype.move = function() {
+//        var rv = this.clone();
+//        this.delete();
+//        return rv;
+//    };
+//
+//    Handle.prototype['delete'] = function() {
+//        if (!this.ptr) {
+//            throw new BindingError(classType.name + ' instance already deleted');
+//        }
+//
+//        this.count.value -= 1;
+//        if (0 === this.count.value) {
+//            destructor(this.ptr);
+//        }
+//        this.ptr = undefined;
+//    };
+//
+//    var constructor = createNamedFunction(name, function() {
+//        var body = constructor.body;
+//        return body.apply(this, arguments);
+//    });
+//    constructor.prototype = Handle.prototype;
+//
+//    registerType(classType, name, {
+//        name: name,
+//        constructor: constructor,
+//        Handle: Handle,
+//        fromWireType: function(ptr) {
+//            return new Handle(ptr);
+//        },
+//        toWireType: function(destructors, o) {
+//            return o.ptr;
+//        }
+//    });
+//
+//    var pointerName = name + '*';
+//    registerType(pointerType, pointerName, {
+//        name: pointerName,
+//        fromWireType: function(ptr) {
+//            // based on the fully downcast type of the pointer,
+//
+//            return new Handle(ptr); // if me
+//        },
+//        toWireType: function(destructors, o) {
+//            return o.ptr;
+//        }
+//    });
+//
+//    var constPointerName = name + ' const*';
+//    registerType(constPointerType, constPointerName, {
+//        name: constPointerName,
+//        fromWireType: function(ptr) {
+//            return new Handle(ptr);
+//        },
+//        toWireType: function(destructors, o) {
+//            return o.ptr;
+//        }
+//    });
+//
+//    exposePublicSymbol(name, constructor);
+//}
+//
 function __embind_register_class_constructor(
     classType,
     argCount,
diff --git a/system/include/emscripten/bind.h b/system/include/emscripten/bind.h
index 08118259..3dc6b5e7 100755
--- a/system/include/emscripten/bind.h
+++ b/system/include/emscripten/bind.h
@@ -114,6 +114,7 @@ namespace emscripten {
                 TYPEID pointerType,
                 TYPEID constPointerType,
                 const char* className,
+                GenericFunction getDynamicTypeInfo,
                 GenericFunction destructor);
 
             void _embind_register_class_constructor(
@@ -265,12 +266,16 @@ namespace emscripten {
     // FUNCTIONS
     ////////////////////////////////////////////////////////////////////////////////
 
-
     template<typename FromType, typename ToType>
     ToType& performCast(FromType& from) {
         return *dynamic_cast<ToType*>(&from);
     };
 
+    template<typename PointerType>
+    internal::TYPEID getDynamicPointerType(PointerType *p) {
+        return reinterpret_cast<internal::TYPEID>(&typeid(*p));
+    };
+
     template<typename FromRawType, typename ToRawType>
     std::shared_ptr<ToRawType> performPointerCast(std::shared_ptr<FromRawType> from) {
         return std::shared_ptr<ToRawType>(from, dynamic_cast<ToRawType*>(from.get()));
@@ -653,6 +658,7 @@ namespace emscripten {
                 TypeID<AllowedRawPointer<ClassType>>::get(),
                 TypeID<AllowedRawPointer<const ClassType>>::get(),
                 name,
+                reinterpret_cast<GenericFunction>(&getDynamicPointerType<ClassType>),
                 reinterpret_cast<GenericFunction>(&raw_destructor<ClassType>));
         }