Changeset 57

Timestamp:

12/12/06 23:49:57 (5 years ago)

Author:

KirkMcDonald

Message:

Inheritance improvements; bugfixes

Files:

• trunk/examples/inherit/inherit.d (modified) (2 diffs)
• trunk/examples/inherit/test.py (modified) (1 diff)
• trunk/examples/testdll/testdll.d (modified) (2 diffs)
• trunk/html_doc/basics.html (modified) (1 diff)
• trunk/html_doc/celerid.html (modified) (1 diff)
• trunk/html_doc/class_wrapping.html (modified) (2 diffs)
• trunk/html_doc/conversion.html (modified) (1 diff)
• trunk/html_doc/credits.html (modified) (1 diff)
• trunk/html_doc/except_wrapping.html (modified) (1 diff)
• trunk/html_doc/func_wrapping.html (modified) (1 diff)
• trunk/html_doc/index.html (modified) (1 diff)
• trunk/html_doc/install.html (modified) (1 diff)
• trunk/html_doc/pydobject.html (modified) (1 diff)
• trunk/html_doc/struct_wrapping.html (modified) (1 diff)
• trunk/html_doc/vsboost.html (added)
• trunk/infrastructure/pyd/class_wrap.d (modified) (1 diff)
• trunk/infrastructure/pyd/exception.d (modified) (2 diffs)
• trunk/infrastructure/pyd/func_wrap.d (modified) (3 diffs)

trunk/examples/inherit/inherit.d

@@ -19 +19 @@
-}
-
+class WrapDerive : Derived {
+    mixin OverloadShim;
+    void foo() {
+        get_overload(&super.foo, "foo");
+    }
+}
+
-void call_poly(Base b) {
-("call_poly: 
+ln("call_poly:
-    b.foo();
-}
@@ -38 +45 @@
-    d.def!(Derived.foo);
-    finalize_class(d);
+
+    wrapped_class!(WrapDerive) w;
+    w.def!(WrapDerive.foo);
+    finalize_class(w);
-}

trunk/examples/inherit/test.py

@@ -26 +26 @@
-inherit.call_poly(d)
-
-
+
+
+
+
-    def foo(self):
-        print 'PyClass.foo'
-
-p = PyClass()
-
+#
-inherit.call_poly(p)

trunk/examples/testdll/testdll.d

@@ -124 +124 @@
-}
-
+void throws() {
+    throw new Exception("Yay! An exception!");
+}
+
-extern (C)
-export void inittestdll() {
@@ -139 +143 @@
-    def!(func_test);
-    def!(dg_test);
+    def!(throws);
-
-    module_init("testdll");

trunk/html_doc/basics.html

@@ -20 +20 @@
-<a class="nav" href="except_wrapping.html">Exception wrapping</a><br />
-<a class="nav" href="pydobject.html">PydObject</a><br />
+<a class="nav" href="vsboost.html">vs. Boost.Python</a><br />
-<a class="nav" href="credits.html">Credits</a>
-</div>

trunk/html_doc/celerid.html

@@ -20 +20 @@
-<a class="nav" href="except_wrapping.html">Exception wrapping</a><br />
-<a class="nav" href="pydobject.html">PydObject</a><br />
+<a class="nav" href="vsboost.html">vs. Boost.Python</a><br />
-<a class="nav" href="credits.html">Credits</a>
-</div>

trunk/html_doc/class_wrapping.html

@@ -20 +20 @@
-<a class="nav" href="except_wrapping.html">Exception wrapping</a><br />
-<a class="nav" href="pydobject.html">PydObject</a><br />
+<a class="nav" href="vsboost.html">vs. Boost.Python</a><br />
-<a class="nav" href="credits.html">Credits</a>
-</div>
@@ -103 +104 @@
-<dt><code>opIn_r</code></dt> <dd>Python expects the <code>in</code> operator to return a boolean value (it is a containment test). D convention is for <code>in</code> to search for the value in the container, and to return a pointer to the found item, or <code>null</code> if the item is not found. That said, D does not enforce any particular signature on the <code>in</code> overload, while the Python/C API does. Pyd will check the boolean result of a call to <code>opIn_r</code>, and return that value to Python.</dd>
-</dl>
+
+<h3><a class="anchor" name="inheritance">Inheritance</a></h3>
+
+<p>If you wrap both a class and a child of that class, Pyd is smart enough to make the resulting Python classes have a parent-child relationship. Any methods of the parent class will automatically be available to the child class. If the child class overloads any of those methods, it is important that the user wrap them in the module's init function. For example:</p>
+
+<pre class="code"><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>); }
+}</pre>
+
+<p>These would be exposed to Python by putting this code in out init function after the call to <code>module_init</code>:</p>
+
+<pre class="code">wrapped_class!(Base) b;
+b.def!(Base.foo);
+b.def!(Base.bar);
+finalize_class(b);
+
+wrapped_class!(Derived) d;
+d.def!(Derived.foo);
+finalize_class(d);</pre>
+
+<p>When used in Python, we get the expected behavior:</p>
+
+<pre class="code">&gt;&gt;&gt; issubclass(Derived, Base)
+True
+&gt;&gt;&gt; b = Base()
+&gt;&gt;&gt; d = Derived()
+&gt;&gt;&gt; b.foo()
+Base.foo
+&gt;&gt;&gt; b.bar()
+Base.bar
+&gt;&gt;&gt; d.foo()
+Derived.foo
+&gt;&gt;&gt; d.bar()
+Base.bar</pre>
+
+<p>There is one weakness in the default behavior. Take a function like the following:</p>
+
+<pre class="code"><span class="keyword">void</span> polymorphic_call(Base b) {
+    b.foo();
+}</pre>
+
+<p>And in Python:</p>
+
+<pre class="code"><span class="keyword">class</span> PyClass(Base):
+    <span class="keyword">def</span> foo(self):
+        <span class="keyword">print</span> <span class="string">"PyClass.foo"</span>
+
+&gt;&gt;&gt; p = PyClass()
+&gt;&gt;&gt; polymorphic_call(p)
+Base.foo</pre>
+
+<p>Optimally, we would want <code>polymorphic_call</code> to call PyClass.foo. This requires some additional work on the D side of things. To get this behavior, then rather than expose Base directly, we must expose a wrapper class:</p>
+
+<pre class="code"><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>);
+    }
+}</pre>
+
+<p>Now, we must replace the old wrapping of Base with this:</p>
+
+<pre class="code">wrapped_class!(BaseWrap, <span class="string">"Base"</span>) w;
+w.def!(BaseWrap.foo);
+w.def!(BaseWrap.bar);
+finalize_class(w);</pre>
+
+<p>Now our subclass will perform just like we expect:</p>
+
+<pre class="code">&gt;&gt;&gt; p = PyClass()
+&gt;&gt;&gt; polymorphic_call(p)
+PyClass.foo</pre>
-
-<h3><a class="anchor" name="examples">Examples</a></h3>

trunk/html_doc/conversion.html

@@ -20 +20 @@
-<a class="nav" href="except_wrapping.html">Exception wrapping</a><br />
-<a class="nav" href="pydobject.html">PydObject</a><br />
+<a class="nav" href="vsboost.html">vs. Boost.Python</a><br />
-<a class="nav" href="credits.html">Credits</a>
-</div>

trunk/html_doc/credits.html

@@ -20 +20 @@
-<a class="nav" href="except_wrapping.html">Exception wrapping</a><br />
-<a class="nav" href="pydobject.html">PydObject</a><br />
+<a class="nav" href="vsboost.html">vs. Boost.Python</a><br />
-<a class="navcur" href="credits.html">Credits</a>
-</div>

trunk/html_doc/except_wrapping.html

@@ -20 +20 @@
-<a class="navcur" href="except_wrapping.html">Exception wrapping</a><br />
-<a class="nav" href="pydobject.html">PydObject</a><br />
+<a class="nav" href="vsboost.html">vs. Boost.Python</a><br />
-<a class="nav" href="credits.html">Credits</a>
-</div>

trunk/html_doc/func_wrapping.html

@@ -20 +20 @@
-<a class="nav" href="except_wrapping.html">Exception wrapping</a><br />
-<a class="nav" href="pydobject.html">PydObject</a><br />
+<a class="nav" href="vsboost.html">vs. Boost.Python</a><br />
-<a class="nav" href="credits.html">Credits</a>
-</div>

trunk/html_doc/index.html

@@ -20 +20 @@
-<a class="nav" href="except_wrapping.html">Exception wrapping</a><br />
-<a class="nav" href="pydobject.html">PydObject</a><br />
+<a class="nav" href="vsboost.html">vs. Boost.Python</a><br />
-<a class="nav" href="credits.html">Credits</a>
-</div>

trunk/html_doc/install.html

@@ -20 +20 @@
-<a class="nav" href="except_wrapping.html">Exception wrapping</a><br />
-<a class="nav" href="pydobject.html">PydObject</a><br />
+<a class="nav" href="vsboost.html">vs. Boost.Python</a><br />
-<a class="nav" href="credits.html">Credits</a>
-</div>

trunk/html_doc/pydobject.html

@@ -20 +20 @@
-<a class="nav" href="except_wrapping.html">Exception wrapping</a><br />
-<a class="navcur" href="pydobject.html">PydObject</a><br />
+<a class="nav" href="vsboost.html">vs. Boost.Python</a><br />
-<a class="nav" href="credits.html">Credits</a>
-</div>

trunk/html_doc/struct_wrapping.html

@@ -20 +20 @@
-<a class="nav" href="except_wrapping.html">Exception wrapping</a><br />
-<a class="nav" href="pydobject.html">PydObject</a><br />
+<a class="nav" href="vsboost.html">vs. Boost.Python</a><br />
-<a class="nav" href="credits.html">Credits</a>
-</div>

trunk/infrastructure/pyd/class_wrap.d

@@ -447 +447 @@
-}
-
+import std.stdio;
+
+template OverloadShim() {
+    std.traits.ReturnType!(dg_t) get_overload(dg_t, T ...) (dg_t dg, char[] name, T t) {
+        python.PyObject* _pyobj = wrapped_gc_objects[cast(void*)this];
+        if (_pyobj.ob_type != &wrapped_class_type!(typeof(this))) {
+            //writefln("Wrapper class, calling wrapped PyObject");
+            // 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.
+            python.PyObject* method = python.PyObject_GetAttrString(_pyobj, (name ~ \0).ptr);
+            if (method is null) handle_exception();
+            dg_t pydg = PydCallable_AsDelegate!(dg_t)(method);
+            python.Py_DECREF(method);
+            return pydg(t);
+        } else {
+            //writefln("Wrapper class, calling original delegate");
+            return dg(t);
+        }
+    }
+}
+
-///////////////////////
-// PYD API FUNCTIONS //

trunk/infrastructure/pyd/exception.d

@@ -25 +25 @@
-private import meta.Nameof;
-private import std.string;
+import std.stdio;
-
-/**
@@ -106 +107 @@
-
-    ~this() {
-
-
-
+if (m_type) 
+if (m_value) 
+if (m_trace) 
-    }
-
-    PyObject* type() {
-
+if (m_type) 
-        return m_type;
-    }
-    PyObject* value() {
-
+if (m_value) 
-        return m_value;
-    }
-    PyObject* traceback() {
-
+if (m_trace) 
-        return m_trace;
-    }

trunk/infrastructure/pyd/func_wrap.d

@@ -88 +88 @@
-}
-
+import std.stdio;
+
-// Calls callable alias fn with PyTuple args.
-ReturnType!(fn_t) applyPyTupleToAlias(alias fn, fn_t, uint MIN_ARGS) (PyObject* args) {
@@ -99 +101 @@
-        argCount = PyObject_Length(args);
-    }
+    //writefln("argCount: %s; MIN_ARGS: %s; MAX_ARGS: %s", argCount, MIN_ARGS, MAX_ARGS);
-
-    // Sanity check!
@@ -196 +199 @@
-        fn_t fn = (cast(wrapped_class_object!(fn_t)*)self).d_obj;
-
-
+delegate PyObject*() 
-            return pyApplyToDelegate(fn, args);
-        });