Changeset 68

Timestamp:

12/19/06 18:07:17 (2 years ago)

Author:

KirkMcDonald

Message:

Polymorphism-related improvements.

Files:

• trunk/examples/inherit/inherit.d (modified) (1 diff)
• trunk/examples/inherit/test.py (modified) (1 diff)
• trunk/infrastructure/pyd/class_wrap.d (modified) (6 diffs)
• trunk/infrastructure/pyd/func_wrap.d (modified) (1 diff)
• trunk/infrastructure/pyd/iteration.d (modified) (1 diff)
• trunk/infrastructure/pyd/make_object.d (modified) (1 diff)

trunk/examples/inherit/inherit.d

@@ -31 +31 @@
-}
-
+Base b1, b2, b3;
+
+Base return_poly_base() {
+    if (b1 is null) b1 = new Base;
+    return b1;
+}
+
+Base return_poly_derived() {
+    if (b2 is null) b2 = new Derived;
+    return b2;
+}
+
+Base return_poly_wrap() {
+    if (b3 is null) b3 = new WrapDerive;
+    return b3;
+}
+
-extern(C) void PydMain() {
-    def!(call_poly);
+    def!(return_poly_base);
+    def!(return_poly_derived);
+    def!(return_poly_wrap);
-
-    module_init();

trunk/examples/inherit/test.py

@@ -36 +36 @@
-#print "The basic inheritance support breaks down here:"
-inherit.call_poly(p)
+
+print
+
+b1 = inherit.return_poly_base()
+print "inherit.return_poly_base returned instance of Base"
+assert type(b1) == inherit.Base
+b2 = inherit.return_poly_derived()
+b2a = inherit.return_poly_derived()
+print "inherit.return_poly_derived returned instance of Derived"
+assert type(b2) == inherit.Derived
+print "inherit.return_poly_derived returned the same object twice"
+assert b2 is b2a
+b3 = inherit.return_poly_wrap()
+print "inherit.return_poly_wrap returned instance of WrapDerive"
+assert type(b3) == inherit.WrapDerive
+
+print
+print '-------'
+print 'SUCCESS'
+print '-------'

trunk/infrastructure/pyd/class_wrap.d

@@ -40 +40 @@
-import std.traits;
-
-
+
+
-
-// This is split out in case I ever want to make a subtype of a wrapped class.
@@ -448 +449 @@
-    PyModule_AddObject(Pyd_Module_p(modulename), name.ptr, cast(PyObject*)&type);
-    is_wrapped!(T) = true;
-
+
+
+
-}
-
@@ -475 +478 @@
-///////////////////////
-
-private union aa_reference(T) {
-    T aa;
-    void* ptr;
-}
-
-private void* get_voidptr(T)(T t) {
-    static if (isAA!(T)) {
-        aa_reference!(T) ref;
-        ref.aa = t;
-        return ref.ptr;
-    } else {
-        return cast(void*)t;
-    }
-}
-
-// If the passed D reference has an existing Python object, return a borrowed
-// reference to it. Otherwise, return null.
@@ -522 +510 @@
-}
-
+PyObject* WrapPyObject_FromObject(T) (T t) {
+    return WrapPyObject_FromTypeAndObject(&wrapped_class_type!(T), t);
+}
+
-/**
- * Returns a new Python object of a wrapped type.
- */
-Object(T) (
-
-
+TypeAndObject(T) (PyTypeObject* type, 
+//
+//
-    if (is_wrapped!(T)) {
-        // If this object is already wrapped, get the existing object.
@@ -536 +528 @@
-        }
-        // Otherwise, allocate a new object
-&
+
-        // Set the contained instance
-        WrapPyObject_SetObj(obj, t);
@@ -562 +554 @@
- * Sets the contained object in self to t.
- */
-PY, T) (PY
+T) (PyObject
-    alias wrapped_class_object!(T) obj;
-    obj* self = cast(obj*)_self;

trunk/infrastructure/pyd/func_wrap.d

@@ -52 +52 @@
-        PyType_Ready(&type);
-        is_wrapped!(T) = true;
-
+//
-    }
-}

trunk/infrastructure/pyd/iteration.d

@@ -124 +124 @@
-        PyType_Ready(&type);
-        is_wrapped!(StackContext) = true;
-
+//
-    }
-}

trunk/infrastructure/pyd/make_object.d

@@ -142 +142 @@
-    } else static if (is(T == class)) {
-        // But only if it actually is a wrapped type. :-)
-
-
+
+
+
-        }
-        // If it's not a wrapped type, fall through to the exception.