Changeset 91

Timestamp:

02/01/07 18:56:35 (5 years ago)

Author:

KirkMcDonald

Message:

Improved inheritance support. Fixed ctor-related bug.

Files:

• trunk/examples/inherit/inherit.d (modified) (6 diffs)
• trunk/examples/inherit/test.py (modified) (3 diffs)
• trunk/html_doc/class_wrapping.html (modified) (1 diff)
• trunk/html_doc/inherit.html (modified) (1 diff)
• trunk/infrastructure/pyd/class_wrap.d (modified) (6 diffs)
• trunk/raw_html/class_wrapping.html (modified) (1 diff)
• trunk/raw_html/inherit.html (modified) (1 diff)

trunk/examples/inherit/inherit.d

@@ -5 +5 @@
-
-class Base {
+    this(int i) { writefln("Base.this(): ", i); }
-    void foo() {
-        writefln("Base.foo");
@@ -14 +15 @@
-
-class Derived : Base {
+    this(int i) { super(i); writefln("Derived.this(): ", i); }
-    void foo() {
-        writefln("Derived.foo");
@@ -19 +21 @@
-}
-
-WrapDerive : Derived
+BaseWrap : Base
-    mixin OverloadShim;
+    this(int i) { super(i); }
+    void foo() {
+        get_overload(&super.foo, "foo");
+    }
+    void bar() {
+        get_overload(&super.bar, "bar");
+    }
+}
+
+class DeriveWrap : Derived {
+    mixin OverloadShim;
+    this(int i) { super(i); }
-    void foo() {
-        get_overload(&super.foo, "foo");
@@ -34 +48 @@
-
-Base return_poly_base() {
-
+(1)
-    return b1;
-}
-
-Base return_poly_derived() {
-
+(2)
-    return b2;
-}
-
-Base return_poly_wrap() {
-WrapDerive
+DeriveWrap(3)
-    return b3;
-}
@@ -57 +71 @@
-
-    wrapped_class!(Base) b;
+    b.hide();
-    b.def!(Base.foo);
-    b.def!(Base.bar);
@@ -62 +77 @@
-
-    wrapped_class!(Derived) d;
+    d.hide();
-    d.def!(Derived.foo);
-    finalize_class(d);
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-}
+

trunk/examples/inherit/test.py

@@ -12 +12 @@
-import inherit
-
-
-
+1
+2
-
-b.foo()
@@ -26 +26 @@
-inherit.call_poly(d)
-
-
-
+#
+#
-
-WrapDerive
+Derived
-    def foo(self):
-        print 'PyClass.foo'
-
-
+3
-#print "The basic inheritance support breaks down here:"
-inherit.call_poly(p)
@@ -41 +41 @@
-b1 = inherit.return_poly_base()
-print "inherit.return_poly_base returned instance of Base"
-
+
+
+
-b2 = inherit.return_poly_derived()
-b2a = inherit.return_poly_derived()
-print "inherit.return_poly_derived returned instance of Derived"
-
+#
-print "inherit.return_poly_derived returned the same object twice"
-assert b2 is b2a
-b3 = inherit.return_poly_wrap()
-WrapDerive
-WrapDerive
+DeriveWrap
+Derived
-
-print

trunk/html_doc/class_wrapping.html

@@ -58 +58 @@
-<dt><code>static void init(<span class="t_arg">C</span> ...) ();</code></dt>
-<dd>This allows you to expose the class's constructors to Python. If the class provides a zero-argument constructor, there is no need to specify it; it is always available. Each element of <span class="t_arg">C</span> should be a function type. Each function type should correspond to a constructor. (That is, the arguments to the function should be the same as arguments to the class constructor. The return type is ignored.) There is an additional limitation at this time: No two constructors may have the same number of arguments. Pyd will always attempt to call the first constructor with the right number of arguments. If you wish to support a constructor with default arguments, you must specify each possible constructor call as a different template argument to this function. The examples show a few uses of the <code>init</code> function.</dd>
+
+<dt><code>static void parent(<span class="t_arg">Parent</span>) ();</code></dt>
+<dd>This allows the user to manually specify a class as this class's parent. This is intended for a very specific purpose (related to how Pyd handles <a href="inherit.html">inheritance</a>), and should not be used heedlessly. If a class's parent was previously wrapped, then Pyd will detect this and set up a parent-child relationship automatically, in which case it is not neccessary to specify this.</dd>
+
+<dt><code>static void hide();</code></dt>
+<dd>Causes this class to be wrapped, but not actually directly exposed to Python. This can be useful if you want to return instances of a class without allowing Python code to instantiate them. This is mainly used when handling <a href="inherit.html">inheritance</a>.</dd>
-
-<dt><code>static void iter(<span class="t_arg">iter_t</span>) ();</code></dt>

trunk/html_doc/inherit.html

@@ -122 +122 @@
-PyClass.foo</pre>
-
+<p>However, BaseWrap has no particular relationship to Derived. You may remember that Derived overloads <tt>bar</tt> but not <tt>foo</tt>. When we wrapped Derived in <tt>PydMain</tt>, we specified the <tt>foo</tt> overload but not the <tt>bar</tt> overload. Because Derived's parent class is no longer wrapped, Pyd no longer has any way to know about the <tt>bar</tt> method of the Derived class.</tt></p>
+
+<p>The solution is to explicitly tell Pyd that Derived's parent is BaseWrap. Furthermore, it is probably best to go the extra mile, by wrapping an <tt>OverloadShim</tt> subclass of Derived (call it DerivedWrap), and telling Pyd that BaseWrap is <em>its</em> parent. Additionally, the original <tt>Base</tt> and <tt>Derived</tt> classes should still be wrapped, in the event that functions return instances of them to Python, but should not actually be exposed to Python. The complete solution ends up looking like this:</p>
+
+<pre class="code"><span class="keyword">import</span> pyd.pyd;
+<span class="keyword">import</span> std.stdio;
+
+<span class="keyword">class</span> Base {
+    <span class="keyword">void</span> foo() { writefln(<span class="string">"Base.foo"</span>); }
+    <span class="keyword">void</span> bar() { writefln(<span class="string">"Base.bar"</span>); }
+}
+
+<span class="keyword">class</span> Derived : Base {
+    <span class="keyword">void</span> foo() { writefln(<span class="string">"Derived.foo"</span>); }
+}
+
+<span class="keyword">class</span> BaseWrap : Base {
+    <span class="keyword">mixin</span> OverloadShim;
+    <span class="keyword">void</span> foo() {
+        get_overload(&amp;<span class="keyword">super</span>.foo, <span class="string">"foo"</span>);
+    }
+    <span class="keyword">void</span> bar() {
+        get_overload(&amp;<span class="keyword">super</span>.bar, <span class="string">"bar"</span>);
+    }
+}
+
+<span class="keyword">class</span> DerivedWrap : Derived {
+    <span class="keyword">mixin</span> OverloadShim;
+    <span class="keyword">void</span> foo() {
+        get_overload(&amp;<span class="keyword">super</span>.foo, <span class="string">"foo"</span>);
+    }
+}
+
+<span class="keyword">extern</span> (C) <span class="keyword">void</span> PydMain() {
+    module_init();
+
+    wrapped_class!(Base) b;
+    w.hide();
+    w.def!(Base.foo);
+    w.def!(Base.bar);
+    finalize_class(w);
+
+    wrapped_class!(Derived) d;
+    d.hide();
+    d.def!(Derived.foo);
+    finalize_class(d);
+
+    wrapped_class!(BaseWrap, <span class="string">"Base"</span>) bw;
+    bw.def!(BaseWrap.foo);
+    bw.def!(BaseWrap.bar);
+    finalize_class(bw);
+
+    wrapped_class!(DerivedWrap, <span class="string">"Derived"</span>) dw;
+    dw.parent!(BaseWrap);
+    dw.def!(DerivedWrap.foo);
+    finalize_class(dw);
+}</pre>
+
+<p><i>(I recognize that this is astoundingly ugly. However, it is the best solution I can come up with without resorting to code generation.)</i></p>
+
+<p>The <a href="http://dsource.org/projects/pyd/browser/trunk/examples/inherit/inherit.d"><tt>inherit</tt> example</a> in the Pyd distribution provides a more complete version of this example, including how wrapper code should handle constructors.</p>
+
+<p><i>(TODO: Add support for interfaces and abstract classes.)</i></p>
+
-</div>
-

trunk/infrastructure/pyd/class_wrap.d

@@ -86 +86 @@
-        null,                         /*tp_setattro*/
-        null,                         /*tp_as_buffer*/
-
+                           
-        null,                         /*tp_doc*/
-        null,                         /*tp_traverse*/
@@ -250 +250 @@
-    static if (is(T == class)) pragma(msg, "wrapped_class: " ~ classname);
-    static const char[] _name = classname;
+    static bool _private = false;
-    alias T wrapped_type;
-    /**
@@ -333 +334 @@
-    }
-
+    static void parent(Parent) () {
+        wrapped_class_type!(T).tp_base = &wrapped_class_type!(Parent);
+    }
+
+    static void hide() {
+        _private = true;
+    }
+
-    // Iteration wrapping support requires StackThreads
-    version(Pyd_with_StackThreads) {
@@ -394 +403 @@
-    type.tp_name      = (module_name ~ "." ~ name ~ \0).ptr;
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-                }
-            }
@@ -437 +448 @@
-    }
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-        }
-    }
-    if (PyType_Ready(&type) < 0) {
-        // XXX: This will probably crash the interpreter, as it isn't normally
-        // caught and translated.
-        throw new Exception("Couldn't ready wrapped type!");
-    }
-    Py_INCREF(cast(PyObject*)&type);
-
+
+
+
-    is_wrapped!(T) = true;
-    static if (is(T == class)) {
@@ -460 +477 @@
-template OverloadShim() {
-    std.traits.ReturnType!(dg_t) get_overload(dg_t, T ...) (dg_t dg, char[] name, T t) {
-
-
+
+
+
-            // If this object's type is not the wrapped class's type (that is,
-            // if this object is actually a Python subclass of the wrapped
-            // class), then call the Python object.
-
+*
-            if (method is null) handle_exception();
-            dg_t pydg = PydCallable_AsDelegate!(dg_t)(method);

trunk/raw_html/class_wrapping.html

@@ -42 +42 @@
-<dt><code>static void init(<span class="t_arg">C</span> ...) ();</code></dt>
-<dd>This allows you to expose the class's constructors to Python. If the class provides a zero-argument constructor, there is no need to specify it; it is always available. Each element of <span class="t_arg">C</span> should be a function type. Each function type should correspond to a constructor. (That is, the arguments to the function should be the same as arguments to the class constructor. The return type is ignored.) There is an additional limitation at this time: No two constructors may have the same number of arguments. Pyd will always attempt to call the first constructor with the right number of arguments. If you wish to support a constructor with default arguments, you must specify each possible constructor call as a different template argument to this function. The examples show a few uses of the <code>init</code> function.</dd>
+
+<dt><code>static void parent(<span class="t_arg">Parent</span>) ();</code></dt>
+<dd>This allows the user to manually specify a class as this class's parent. This is intended for a very specific purpose (related to how Pyd handles <a href="inherit.html">inheritance</a>), and should not be used heedlessly. If a class's parent was previously wrapped, then Pyd will detect this and set up a parent-child relationship automatically, in which case it is not neccessary to specify this.</dd>
+
+<dt><code>static void hide();</code></dt>
+<dd>Causes this class to be wrapped, but not actually directly exposed to Python. This can be useful if you want to return instances of a class without allowing Python code to instantiate them. This is mainly used when handling <a href="inherit.html">inheritance</a>.</dd>
-
-<dt><code>static void iter(<span class="t_arg">iter_t</span>) ();</code></dt>

trunk/raw_html/inherit.html

@@ -106 +106 @@
-PyClass.foo</pre>
-
+<p>However, BaseWrap has no particular relationship to Derived. You may remember that Derived overloads <tt>bar</tt> but not <tt>foo</tt>. When we wrapped Derived in <tt>PydMain</tt>, we specified the <tt>foo</tt> overload but not the <tt>bar</tt> overload. Because Derived's parent class is no longer wrapped, Pyd no longer has any way to know about the <tt>bar</tt> method of the Derived class.</tt></p>
+
+<p>The solution is to explicitly tell Pyd that Derived's parent is BaseWrap. Furthermore, it is probably best to go the extra mile, by wrapping an <tt>OverloadShim</tt> subclass of Derived (call it DerivedWrap), and telling Pyd that BaseWrap is <em>its</em> parent. Additionally, the original <tt>Base</tt> and <tt>Derived</tt> classes should still be wrapped, in the event that functions return instances of them to Python, but should not actually be exposed to Python. The complete solution ends up looking like this:</p>
+
+<pre class="code"><span class="keyword">import</span> pyd.pyd;
+<span class="keyword">import</span> std.stdio;
+
+<span class="keyword">class</span> Base {
+    <span class="keyword">void</span> foo() { writefln(<span class="string">"Base.foo"</span>); }
+    <span class="keyword">void</span> bar() { writefln(<span class="string">"Base.bar"</span>); }
+}
+
+<span class="keyword">class</span> Derived : Base {
+    <span class="keyword">void</span> foo() { writefln(<span class="string">"Derived.foo"</span>); }
+}
+
+<span class="keyword">class</span> BaseWrap : Base {
+    <span class="keyword">mixin</span> OverloadShim;
+    <span class="keyword">void</span> foo() {
+        get_overload(&amp;<span class="keyword">super</span>.foo, <span class="string">"foo"</span>);
+    }
+    <span class="keyword">void</span> bar() {
+        get_overload(&amp;<span class="keyword">super</span>.bar, <span class="string">"bar"</span>);
+    }
+}
+
+<span class="keyword">class</span> DerivedWrap : Derived {
+    <span class="keyword">mixin</span> OverloadShim;
+    <span class="keyword">void</span> foo() {
+        get_overload(&amp;<span class="keyword">super</span>.foo, <span class="string">"foo"</span>);
+    }
+}
+
+<span class="keyword">extern</span> (C) <span class="keyword">void</span> PydMain() {
+    module_init();
+
+    wrapped_class!(Base) b;
+    w.hide();
+    w.def!(Base.foo);
+    w.def!(Base.bar);
+    finalize_class(w);
+
+    wrapped_class!(Derived) d;
+    d.hide();
+    d.def!(Derived.foo);
+    finalize_class(d);
+
+    wrapped_class!(BaseWrap, <span class="string">"Base"</span>) bw;
+    bw.def!(BaseWrap.foo);
+    bw.def!(BaseWrap.bar);
+    finalize_class(bw);
+
+    wrapped_class!(DerivedWrap, <span class="string">"Derived"</span>) dw;
+    dw.parent!(BaseWrap);
+    dw.def!(DerivedWrap.foo);
+    finalize_class(dw);
+}</pre>
+
+<p><i>(I recognize that this is astoundingly ugly. However, it is the best solution I can come up with without resorting to code generation.)</i></p>
+
+<p>The <a href="http://dsource.org/projects/pyd/browser/trunk/examples/inherit/inherit.d"><tt>inherit</tt> example</a> in the Pyd distribution provides a more complete version of this example, including how wrapper code should handle constructors.</p>
+
+<p><i>(TODO: Add support for interfaces and abstract classes.)</i></p>
+
-</div>
-