|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r63506 - in trunk/libs/python/doc/tutorial/doc/html: . python
From: daniel_james_at_[hidden]
Date: 2010-07-02 14:55:10
Author: danieljames
Date: 2010-07-01 18:13:45 EDT (Thu, 01 Jul 2010)
New Revision: 63506
URL: http://svn.boost.org/trac/boost/changeset/63506
Log:
Rebuild python documentation.
Text files modified:
trunk/libs/python/doc/tutorial/doc/html/index.html | 48 ++---
trunk/libs/python/doc/tutorial/doc/html/python/embedding.html | 124 +++++++--------
trunk/libs/python/doc/tutorial/doc/html/python/exception.html | 22 +-
trunk/libs/python/doc/tutorial/doc/html/python/exposing.html | 232 +++++++++++++++---------------
trunk/libs/python/doc/tutorial/doc/html/python/functions.html | 303 ++++++++++++++++++++-------------------
trunk/libs/python/doc/tutorial/doc/html/python/hello.html | 127 ++++++---------
trunk/libs/python/doc/tutorial/doc/html/python/iterators.html | 128 ++++++++--------
trunk/libs/python/doc/tutorial/doc/html/python/object.html | 147 +++++++++---------
trunk/libs/python/doc/tutorial/doc/html/python/techniques.html | 118 +++++++-------
9 files changed, 610 insertions(+), 639 deletions(-)
Modified: trunk/libs/python/doc/tutorial/doc/html/index.html
==============================================================================
--- trunk/libs/python/doc/tutorial/doc/html/index.html (original)
+++ trunk/libs/python/doc/tutorial/doc/html/index.html 2010-07-01 18:13:45 EDT (Thu, 01 Jul 2010)
@@ -1,11 +1,11 @@
<html>
<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Chapter 1. python 2.0</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
-<link rel="start" href="index.html" title="Chapter 1. python 1.0">
-<link rel="next" href="python/hello.html" title=" Building Hello World">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Chapter 1. python 2.0</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="index.html" title="Chapter 1. python 2.0">
+<link rel="next" href="python/hello.html" title="Building Hello World">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@@ -17,21 +17,21 @@
<td align="center">More</td>
</tr></table>
<hr>
-<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a></div>
-<div class="chapter" lang="en">
+<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a></div>
+<div class="chapter">
<div class="titlepage"><div>
<div><h2 class="title">
-<a name="python"></a>Chapter 1. python 1.0</h2></div>
+<a name="python"></a>Chapter 1. python 2.0</h2></div>
<div><div class="author"><h3 class="author">
<span class="firstname">Joel</span> <span class="surname">de Guzman</span>
</h3></div></div>
<div><div class="author"><h3 class="author">
<span class="firstname">David</span> <span class="surname">Abrahams</span>
</h3></div></div>
-<div><p class="copyright">Copyright © 2002-2005 Joel
+<div><p class="copyright">Copyright © 2002-2005 Joel
de Guzman, David Abrahams</p></div>
<div><div class="legalnotice">
-<a name="id457106"></a><p>
+<a name="id759709"></a><p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
http://www.boost.org/LICENSE_1_0.txt </a>)
@@ -79,7 +79,7 @@
</dl></dd>
</dl>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="python.quickstart"></a>QuickStart</h2></div></div></div>
<p>
@@ -93,10 +93,10 @@
code takes on the look of a kind of declarative interface definition language
(IDL).
</p>
-<a name="quickstart.hello_world"></a><h2>
-<a name="id386707"></a>
+<a name="quickstart.hello_world"></a><h3>
+<a name="id759740"></a>
Hello World
- </h2>
+ </h3>
<p>
Following C/C++ tradition, let's start with the "hello, world". A
C++ Function:
@@ -129,23 +129,17 @@
</pre>
<p>
</p>
-<div class="blockquote"><blockquote class="blockquote">
-<p>
- </p>
-<p>
- <span class="emphasis"><em><span class="bold"><b>Next stop... Building your Hello World
- module from start to finish...</b></span></em></span>
- </p>
-<p>
- </p>
-</blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <span class="emphasis"><em><span class="bold"><strong>Next stop... Building your Hello World module
+ from start to finish...</strong></span></em></span>
+ </p></blockquote></div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: November 22, 2008 at 03:24:11 GMT</small></p></td>
+<td align="left"><p><small>Last revised: July 01, 2010 at 21:56:58 GMT</small></p></td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>
-<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a></div>
</body>
</html>
Modified: trunk/libs/python/doc/tutorial/doc/html/python/embedding.html
==============================================================================
--- trunk/libs/python/doc/tutorial/doc/html/python/embedding.html (original)
+++ trunk/libs/python/doc/tutorial/doc/html/python/embedding.html 2010-07-01 18:13:45 EDT (Thu, 01 Jul 2010)
@@ -1,12 +1,12 @@
<html>
<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Embedding</title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="prev" href="object.html" title=" Object Interface">
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../index.html" title="Chapter 1. python 2.0">
+<link rel="up" href="../index.html" title="Chapter 1. python 2.0">
+<link rel="prev" href="object.html" title="Object Interface">
<link rel="next" href="iterators.html" title="Iterators">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,9 +20,9 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="object.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="object.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="python.embedding"></a>Embedding</h2></div></div></div>
<div class="toc"><dl><dt><span class="section">Using the interpreter</span></dt></dl></div>
@@ -39,28 +39,28 @@
a lot easier and, in a future version, it may become unnecessary to touch the
Python/C API at all. So stay tuned... <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span>
</p>
-<a name="embedding.building_embedded_programs"></a><h2>
-<a name="id472330"></a>
+<a name="embedding.building_embedded_programs"></a><h3>
+<a name="id773307"></a>
Building embedded programs
- </h2>
+ </h3>
<p>
To be able to embed python into your programs, you have to link to both Boost.Python's
as well as Python's own runtime library.
</p>
<p>
Boost.Python's library comes in two variants. Both are located in Boost's
- <tt class="literal">/libs/python/build/bin-stage</tt> subdirectory. On Windows, the
- variants are called <tt class="literal">boost_python.lib</tt> (for release builds)
- and <tt class="literal">boost_python_debug.lib</tt> (for debugging). If you can't
+ <code class="literal">/libs/python/build/bin-stage</code> subdirectory. On Windows, the
+ variants are called <code class="literal">boost_python.lib</code> (for release builds)
+ and <code class="literal">boost_python_debug.lib</code> (for debugging). If you can't
find the libraries, you probably haven't built Boost.Python yet. See Building and Testing on how to do this.
</p>
<p>
- Python's library can be found in the <tt class="literal">/libs</tt> subdirectory
+ Python's library can be found in the <code class="literal">/libs</code> subdirectory
of your Python directory. On Windows it is called pythonXY.lib where X.Y is
your major Python version number.
</p>
<p>
- Additionally, Python's <tt class="literal">/include</tt> subdirectory has to be added
+ Additionally, Python's <code class="literal">/include</code> subdirectory has to be added
to your include path.
</p>
<p>
@@ -81,56 +81,50 @@
<library-path>$(PYTHON_LIB_PATH)
<find-library>$(PYTHON_EMBEDDED_LIBRARY) ;
</pre>
-<a name="embedding.getting_started"></a><h2>
-<a name="id472435"></a>
+<a name="embedding.getting_started"></a><h3>
+<a name="id773391"></a>
Getting started
- </h2>
+ </h3>
<p>
Being able to build is nice, but there is nothing to build yet. Embedding the
Python interpreter into one of your C++ programs requires these 4 steps:
</p>
-<div class="orderedlist"><ol type="1">
-<li>
- #include <tt class="literal"><boost/python.hpp></tt>
-</li>
-<li>
- Call Py_Initialize()
- to start the interpreter and create the <tt class="literal"><span class="underline">_main</span>_</tt>
- module.
- </li>
-<li>
- Call other Python C API routines to use the interpreter.
- </li>
+<div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+ #include <code class="literal"><boost/python.hpp></code>
+ </li>
+<li class="listitem">
+ Call Py_Initialize()
+ to start the interpreter and create the <code class="literal"><span class="underline">_main</span>_</code>
+ module.
+ </li>
+<li class="listitem">
+ Call other Python C API routines to use the interpreter.
+ </li>
</ol></div>
<div class="note"><table border="0" summary="Note">
<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
-<tr><td colspan="2" align="left" valign="top"><p>
- <span class="bold"><b>Note that at this time you must not call Py_Finalize()
- to stop the interpreter. This may be fixed in a future version of boost.python.</b></span>
+<tr><td align="left" valign="top"><p>
+ <span class="bold"><strong>Note that at this time you must not call Py_Finalize()
+ to stop the interpreter. This may be fixed in a future version of boost.python.</strong></span>
</p></td></tr>
</table></div>
<p>
(Of course, there can be other C++ code between all of these steps.)
</p>
-<div class="blockquote"><blockquote class="blockquote">
-<p>
- </p>
-<p>
- <span class="emphasis"><em><span class="bold"><b>Now that we can embed the interpreter in
- our programs, lets see how to put it to use...</b></span></em></span>
- </p>
-<p>
- </p>
-</blockquote></div>
-<div class="section" lang="en">
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <span class="emphasis"><em><span class="bold"><strong>Now that we can embed the interpreter in
+ our programs, lets see how to put it to use...</strong></span></em></span>
+ </p></blockquote></div>
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.using_the_interpreter"></a>Using the interpreter</h3></div></div></div>
<p>
As you probably already know, objects in Python are reference-counted. Naturally,
- the <tt class="literal">PyObject</tt>s of the Python C API are also reference-counted.
+ the <code class="literal">PyObject</code>s of the Python C API are also reference-counted.
There is a difference however. While the reference-counting is fully automatic
in Python, the Python C API requires you to do it <a href="http://www.python.org/doc/current/c-api/refcounting.html" target="_top">by
hand</a>. This is messy and especially hard to get right in the presence
@@ -138,10 +132,10 @@
and object class templates to
automate the process.
</p>
-<a name="using_the_interpreter.running_python_code"></a><h2>
-<a name="id472601"></a>
+<a name="using_the_interpreter.running_python_code"></a><h3>
+<a name="id773549"></a>
Running Python code
- </h2>
+ </h3>
<p>
Boost.python provides three related functions to run Python code from C++.
</p>
@@ -155,10 +149,10 @@
and exec_file executes the code contained in the given file.
</p>
<p>
- The <tt class="literal">globals</tt> and <tt class="literal">locals</tt> parameters are
+ The <code class="literal">globals</code> and <code class="literal">locals</code> parameters are
Python dictionaries containing the globals and locals of the context in which
to run the code. For most intents and purposes you can use the namespace
- dictionary of the <tt class="literal"><span class="underline">_main</span>_</tt>
+ dictionary of the <code class="literal"><span class="underline">_main</span>_</code>
module for both parameters.
</p>
<p>
@@ -171,7 +165,7 @@
first), and returns it.
</p>
<p>
- Let's import the <tt class="literal"><span class="underline">_main</span>_</tt>
+ Let's import the <code class="literal"><span class="underline">_main</span>_</code>
module and run some Python code in its namespace:
</p>
<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
@@ -186,15 +180,15 @@
This should create a file called 'hello.txt' in the current directory containing
a phrase that is well-known in programming circles.
</p>
-<a name="using_the_interpreter.manipulating_python_objects"></a><h2>
-<a name="id473185"></a>
+<a name="using_the_interpreter.manipulating_python_objects"></a><h3>
+<a name="id774064"></a>
Manipulating Python objects
- </h2>
+ </h3>
<p>
Often we'd like to have a class to manipulate Python objects. But we have
already seen such a class above, and in the <a href="object.html" target="_top">previous
- section</a>: the aptly named <tt class="literal">object</tt> class and its
- derivatives. We've already seen that they can be constructed from a <tt class="literal">handle</tt>.
+ section</a>: the aptly named <code class="literal">object</code> class and its
+ derivatives. We've already seen that they can be constructed from a <code class="literal">handle</code>.
The following examples should further illustrate this fact:
</p>
<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
@@ -203,7 +197,7 @@
<span class="keyword">int</span> <span class="identifier">five_squared</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special"><</span><span class="keyword">int</span><span class="special">>(</span><span class="identifier">main_namespace</span><span class="special">[</span><span class="string">"result"</span><span class="special">]);</span>
</pre>
<p>
- Here we create a dictionary object for the <tt class="literal"><span class="underline">_main</span>_</tt>
+ Here we create a dictionary object for the <code class="literal"><span class="underline">_main</span>_</code>
module's namespace. Then we assign 5 squared to the result variable and read
this variable from the dictionary. Another way to achieve the same result
is to use eval instead, which returns the result directly:
@@ -211,10 +205,10 @@
<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">eval</span><span class="special">(</span><span class="string">"5 ** 2"</span><span class="special">);</span>
<span class="keyword">int</span> <span class="identifier">five_squared</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special"><</span><span class="keyword">int</span><span class="special">>(</span><span class="identifier">result</span><span class="special">);</span>
</pre>
-<a name="using_the_interpreter.exception_handling"></a><h2>
-<a name="id473554"></a>
+<a name="using_the_interpreter.exception_handling"></a><h3>
+<a name="id774390"></a>
Exception handling
- </h2>
+ </h3>
<p>
If an exception occurs in the evaluation of the python expression, error_already_set
is thrown:
@@ -231,7 +225,7 @@
</span><span class="special">}</span>
</pre>
<p>
- The <tt class="literal">error_already_set</tt> exception class doesn't carry any
+ The <code class="literal">error_already_set</code> exception class doesn't carry any
information in itself. To find out more about the Python exception that occurred,
you need to use the <a href="http://www.python.org/doc/api/exceptionHandling.html" target="_top">exception
handling functions</a> of the Python C API in your catch-statement. This
@@ -261,7 +255,7 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
de Guzman, David Abrahams<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
@@ -271,7 +265,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="object.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="object.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
Modified: trunk/libs/python/doc/tutorial/doc/html/python/exception.html
==============================================================================
--- trunk/libs/python/doc/tutorial/doc/html/python/exception.html (original)
+++ trunk/libs/python/doc/tutorial/doc/html/python/exception.html 2010-07-01 18:13:45 EDT (Thu, 01 Jul 2010)
@@ -1,13 +1,13 @@
<html>
<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Exception Translation</title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Exception Translation</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../index.html" title="Chapter 1. python 2.0">
+<link rel="up" href="../index.html" title="Chapter 1. python 2.0">
<link rel="prev" href="iterators.html" title="Iterators">
-<link rel="next" href="techniques.html" title=" General Techniques">
+<link rel="next" href="techniques.html" title="General Techniques">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@@ -20,9 +20,9 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="iterators.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="techniques.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="iterators.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="techniques.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="python.exception"></a> Exception Translation</h2></div></div></div>
<p>
@@ -47,7 +47,7 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
de Guzman, David Abrahams<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
@@ -57,7 +57,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="iterators.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="techniques.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="iterators.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="techniques.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
Modified: trunk/libs/python/doc/tutorial/doc/html/python/exposing.html
==============================================================================
--- trunk/libs/python/doc/tutorial/doc/html/python/exposing.html (original)
+++ trunk/libs/python/doc/tutorial/doc/html/python/exposing.html 2010-07-01 18:13:45 EDT (Thu, 01 Jul 2010)
@@ -1,12 +1,12 @@
<html>
<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Exposing Classes</title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="prev" href="hello.html" title=" Building Hello World">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Exposing Classes</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../index.html" title="Chapter 1. python 2.0">
+<link rel="up" href="../index.html" title="Chapter 1. python 2.0">
+<link rel="prev" href="hello.html" title="Building Hello World">
<link rel="next" href="functions.html" title="Functions">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,9 +20,9 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="hello.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="hello.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="python.exposing"></a> Exposing Classes</h2></div></div></div>
<div class="toc"><dl>
@@ -62,9 +62,9 @@
<span class="special">}</span>
</pre>
<p>
- Here, we wrote a C++ class wrapper that exposes the member functions <tt class="literal">greet</tt>
- and <tt class="literal">set</tt>. Now, after building our module as a shared library,
- we may use our class <tt class="literal">World</tt> in Python. Here's a sample Python
+ Here, we wrote a C++ class wrapper that exposes the member functions <code class="literal">greet</code>
+ and <code class="literal">set</code>. Now, after building our module as a shared library,
+ we may use our class <code class="literal">World</code> in Python. Here's a sample Python
session:
</p>
<p>
@@ -75,11 +75,11 @@
<span class="special">>>></span> <span class="identifier">planet</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span>
<span class="string">'howdy'</span>
</pre>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.constructors"></a>Constructors</h3></div></div></div>
<p>
- Our previous example didn't have any explicit constructors. Since <tt class="literal">World</tt>
+ Our previous example didn't have any explicit constructors. Since <code class="literal">World</code>
is declared as a plain struct, it has an implicit default constructor. Boost.Python
exposes the default constructor by default, which is why we were able to
write
@@ -101,9 +101,9 @@
<span class="special">};</span>
</pre>
<p>
- This time <tt class="literal">World</tt> has no default constructor; our previous
+ This time <code class="literal">World</code> has no default constructor; our previous
wrapping code would fail to compile when the library tried to expose it.
- We have to tell <tt class="literal">class_<World></tt> about the constructor
+ We have to tell <code class="literal">class_<World></code> about the constructor
we want to expose instead.
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
@@ -118,13 +118,13 @@
<span class="special">}</span>
</pre>
<p>
- <tt class="literal">init<std::string>()</tt> exposes the constructor taking
- in a <tt class="literal">std::string</tt> (in Python, constructors are spelled
- "<tt class="literal">"<span class="underline">_init</span>_"</tt>").
+ <code class="literal">init<std::string>()</code> exposes the constructor taking
+ in a <code class="literal">std::string</code> (in Python, constructors are spelled
+ "<code class="literal">"<span class="underline">_init</span>_"</code>").
</p>
<p>
- We can expose additional constructors by passing more <tt class="literal">init<...></tt>s
- to the <tt class="literal">def()</tt> member function. Say for example we have
+ We can expose additional constructors by passing more <code class="literal">init<...></code>s
+ to the <code class="literal">def()</code> member function. Say for example we have
another World constructor taking in two doubles:
</p>
<pre class="programlisting"><span class="identifier">class_</span><span class="special"><</span><span class="identifier">World</span><span class="special">>(</span><span class="string">"World"</span><span class="special">,</span> <span class="identifier">init</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">>())</span>
@@ -135,23 +135,23 @@
</pre>
<p>
On the other hand, if we do not wish to expose any constructors at all, we
- may use <tt class="literal">no_init</tt> instead:
+ may use <code class="literal">no_init</code> instead:
</p>
<pre class="programlisting"><span class="identifier">class_</span><span class="special"><</span><span class="identifier">Abstract</span><span class="special">>(</span><span class="string">"Abstract"</span><span class="special">,</span> <span class="identifier">no_init</span><span class="special">)</span>
</pre>
<p>
- This actually adds an <tt class="literal"><span class="underline">_init</span>_</tt>
+ This actually adds an <code class="literal"><span class="underline">_init</span>_</code>
method which always raises a Python RuntimeError exception.
</p>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.class_data_members"></a>Class Data Members</h3></div></div></div>
<p>
Data members may also be exposed to Python so that they can be accessed as
attributes of the corresponding Python class. Each data member that we wish
- to be exposed may be regarded as <span class="bold"><b>read-only</b></span>
- or <span class="bold"><b>read-write</b></span>. Consider this class <tt class="literal">Var</tt>:
+ to be exposed may be regarded as <span class="bold"><strong>read-only</strong></span>
+ or <span class="bold"><strong>read-write</strong></span>. Consider this class <code class="literal">Var</code>:
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Var</span>
<span class="special">{</span>
@@ -161,7 +161,7 @@
<span class="special">};</span>
</pre>
<p>
- Our C++ <tt class="literal">Var</tt> class and its data members can be exposed
+ Our C++ <code class="literal">Var</code> class and its data members can be exposed
to Python:
</p>
<pre class="programlisting"><span class="identifier">class_</span><span class="special"><</span><span class="identifier">Var</span><span class="special">>(</span><span class="string">"Var"</span><span class="special">,</span> <span class="identifier">init</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">>())</span>
@@ -180,16 +180,16 @@
<span class="identifier">pi</span> <span class="keyword">is</span> <span class="identifier">around</span> <span class="number">3.14</span>
</pre>
<p>
- Note that <tt class="literal">name</tt> is exposed as <span class="bold"><b>read-only</b></span>
- while <tt class="literal">value</tt> is exposed as <span class="bold"><b>read-write</b></span>.
+ Note that <code class="literal">name</code> is exposed as <span class="bold"><strong>read-only</strong></span>
+ while <code class="literal">value</code> is exposed as <span class="bold"><strong>read-write</strong></span>.
</p>
<pre class="programlisting"><span class="special">>>></span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">name</span> <span class="special">=</span> <span class="string">'e'</span> <span class="comment"># can't change name
</span><span class="identifier">Traceback</span> <span class="special">(</span><span class="identifier">most</span> <span class="identifier">recent</span> <span class="identifier">call</span> <span class="identifier">last</span><span class="special">):</span>
- <span class="identifier">File</span> <span class="string">"<stdin>"</span><span class="special">,</span> <span class="identifier">line</span> <span class="number">1</span><span class="special">,</span> <span class="keyword">in</span> #
-<span class="identifier">AttributeError</span><span class="special">:</span> <span class="identifier">can</span>#<span class="identifier">t</span> <span class="identifier">set</span> <span class="identifier">attribute</span>
+ <span class="identifier">File</span> <span class="string">"<stdin>"</span><span class="special">,</span> <span class="identifier">line</span> <span class="number">1</span><span class="special">,</span> <span class="keyword">in</span> <span class="error">?</span>
+<span class="identifier">AttributeError</span><span class="special">:</span> <span class="identifier">can</span><span class="error">'</span><span class="identifier">t</span> <span class="identifier">set</span> <span class="identifier">attribute</span>
</pre>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.class_properties"></a>Class Properties</h3></div></div></div>
<p>
@@ -211,7 +211,7 @@
<p>
However, in Python attribute access is fine; it doesn't neccessarily break
encapsulation to let users handle attributes directly, because the attributes
- can just be a different syntax for a method call. Wrapping our <tt class="literal">Num</tt>
+ can just be a different syntax for a method call. Wrapping our <code class="literal">Num</code>
class using Boost.Python:
</p>
<pre class="programlisting"><span class="identifier">class_</span><span class="special"><</span><span class="identifier">Num</span><span class="special">>(</span><span class="string">"Num"</span><span class="special">)</span>
@@ -230,8 +230,8 @@
<span class="special">>>></span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">rovalue</span> <span class="special">=</span> <span class="number">2.17</span> <span class="comment"># error!
</span></pre>
<p>
- Take note that the class property <tt class="literal">rovalue</tt> is exposed as
- <span class="bold"><b>read-only</b></span> since the <tt class="literal">rovalue</tt>
+ Take note that the class property <code class="literal">rovalue</code> is exposed as
+ <span class="bold"><strong>read-only</strong></span> since the <code class="literal">rovalue</code>
setter member function is not passed in:
</p>
<p>
@@ -239,7 +239,7 @@
<pre class="programlisting"><span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"rovalue"</span><span class="special">,</span> <span class="special">&</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">)</span>
</pre>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.inheritance"></a>Inheritance</h3></div></div></div>
<p>
@@ -256,7 +256,7 @@
<span class="keyword">struct</span> <span class="identifier">Derived</span> <span class="special">:</span> <span class="identifier">Base</span> <span class="special">{};</span>
</pre>
<p>
- And a set of C++ functions operating on <tt class="literal">Base</tt> and <tt class="literal">Derived</tt>
+ And a set of C++ functions operating on <code class="literal">Base</code> and <code class="literal">Derived</code>
object instances:
</p>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">b</span><span class="special">(</span><span class="identifier">Base</span><span class="special">*);</span>
@@ -264,15 +264,15 @@
<span class="identifier">Base</span><span class="special">*</span> <span class="identifier">factory</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="keyword">new</span> <span class="identifier">Derived</span><span class="special">;</span> <span class="special">}</span>
</pre>
<p>
- We've seen how we can wrap the base class <tt class="literal">Base</tt>:
+ We've seen how we can wrap the base class <code class="literal">Base</code>:
</p>
<pre class="programlisting"><span class="identifier">class_</span><span class="special"><</span><span class="identifier">Base</span><span class="special">>(</span><span class="string">"Base"</span><span class="special">)</span>
<span class="comment">/*...*/</span>
<span class="special">;</span>
</pre>
<p>
- Now we can inform Boost.Python of the inheritance relationship between <tt class="literal">Derived</tt>
- and its base class <tt class="literal">Base</tt>. Thus:
+ Now we can inform Boost.Python of the inheritance relationship between <code class="literal">Derived</code>
+ and its base class <code class="literal">Base</code>. Thus:
</p>
<pre class="programlisting"><span class="identifier">class_</span><span class="special"><</span><span class="identifier">Derived</span><span class="special">,</span> <span class="identifier">bases</span><span class="special"><</span><span class="identifier">Base</span><span class="special">></span> <span class="special">>(</span><span class="string">"Derived"</span><span class="special">)</span>
<span class="comment">/*...*/</span>
@@ -281,33 +281,33 @@
<p>
Doing so, we get some things for free:
</p>
-<div class="orderedlist"><ol type="1">
-<li>
- Derived automatically inherits all of Base's Python methods (wrapped C++
- member functions)
- </li>
-<li>
-<span class="bold"><b>If</b></span> Base is polymorphic, <tt class="literal">Derived</tt>
- objects which have been passed to Python via a pointer or reference to
- <tt class="literal">Base</tt> can be passed where a pointer or reference to
- <tt class="literal">Derived</tt> is expected.
- </li>
+<div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+ Derived automatically inherits all of Base's Python methods (wrapped
+ C++ member functions)
+ </li>
+<li class="listitem">
+ <span class="bold"><strong>If</strong></span> Base is polymorphic, <code class="literal">Derived</code>
+ objects which have been passed to Python via a pointer or reference to
+ <code class="literal">Base</code> can be passed where a pointer or reference to
+ <code class="literal">Derived</code> is expected.
+ </li>
</ol></div>
<p>
- Now, we will expose the C++ free functions <tt class="literal">b</tt> and <tt class="literal">d</tt>
- and <tt class="literal">factory</tt>:
+ Now, we will expose the C++ free functions <code class="literal">b</code> and <code class="literal">d</code>
+ and <code class="literal">factory</code>:
</p>
<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"b"</span><span class="special">,</span> <span class="identifier">b</span><span class="special">);</span>
<span class="identifier">def</span><span class="special">(</span><span class="string">"d"</span><span class="special">,</span> <span class="identifier">d</span><span class="special">);</span>
<span class="identifier">def</span><span class="special">(</span><span class="string">"factory"</span><span class="special">,</span> <span class="identifier">factory</span><span class="special">);</span>
</pre>
<p>
- Note that free function <tt class="literal">factory</tt> is being used to generate
- new instances of class <tt class="literal">Derived</tt>. In such cases, we use
- <tt class="literal">return_value_policy<manage_new_object></tt> to instruct
- Python to adopt the pointer to <tt class="literal">Base</tt> and hold the instance
- in a new Python <tt class="literal">Base</tt> object until the the Python object
- is destroyed. We will see more of Boost.Python <a href="functions.html#python.call_policies" title="Call Policies">call
+ Note that free function <code class="literal">factory</code> is being used to generate
+ new instances of class <code class="literal">Derived</code>. In such cases, we use
+ <code class="literal">return_value_policy<manage_new_object></code> to instruct
+ Python to adopt the pointer to <code class="literal">Base</code> and hold the instance
+ in a new Python <code class="literal">Base</code> object until the the Python object
+ is destroyed. We will see more of Boost.Python <a class="link" href="functions.html#python.call_policies" title="Call Policies">call
policies</a> later.
</p>
<pre class="programlisting"><span class="comment">// Tell Python to take ownership of factory's result
@@ -315,13 +315,13 @@
<span class="identifier">return_value_policy</span><span class="special"><</span><span class="identifier">manage_new_object</span><span class="special">>());</span>
</pre>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.class_virtual_functions"></a>Class Virtual Functions</h3></div></div></div>
<p>
In this section, we will learn how to make functions behave polymorphically
through virtual functions. Continuing our example, let us add a virtual function
- to our <tt class="literal">Base</tt> class:
+ to our <code class="literal">Base</code> class:
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span>
<span class="special">{</span>
@@ -333,11 +333,11 @@
One of the goals of Boost.Python is to be minimally intrusive on an existing
C++ design. In principle, it should be possible to expose the interface for
a 3rd party library without changing it. It is not ideal to add anything
- to our class <tt class="computeroutput"><span class="identifier">Base</span></tt>. Yet, when
+ to our class <code class="computeroutput"><span class="identifier">Base</span></code>. Yet, when
you have a virtual function that's going to be overridden in Python and called
- polymorphically <span class="bold"><b>from C++</b></span>, we'll need to
+ polymorphically <span class="bold"><strong>from C++</strong></span>, we'll need to
add some scaffoldings to make things work properly. What we'll do is write
- a class wrapper that derives from <tt class="computeroutput"><span class="identifier">Base</span></tt>
+ a class wrapper that derives from <code class="computeroutput"><span class="identifier">Base</span></code>
that will unintrusively hook into the virtual functions so that a Python
override may be called:
</p>
@@ -350,65 +350,66 @@
<span class="special">};</span>
</pre>
<p>
- Notice too that in addition to inheriting from <tt class="computeroutput"><span class="identifier">Base</span></tt>,
- we also multiply- inherited <tt class="computeroutput"><span class="identifier">wrapper</span><span class="special"><</span><span class="identifier">Base</span><span class="special">></span></tt> (See Wrapper).
- The <tt class="computeroutput"><span class="identifier">wrapper</span></tt> template makes
+ Notice too that in addition to inheriting from <code class="computeroutput"><span class="identifier">Base</span></code>,
+ we also multiply- inherited <code class="computeroutput"><span class="identifier">wrapper</span><span class="special"><</span><span class="identifier">Base</span><span class="special">></span></code> (See Wrapper).
+ The <code class="computeroutput"><span class="identifier">wrapper</span></code> template makes
the job of wrapping classes that are meant to overridden in Python, easier.
</p>
<div class="sidebar">
+<p class="title"><b></b></p>
<p>
- <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><b>MSVC6/7 Workaround</b></span>
+ <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><strong>MSVC6/7 Workaround</strong></span>
</p>
<p>
- If you are using Microsoft Visual C++ 6 or 7, you have to write <tt class="computeroutput"><span class="identifier">f</span></tt> as:
+ If you are using Microsoft Visual C++ 6 or 7, you have to write <code class="computeroutput"><span class="identifier">f</span></code> as:
</p>
<p>
- <tt class="computeroutput"><span class="keyword">return</span> <span class="identifier">call</span><span class="special"><</span><span class="keyword">int</span><span class="special">>(</span><span class="keyword">this</span><span class="special">-></span><span class="identifier">get_override</span><span class="special">(</span><span class="string">"f"</span><span class="special">).</span><span class="identifier">ptr</span><span class="special">());</span></tt>.
+ <code class="computeroutput"><span class="keyword">return</span> <span class="identifier">call</span><span class="special"><</span><span class="keyword">int</span><span class="special">>(</span><span class="keyword">this</span><span class="special">-></span><span class="identifier">get_override</span><span class="special">(</span><span class="string">"f"</span><span class="special">).</span><span class="identifier">ptr</span><span class="special">());</span></code>.
</p>
</div>
<p>
- BaseWrap's overridden virtual member function <tt class="computeroutput"><span class="identifier">f</span></tt>
- in effect calls the corresponding method of the Python object through <tt class="computeroutput"><span class="identifier">get_override</span></tt>.
+ BaseWrap's overridden virtual member function <code class="computeroutput"><span class="identifier">f</span></code>
+ in effect calls the corresponding method of the Python object through <code class="computeroutput"><span class="identifier">get_override</span></code>.
</p>
<p>
- Finally, exposing <tt class="computeroutput"><span class="identifier">Base</span></tt>:
+ Finally, exposing <code class="computeroutput"><span class="identifier">Base</span></code>:
</p>
<pre class="programlisting"><span class="identifier">class_</span><span class="special"><</span><span class="identifier">BaseWrap</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">>(</span><span class="string">"Base"</span><span class="special">)</span>
<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">pure_virtual</span><span class="special">(&</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">))</span>
<span class="special">;</span>
</pre>
<p>
- <tt class="computeroutput"><span class="identifier">pure_virtual</span></tt> signals Boost.Python
- that the function <tt class="computeroutput"><span class="identifier">f</span></tt> is a
+ <code class="computeroutput"><span class="identifier">pure_virtual</span></code> signals Boost.Python
+ that the function <code class="computeroutput"><span class="identifier">f</span></code> is a
pure virtual function.
</p>
<div class="note"><table border="0" summary="Note">
<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
-<tr><td colspan="2" align="left" valign="top">
+<tr><td align="left" valign="top">
<p>
- <span class="bold"><b>member function and methods</b></span>
+ <span class="bold"><strong>member function and methods</strong></span>
</p>
<p>
- Python, like many object oriented languages uses the term <span class="bold"><b>methods</b></span>.
- Methods correspond roughly to C++'s <span class="bold"><b>member functions</b></span>
+ Python, like many object oriented languages uses the term <span class="bold"><strong>methods</strong></span>.
+ Methods correspond roughly to C++'s <span class="bold"><strong>member functions</strong></span>
</p>
</td></tr>
</table></div>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.virtual_functions_with_default_implementations"></a>Virtual Functions with Default Implementations</h3></div></div></div>
<p>
We've seen in the previous section how classes with pure virtual functions
are wrapped using Boost.Python's <a href="../../../../v2/wrapper.html" target="_top">class
- wrapper</a> facilities. If we wish to wrap <span class="bold"><b>non</b></span>-pure-virtual
+ wrapper</a> facilities. If we wish to wrap <span class="bold"><strong>non</strong></span>-pure-virtual
functions instead, the mechanism is a bit different.
</p>
<p>
- Recall that in the <a href="exposing.html#python.class_virtual_functions" title="Class Virtual Functions">previous
+ Recall that in the <a class="link" href="exposing.html#python.class_virtual_functions" title="Class Virtual Functions">previous
section</a>, we wrapped a class with a pure virtual function that we then
implemented in C++, or Python classes derived from it. Our base class:
</p>
@@ -418,8 +419,8 @@
<span class="special">};</span>
</pre>
<p>
- had a pure virtual function <tt class="literal">f</tt>. If, however, its member
- function <tt class="literal">f</tt> was not declared as pure virtual:
+ had a pure virtual function <code class="literal">f</code>. If, however, its member
+ function <code class="literal">f</code> was not declared as pure virtual:
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span>
<span class="special">{</span>
@@ -443,20 +444,21 @@
<span class="special">};</span>
</pre>
<p>
- Notice how we implemented <tt class="computeroutput"><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">f</span></tt>. Now,
- we have to check if there is an override for <tt class="computeroutput"><span class="identifier">f</span></tt>.
- If none, then we call <tt class="computeroutput"><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">()</span></tt>.
+ Notice how we implemented <code class="computeroutput"><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">f</span></code>. Now,
+ we have to check if there is an override for <code class="computeroutput"><span class="identifier">f</span></code>.
+ If none, then we call <code class="computeroutput"><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">()</span></code>.
</p>
<div class="sidebar">
+<p class="title"><b></b></p>
<p>
- <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><b>MSVC6/7 Workaround</b></span>
+ <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><strong>MSVC6/7 Workaround</strong></span>
</p>
<p>
If you are using Microsoft Visual C++ 6 or 7, you have to rewrite the line
- with the <tt class="computeroutput"><span class="special">*</span><span class="identifier">note</span><span class="special">*</span></tt> as:
+ with the <code class="computeroutput"><span class="special">*</span><span class="identifier">note</span><span class="special">*</span></code> as:
</p>
<p>
- <tt class="computeroutput"><span class="keyword">return</span> <span class="identifier">call</span><span class="special"><</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*>(</span><span class="identifier">f</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">());</span></tt>.
+ <code class="computeroutput"><span class="keyword">return</span> <span class="identifier">call</span><span class="special"><</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*>(</span><span class="identifier">f</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">());</span></code>.
</p>
</div>
<p>
@@ -467,10 +469,10 @@
<span class="special">;</span>
</pre>
<p>
- Take note that we expose both <tt class="computeroutput"><span class="special">&</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span></tt> and <tt class="computeroutput"><span class="special">&</span><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">default_f</span></tt>. Boost.Python needs to keep track
- of 1) the dispatch function <tt class="literal">f</tt> and 2) the forwarding function
- to its default implementation <tt class="literal">default_f</tt>. There's a special
- <tt class="literal">def</tt> function for this purpose.
+ Take note that we expose both <code class="computeroutput"><span class="special">&</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span></code> and <code class="computeroutput"><span class="special">&</span><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">default_f</span></code>. Boost.Python needs to keep track
+ of 1) the dispatch function <code class="literal">f</code> and 2) the forwarding function
+ to its default implementation <code class="literal">default_f</code>. There's a special
+ <code class="literal">def</code> function for this purpose.
</p>
<p>
In Python, the results would be as expected:
@@ -485,32 +487,32 @@
<span class="special">>>></span> <span class="identifier">derived</span> <span class="special">=</span> <span class="identifier">Derived</span><span class="special">()</span>
</pre>
<p>
- Calling <tt class="literal">base.f()</tt>:
+ Calling <code class="literal">base.f()</code>:
</p>
<pre class="programlisting"><span class="special">>>></span> <span class="identifier">base</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
<span class="number">0</span>
</pre>
<p>
- Calling <tt class="literal">derived.f()</tt>:
+ Calling <code class="literal">derived.f()</code>:
</p>
<pre class="programlisting"><span class="special">>>></span> <span class="identifier">derived</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
<span class="number">42</span>
</pre>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.class_operators_special_functions"></a>Class Operators/Special Functions</h3></div></div></div>
-<a name="class_operators_special_functions.python_operators"></a><h2>
-<a name="id462548"></a>
+<a name="class_operators_special_functions.python_operators"></a><h3>
+<a name="id764956"></a>
Python Operators
- </h2>
+ </h3>
<p>
C is well known for the abundance of operators. C++ extends this to the extremes
by allowing operator overloading. Boost.Python takes advantage of this and
makes it easy to wrap C++ operator-powered classes.
</p>
<p>
- Consider a file position class <tt class="literal">FilePos</tt> and a set of operators
+ Consider a file position class <code class="literal">FilePos</code> and a set of operators
that take on FilePos instances:
</p>
<p>
@@ -541,16 +543,16 @@
<p>
The code snippet above is very clear and needs almost no explanation at all.
It is virtually the same as the operators' signatures. Just take note that
- <tt class="literal">self</tt> refers to FilePos object. Also, not every class
- <tt class="literal">T</tt> that you might need to interact with in an operator
- expression is (cheaply) default-constructible. You can use <tt class="literal">other<T>()</tt>
- in place of an actual <tt class="literal">T</tt> instance when writing "self
+ <code class="literal">self</code> refers to FilePos object. Also, not every class
+ <code class="literal">T</code> that you might need to interact with in an operator
+ expression is (cheaply) default-constructible. You can use <code class="literal">other<T>()</code>
+ in place of an actual <code class="literal">T</code> instance when writing "self
expressions".
</p>
-<a name="class_operators_special_functions.special_methods"></a><h2>
-<a name="id463302"></a>
+<a name="class_operators_special_functions.special_methods"></a><h3>
+<a name="id765570"></a>
Special Methods
- </h2>
+ </h3>
<p>
Python has a few more <span class="emphasis"><em>Special Methods</em></span>. Boost.Python
supports all of the standard special method names supported by real Python
@@ -577,19 +579,19 @@
</p>
<div class="note"><table border="0" summary="Note">
<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
-<tr><td colspan="2" align="left" valign="top"><p>
- What is the business of <tt class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></tt>? Well, the method <tt class="computeroutput"><span class="identifier">str</span></tt> requires the <tt class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></tt> to do its work (i.e. <tt class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></tt>
- is used by the method defined by <tt class="computeroutput"><span class="identifier">def</span><span class="special">(</span><span class="identifier">str</span><span class="special">(</span><span class="identifier">self</span><span class="special">))</span></tt>.
+<tr><td align="left" valign="top"><p>
+ What is the business of <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></code>? Well, the method <code class="computeroutput"><span class="identifier">str</span></code> requires the <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></code> to do its work (i.e. <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></code>
+ is used by the method defined by <code class="computeroutput"><span class="identifier">def</span><span class="special">(</span><span class="identifier">str</span><span class="special">(</span><span class="identifier">self</span><span class="special">))</span></code>.
</p></td></tr>
</table></div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
de Guzman, David Abrahams<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
@@ -599,7 +601,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="hello.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="hello.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
Modified: trunk/libs/python/doc/tutorial/doc/html/python/functions.html
==============================================================================
--- trunk/libs/python/doc/tutorial/doc/html/python/functions.html (original)
+++ trunk/libs/python/doc/tutorial/doc/html/python/functions.html 2010-07-01 18:13:45 EDT (Thu, 01 Jul 2010)
@@ -1,13 +1,13 @@
<html>
<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Functions</title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="prev" href="exposing.html" title=" Exposing Classes">
-<link rel="next" href="object.html" title=" Object Interface">
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../index.html" title="Chapter 1. python 2.0">
+<link rel="up" href="../index.html" title="Chapter 1. python 2.0">
+<link rel="prev" href="exposing.html" title="Exposing Classes">
+<link rel="next" href="object.html" title="Object Interface">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@@ -20,9 +20,9 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="exposing.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="object.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="exposing.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="object.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="python.functions"></a>Functions</h2></div></div></div>
<div class="toc"><dl>
@@ -38,18 +38,12 @@
facilities that will make it even easier for us to expose C++ functions that
take advantage of C++ features such as overloading and default arguments.
</p>
-<div class="blockquote"><blockquote class="blockquote">
-<p>
- </p>
-<p>
- <span class="emphasis"><em>Read on...</em></span>
- </p>
-<p>
- </p>
-</blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <span class="emphasis"><em>Read on...</em></span>
+ </p></blockquote></div>
<p>
But before you do, you might want to fire up Python 2.2 or later and type
- <tt class="literal">>>> import this</tt>.
+ <code class="literal">>>> import this</code>.
</p>
<pre class="programlisting">>>> import this
The Zen of Python, by Tim Peters
@@ -68,12 +62,12 @@
There should be one-- and preferably only one --obvious way to do it
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
-Although never is often better than <span class="bold"><b>right</b></span> now.
+Although never is often better than <span class="bold"><strong>right</strong></span> now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
</pre>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.call_policies"></a>Call Policies</h3></div></div></div>
<p>
@@ -121,21 +115,23 @@
<p>
Here's what's happening:
</p>
-<div class="orderedlist"><ol type="1">
-<li>
-<tt class="literal">f</tt> is called passing in a reference to <tt class="literal">y</tt>
- and a pointer to <tt class="literal">z</tt>
-</li>
-<li>
- A reference to <tt class="literal">y.x</tt> is returned
- </li>
-<li>
-<tt class="literal">y</tt> is deleted. <tt class="literal">x</tt> is a dangling reference
- </li>
-<li>
-<tt class="literal">x.some_method()</tt> is called
- </li>
-<li><span class="bold"><b>BOOM!</b></span></li>
+<div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+ <code class="literal">f</code> is called passing in a reference to <code class="literal">y</code>
+ and a pointer to <code class="literal">z</code>
+ </li>
+<li class="listitem">
+ A reference to <code class="literal">y.x</code> is returned
+ </li>
+<li class="listitem">
+ <code class="literal">y</code> is deleted. <code class="literal">x</code> is a dangling reference
+ </li>
+<li class="listitem">
+ <code class="literal">x.some_method()</code> is called
+ </li>
+<li class="listitem">
+ <span class="bold"><strong>BOOM!</strong></span>
+ </li>
</ol></div>
<p>
We could copy result into a new object:
@@ -163,7 +159,7 @@
<span class="special">};</span>
</pre>
<p>
- Notice that the data member <tt class="literal">z</tt> is held by class Y using
+ Notice that the data member <code class="literal">z</code> is held by class Y using
a raw pointer. Now we have a potential dangling pointer problem inside Y:
</p>
<pre class="programlisting"><span class="special">>>></span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="preprocessor"># y</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">z</span>
@@ -171,7 +167,7 @@
<span class="special">>>></span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">z_value</span><span class="special">()</span> <span class="preprocessor"># CRASH</span><span class="special">!</span>
</pre>
<p>
- For reference, here's the implementation of <tt class="literal">f</tt> again:
+ For reference, here's the implementation of <code class="literal">f</code> again:
</p>
<pre class="programlisting"><span class="identifier">X</span><span class="special">&</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">)</span>
<span class="special">{</span>
@@ -182,35 +178,38 @@
<p>
Here's what's happening:
</p>
-<div class="orderedlist"><ol type="1">
-<li>
-<tt class="literal">f</tt> is called passing in a reference to <tt class="literal">y</tt>
- and a pointer to <tt class="literal">z</tt>
-</li>
-<li>
- A pointer to <tt class="literal">z</tt> is held by <tt class="literal">y</tt>
-</li>
-<li>
- A reference to <tt class="literal">y.x</tt> is returned
- </li>
-<li>
-<tt class="literal">z</tt> is deleted. <tt class="literal">y.z</tt> is a dangling pointer
- </li>
-<li>
-<tt class="literal">y.z_value()</tt> is called
- </li>
-<li>
-<tt class="literal">z->value()</tt> is called
- </li>
-<li><span class="bold"><b>BOOM!</b></span></li>
+<div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+ <code class="literal">f</code> is called passing in a reference to <code class="literal">y</code>
+ and a pointer to <code class="literal">z</code>
+ </li>
+<li class="listitem">
+ A pointer to <code class="literal">z</code> is held by <code class="literal">y</code>
+ </li>
+<li class="listitem">
+ A reference to <code class="literal">y.x</code> is returned
+ </li>
+<li class="listitem">
+ <code class="literal">z</code> is deleted. <code class="literal">y.z</code> is a dangling
+ pointer
+ </li>
+<li class="listitem">
+ <code class="literal">y.z_value()</code> is called
+ </li>
+<li class="listitem">
+ <code class="literal">z->value()</code> is called
+ </li>
+<li class="listitem">
+ <span class="bold"><strong>BOOM!</strong></span>
+ </li>
</ol></div>
-<a name="call_policies.call_policies"></a><h2>
-<a name="id465291"></a>
+<a name="call_policies.call_policies"></a><h3>
+<a name="id767074"></a>
Call Policies
- </h2>
+ </h3>
<p>
Call Policies may be used in situations such as the example detailed above.
- In our example, <tt class="literal">return_internal_reference</tt> and <tt class="literal">with_custodian_and_ward</tt>
+ In our example, <code class="literal">return_internal_reference</code> and <code class="literal">with_custodian_and_ward</code>
are our friends:
</p>
<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span>
@@ -218,25 +217,25 @@
<span class="identifier">with_custodian_and_ward</span><span class="special"><</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">></span> <span class="special">>());</span>
</pre>
<p>
- What are the <tt class="literal">1</tt> and <tt class="literal">2</tt> parameters, you
+ What are the <code class="literal">1</code> and <code class="literal">2</code> parameters, you
ask?
</p>
<pre class="programlisting"><span class="identifier">return_internal_reference</span><span class="special"><</span><span class="number">1</span>
</pre>
<p>
- Informs Boost.Python that the first argument, in our case <tt class="literal">Y&
- y</tt>, is the owner of the returned reference: <tt class="literal">X&</tt>.
- The "<tt class="literal">1</tt>" simply specifies the first argument.
- In short: "return an internal reference <tt class="literal">X&</tt> owned
- by the 1st argument <tt class="literal">Y& y</tt>".
+ Informs Boost.Python that the first argument, in our case <code class="literal">Y&
+ y</code>, is the owner of the returned reference: <code class="literal">X&</code>.
+ The "<code class="literal">1</code>" simply specifies the first argument.
+ In short: "return an internal reference <code class="literal">X&</code> owned
+ by the 1st argument <code class="literal">Y& y</code>".
</p>
<pre class="programlisting"><span class="identifier">with_custodian_and_ward</span><span class="special"><</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">></span>
</pre>
<p>
Informs Boost.Python that the lifetime of the argument indicated by ward
- (i.e. the 2nd argument: <tt class="literal">Z* z</tt>) is dependent on the lifetime
- of the argument indicated by custodian (i.e. the 1st argument: <tt class="literal">Y&
- y</tt>).
+ (i.e. the 2nd argument: <code class="literal">Z* z</code>) is dependent on the lifetime
+ of the argument indicated by custodian (i.e. the 1st argument: <code class="literal">Y&
+ y</code>).
</p>
<p>
It is also important to note that we have defined two policies above. Two
@@ -250,42 +249,44 @@
Here is the list of predefined call policies. A complete reference detailing
these can be found here.
</p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-<span class="bold"><b>with_custodian_and_ward</b></span>: Ties lifetimes
- of the arguments
- </li>
-<li>
-<span class="bold"><b>with_custodian_and_ward_postcall</b></span>: Ties
- lifetimes of the arguments and results
- </li>
-<li>
-<span class="bold"><b>return_internal_reference</b></span>: Ties lifetime
- of one argument to that of result
- </li>
-<li>
-<span class="bold"><b>return_value_policy<T> with T one of:</b></span><div class="itemizedlist"><ul type="circle">
-<li>
-<span class="bold"><b>reference_existing_object</b></span>: naive (dangerous)
- approach
- </li>
-<li>
-<span class="bold"><b>copy_const_reference</b></span>: Boost.Python
- v1 approach
- </li>
-<li>
-<span class="bold"><b>copy_non_const_reference</b></span>:
- </li>
-<li>
-<span class="bold"><b>manage_new_object</b></span>: Adopt a pointer
- and hold the instance
- </li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ <span class="bold"><strong>with_custodian_and_ward</strong></span>: Ties lifetimes
+ of the arguments
+ </li>
+<li class="listitem">
+ <span class="bold"><strong>with_custodian_and_ward_postcall</strong></span>: Ties
+ lifetimes of the arguments and results
+ </li>
+<li class="listitem">
+ <span class="bold"><strong>return_internal_reference</strong></span>: Ties lifetime
+ of one argument to that of result
+ </li>
+<li class="listitem">
+ <span class="bold"><strong>return_value_policy<T> with T one of:</strong></span>
+ <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+ <span class="bold"><strong>reference_existing_object</strong></span>: naive
+ (dangerous) approach
+ </li>
+<li class="listitem">
+ <span class="bold"><strong>copy_const_reference</strong></span>: Boost.Python
+ v1 approach
+ </li>
+<li class="listitem">
+ <span class="bold"><strong>copy_non_const_reference</strong></span>:
+ </li>
+<li class="listitem">
+ <span class="bold"><strong>manage_new_object</strong></span>: Adopt a pointer
+ and hold the instance
+ </li>
</ul></div>
-</li>
+ </li>
</ul></div>
<div class="sidebar">
+<p class="title"><b></b></p>
<p>
- <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span> <span class="bold"><b>Remember the Zen, Luke:</b></span>
+ <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span> <span class="bold"><strong>Remember the Zen, Luke:</strong></span>
</p>
<p>
"Explicit is better than implicit"
@@ -295,7 +296,7 @@
</p>
</div>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.overloading"></a>Overloading</h3></div></div></div>
<p>
@@ -347,31 +348,31 @@
<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx4</span><span class="special">)</span>
</pre>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.default_arguments"></a>Default Arguments</h3></div></div></div>
<p>
Boost.Python wraps (member) function pointers. Unfortunately, C++ function
- pointers carry no default argument info. Take a function <tt class="literal">f</tt>
+ pointers carry no default argument info. Take a function <code class="literal">f</code>
with default arguments:
</p>
<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span> <span class="special">=</span> <span class="number">3.14</span><span class="special">,</span> <span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="special">=</span> <span class="string">"hello"</span><span class="special">);</span>
</pre>
<p>
- But the type of a pointer to the function <tt class="literal">f</tt> has no information
+ But the type of a pointer to the function <code class="literal">f</code> has no information
about its default arguments:
</p>
<pre class="programlisting"><span class="keyword">int</span><span class="special">(*</span><span class="identifier">g</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span><span class="keyword">double</span><span class="special">,</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*)</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">;</span> <span class="comment">// defaults lost!
</span></pre>
<p>
- When we pass this function pointer to the <tt class="literal">def</tt> function,
+ When we pass this function pointer to the <code class="literal">def</code> function,
there is no way to retrieve the default arguments:
</p>
<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span> <span class="comment">// defaults lost!
</span></pre>
<p>
Because of this, when wrapping C++ code, we had to resort to manual wrapping
- as outlined in the previous section,
+ as outlined in the <a class="link" href="functions.html#python.overloading" title="Overloading">previous section</a>,
or writing thin wrappers:
</p>
<pre class="programlisting"><span class="comment">// write "thin wrappers"
@@ -388,18 +389,18 @@
<p>
When you want to wrap functions (or member functions) that either:
</p>
-<div class="itemizedlist"><ul type="disc">
-<li>
- have default arguments, or
- </li>
-<li>
- are overloaded with a common sequence of initial arguments
- </li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ have default arguments, or
+ </li>
+<li class="listitem">
+ are overloaded with a common sequence of initial arguments
+ </li>
</ul></div>
-<a name="default_arguments.boost_python_function_overloads"></a><h2>
-<a name="id467317"></a>
+<a name="default_arguments.boost_python_function_overloads"></a><h3>
+<a name="id769042"></a>
BOOST_PYTHON_FUNCTION_OVERLOADS
- </h2>
+ </h3>
<p>
Boost.Python now has a way to make it easier. For instance, given a function:
</p>
@@ -415,18 +416,18 @@
</pre>
<p>
will automatically create the thin wrappers for us. This macro will create
- a class <tt class="literal">foo_overloads</tt> that can be passed on to <tt class="literal">def(...)</tt>.
+ a class <code class="literal">foo_overloads</code> that can be passed on to <code class="literal">def(...)</code>.
The third and fourth macro argument are the minimum arguments and maximum
- arguments, respectively. In our <tt class="literal">foo</tt> function the minimum
- number of arguments is 1 and the maximum number of arguments is 4. The <tt class="literal">def(...)</tt>
+ arguments, respectively. In our <code class="literal">foo</code> function the minimum
+ number of arguments is 1 and the maximum number of arguments is 4. The <code class="literal">def(...)</code>
function will automatically add all the foo variants for us:
</p>
<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
</pre>
-<a name="default_arguments.boost_python_member_function_overloads"></a><h2>
-<a name="id467632"></a>
+<a name="default_arguments.boost_python_member_function_overloads"></a><h3>
+<a name="id769301"></a>
BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS
- </h2>
+ </h3>
<p>
Objects here, objects there, objects here there everywhere. More frequently
than anything else, we need to expose member functions of our classes to
@@ -435,7 +436,7 @@
play. Another macro is provided to make this a breeze.
</p>
<p>
- Like <tt class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</tt>, <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt>
+ Like <code class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</code>, <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code>
may be used to automatically create the thin wrappers for wrapping member
functions. Let's have an example:
</p>
@@ -454,11 +455,11 @@
<pre class="programlisting"><span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">george_overloads</span><span class="special">,</span> <span class="identifier">wack_em</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
</pre>
<p>
- will generate a set of thin wrappers for george's <tt class="literal">wack_em</tt>
+ will generate a set of thin wrappers for george's <code class="literal">wack_em</code>
member function accepting a minimum of 1 and a maximum of 3 arguments (i.e.
the third and fourth macro argument). The thin wrappers are all enclosed
- in a class named <tt class="literal">george_overloads</tt> that can then be used
- as an argument to <tt class="literal">def(...)</tt>:
+ in a class named <code class="literal">george_overloads</code> that can then be used
+ as an argument to <code class="literal">def(...)</code>:
</p>
<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"wack_em"</span><span class="special">,</span> <span class="special">&</span><span class="identifier">george</span><span class="special">::</span><span class="identifier">wack_em</span><span class="special">,</span> <span class="identifier">george_overloads</span><span class="special">());</span>
</pre>
@@ -466,13 +467,13 @@
See the <a href="../../../../v2/overloads.html#BOOST_PYTHON_FUNCTION_OVERLOADS-spec" target="_top">overloads
reference</a> for details.
</p>
-<a name="default_arguments.init_and_optional"></a><h2>
-<a name="id467992"></a>
+<a name="default_arguments.init_and_optional"></a><h3>
+<a name="id769596"></a>
init and optional
- </h2>
+ </h3>
<p>
A similar facility is provided for class constructors, again, with default
- arguments or a sequence of overloads. Remember <tt class="literal">init<...></tt>?
+ arguments or a sequence of overloads. Remember <code class="literal">init<...></code>?
For example, given a class X with a constructor:
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">X</span>
@@ -487,16 +488,16 @@
<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">init</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">optional</span><span class="special"><</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span> <span class="special">>())</span>
</pre>
<p>
- Notice the use of <tt class="literal">init<...></tt> and <tt class="literal">optional<...></tt>
+ Notice the use of <code class="literal">init<...></code> and <code class="literal">optional<...></code>
to signify the default (optional arguments).
</p>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.auto_overloading"></a>Auto-Overloading</h3></div></div></div>
<p>
- It was mentioned in passing in the previous section that <tt class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</tt>
- and <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt> can also be
+ It was mentioned in passing in the previous section that <code class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</code>
+ and <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code> can also be
used for overloaded functions and member functions with a common sequence
of initial arguments. Here is an example:
</p>
@@ -535,24 +536,24 @@
Notice though that we have a situation now where we have a minimum of zero
(0) arguments and a maximum of 3 arguments.
</p>
-<a name="auto_overloading.manual_wrapping"></a><h2>
-<a name="id468767"></a>
+<a name="auto_overloading.manual_wrapping"></a><h3>
+<a name="id770226"></a>
Manual Wrapping
- </h2>
+ </h3>
<p>
- It is important to emphasize however that <span class="bold"><b>the overloaded
- functions must have a common sequence of initial arguments</b></span>. Otherwise,
+ It is important to emphasize however that <span class="bold"><strong>the overloaded
+ functions must have a common sequence of initial arguments</strong></span>. Otherwise,
our scheme above will not work. If this is not the case, we have to wrap
- our functions manually.
+ our functions <a class="link" href="functions.html#python.overloading" title="Overloading">manually</a>.
</p>
<p>
Actually, we can mix and match manual wrapping of overloaded functions and
- automatic wrapping through <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt>
- and its sister, <tt class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</tt>. Following
- up on our example presented in the section <a href="functions.html#python.overloading" title="Overloading">on
+ automatic wrapping through <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code>
+ and its sister, <code class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</code>. Following
+ up on our example presented in the section <a class="link" href="functions.html#python.overloading" title="Overloading">on
overloading</a>, since the first 4 overload functins have a common sequence
- of initial arguments, we can use <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt>
- to automatically wrap the first three of the <tt class="literal">def</tt>s and
+ of initial arguments, we can use <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code>
+ to automatically wrap the first three of the <code class="literal">def</code>s and
manually wrap just the last. Here's how we'll do this:
</p>
<pre class="programlisting"><span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">xf_overloads</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
@@ -573,7 +574,7 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
de Guzman, David Abrahams<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
@@ -583,7 +584,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="exposing.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="object.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="exposing.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="object.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
Modified: trunk/libs/python/doc/tutorial/doc/html/python/hello.html
==============================================================================
--- trunk/libs/python/doc/tutorial/doc/html/python/hello.html (original)
+++ trunk/libs/python/doc/tutorial/doc/html/python/hello.html 2010-07-01 18:13:45 EDT (Thu, 01 Jul 2010)
@@ -1,13 +1,13 @@
<html>
<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Building Hello World</title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="prev" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="next" href="exposing.html" title=" Exposing Classes">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Building Hello World</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../index.html" title="Chapter 1. python 2.0">
+<link rel="up" href="../index.html" title="Chapter 1. python 2.0">
+<link rel="prev" href="../index.html" title="Chapter 1. python 2.0">
+<link rel="next" href="exposing.html" title="Exposing Classes">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@@ -20,34 +20,34 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="../index.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="../index.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="python.hello"></a> Building Hello World</h2></div></div></div>
-<a name="hello.from_start_to_finish"></a><h2>
-<a name="id388718"></a>
+<a name="hello.from_start_to_finish"></a><h3>
+<a name="id760024"></a>
From Start To Finish
- </h2>
+ </h3>
<p>
Now the first thing you'd want to do is to build the Hello World module and
try it for yourself in Python. In this section, we will outline the steps necessary
to achieve that. We will use the build tool that comes bundled with every boost
- distribution: <span class="bold"><b>bjam</b></span>.
+ distribution: <span class="bold"><strong>bjam</strong></span>.
</p>
<div class="note"><table border="0" summary="Note">
<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
-<tr><td colspan="2" align="left" valign="top">
+<tr><td align="left" valign="top">
<p>
- <span class="bold"><b>Building without bjam</b></span>
+ <span class="bold"><strong>Building without bjam</strong></span>
</p>
<p>
Besides bjam, there are of course other ways to get your module built. What's
written here should not be taken as "the one and only way". There
- are of course other build tools apart from <tt class="literal">bjam</tt>.
+ are of course other build tools apart from <code class="literal">bjam</code>.
</p>
<p>
Take note however that the preferred build tool for Boost.Python is bjam.
@@ -65,65 +65,59 @@
and run a python program using the extension.
</p>
<p>
- The tutorial example can be found in the directory: <tt class="literal">libs/python/example/tutorial</tt>.
+ The tutorial example can be found in the directory: <code class="literal">libs/python/example/tutorial</code>.
There, you can find:
</p>
-<div class="itemizedlist"><ul type="disc">
-<li>
- hello.cpp
- </li>
-<li>
- hello.py
- </li>
-<li>
- Jamroot
- </li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ hello.cpp
+ </li>
+<li class="listitem">
+ hello.py
+ </li>
+<li class="listitem">
+ Jamroot
+ </li>
</ul></div>
<p>
- The <tt class="literal">hello.cpp</tt> file is our C++ hello world example. The
- <tt class="literal">Jamroot</tt> is a minimalist <span class="emphasis"><em>bjam</em></span> script
- that builds the DLLs for us. Finally, <tt class="literal">hello.py</tt> is our Python
- program that uses the extension in <tt class="literal">hello.cpp</tt>.
+ The <code class="literal">hello.cpp</code> file is our C++ hello world example. The
+ <code class="literal">Jamroot</code> is a minimalist <span class="emphasis"><em>bjam</em></span> script
+ that builds the DLLs for us. Finally, <code class="literal">hello.py</code> is our Python
+ program that uses the extension in <code class="literal">hello.cpp</code>.
</p>
<p>
Before anything else, you should have the bjam executable in your boost directory
- or somewhere in your path such that <tt class="literal">bjam</tt> can be executed
+ or somewhere in your path such that <code class="literal">bjam</code> can be executed
in the command line. Pre-built Boost.Jam executables are available for most
platforms. The complete list of Bjam executables can be found here.
</p>
-<a name="hello.let_s_jam_"></a><h2>
-<a name="id387300"></a>
+<a name="hello.let_s_jam_"></a><h3>
+<a name="id760177"></a>
Let's Jam!
- </h2>
+ </h3>
<p>
<span class="inlinemediaobject"><img src="../images/jam.png" alt="jam"></span>
</p>
<p>
<a href="../../../../../example/tutorial/Jamroot" target="_top">Here</a> is our minimalist
- Jamroot file. Simply copy the file and tweak <tt class="literal">use-project boost</tt>
+ Jamroot file. Simply copy the file and tweak <code class="literal">use-project boost</code>
to where your boost root directory is and your OK.
</p>
<p>
The comments contained in the Jamrules file above should be sufficient to get
you going.
</p>
-<a name="hello.running_bjam"></a><h2>
-<a name="id387357"></a>
+<a name="hello.running_bjam"></a><h3>
+<a name="id760225"></a>
Running bjam
- </h2>
+ </h3>
<p>
<span class="emphasis"><em>bjam</em></span> is run using your operating system's command line
interpreter.
</p>
-<div class="blockquote"><blockquote class="blockquote">
-<p>
- </p>
-<p>
- Start it up.
- </p>
-<p>
- </p>
-</blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ Start it up.
+ </p></blockquote></div>
<p>
A file called user-config.jam in your home directory is used to configure your
tools. In Windows, your home directory can be found by typing:
@@ -144,13 +138,13 @@
<p>
The first rule tells Bjam to use the MSVC 8.0 compiler and associated tools.
The second rule provides information on Python, its version and where it is
- located. The above assumes that the Python installation is in <tt class="literal">C:/dev/tools/Python/</tt>.
+ located. The above assumes that the Python installation is in <code class="literal">C:/dev/tools/Python/</code>.
If you have one fairly "standard" python installation for your platform,
you might not need to do this.
</p>
<p>
- Now we are ready... Be sure to <tt class="literal">cd</tt> to <tt class="literal">libs/python/example/tutorial</tt>
- where the tutorial <tt class="literal">"hello.cpp"</tt> and the <tt class="literal">"Jamroot"</tt>
+ Now we are ready... Be sure to <code class="literal">cd</code> to <code class="literal">libs/python/example/tutorial</code>
+ where the tutorial <code class="literal">"hello.cpp"</code> and the <code class="literal">"Jamroot"</code>
is situated.
</p>
<p>
@@ -179,30 +173,13 @@
Or something similar. If all is well, you should now have built the DLLs and
run the Python program.
</p>
-<div class="note"><table border="0" summary="Note">
-<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
-<th align="left">Note</th>
-</tr>
-<tr><td colspan="2" align="left" valign="top"><p>
- Starting from Boost 1.35, bjam erases the generated executables (e.g. pyd
- file) after the test has concluded to conserve disk space. To keep bjam from
- doing that, pass --preserve-test-targets to bjam.
- </p></td></tr>
-</table></div>
-<div class="blockquote"><blockquote class="blockquote">
-<p>
- </p>
-<p>
- <span class="bold"><b>There you go... Have fun!</b></span>
- </p>
-<p>
- </p>
-</blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <span class="bold"><strong>There you go... Have fun!</strong></span>
+ </p></blockquote></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
de Guzman, David Abrahams<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
@@ -212,7 +189,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="../index.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="../index.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
Modified: trunk/libs/python/doc/tutorial/doc/html/python/iterators.html
==============================================================================
--- trunk/libs/python/doc/tutorial/doc/html/python/iterators.html (original)
+++ trunk/libs/python/doc/tutorial/doc/html/python/iterators.html 2010-07-01 18:13:45 EDT (Thu, 01 Jul 2010)
@@ -1,13 +1,13 @@
<html>
<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Iterators</title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../index.html" title="Chapter 1. python 2.0">
+<link rel="up" href="../index.html" title="Chapter 1. python 2.0">
<link rel="prev" href="embedding.html" title="Embedding">
-<link rel="next" href="exception.html" title=" Exception Translation">
+<link rel="next" href="exception.html" title="Exception Translation">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@@ -20,9 +20,9 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="embedding.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="exception.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="embedding.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exception.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="python.iterators"></a>Iterators</h2></div></div></div>
<p>
@@ -30,37 +30,37 @@
iterators, but these are two very different beasts.
</p>
<p>
- <span class="bold"><b>C++ iterators:</b></span>
+ <span class="bold"><strong>C++ iterators:</strong></span>
</p>
-<div class="itemizedlist"><ul type="disc">
-<li>
- C++ has 5 type categories (random-access, bidirectional, forward, input,
- output)
- </li>
-<li>
- There are 2 Operation categories: reposition, access
- </li>
-<li>
- A pair of iterators is needed to represent a (first/last) range.
- </li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ C++ has 5 type categories (random-access, bidirectional, forward, input,
+ output)
+ </li>
+<li class="listitem">
+ There are 2 Operation categories: reposition, access
+ </li>
+<li class="listitem">
+ A pair of iterators is needed to represent a (first/last) range.
+ </li>
</ul></div>
<p>
- <span class="bold"><b>Python Iterators:</b></span>
+ <span class="bold"><strong>Python Iterators:</strong></span>
</p>
-<div class="itemizedlist"><ul type="disc">
-<li>
- 1 category (forward)
- </li>
-<li>
- 1 operation category (next())
- </li>
-<li>
- Raises StopIteration exception at end
- </li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ 1 category (forward)
+ </li>
+<li class="listitem">
+ 1 operation category (next())
+ </li>
+<li class="listitem">
+ Raises StopIteration exception at end
+ </li>
</ul></div>
<p>
- The typical Python iteration protocol: <tt class="literal"><span class="bold"><b>for y
- in x...</b></span></tt> is as follows:
+ The typical Python iteration protocol: <code class="literal"><span class="bold"><strong>for y
+ in x...</strong></span></code> is as follows:
</p>
<p>
</p>
@@ -73,7 +73,7 @@
</span></pre>
<p>
Boost.Python provides some mechanisms to make C++ iterators play along nicely
- as Python iterators. What we need to do is to produce appropriate <tt class="computeroutput"><span class="identifier">__iter__</span></tt> function from C++ iterators that
+ as Python iterators. What we need to do is to produce appropriate <code class="computeroutput"><span class="identifier">__iter__</span></code> function from C++ iterators that
is compatible with the Python iteration protocol. For example:
</p>
<p>
@@ -88,42 +88,42 @@
<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"__iter__"</span><span class="special">,</span> <span class="identifier">iterator</span><span class="special"><</span><span class="identifier">vector</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span> <span class="special">>())</span>
</pre>
<p>
- <span class="bold"><b>range</b></span>
+ <span class="bold"><strong>range</strong></span>
</p>
<p>
We can create a Python savvy iterator using the range function:
</p>
-<div class="itemizedlist"><ul type="disc">
-<li>
- range(start, finish)
- </li>
-<li>
- range<Policies,Target>(start, finish)
- </li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ range(start, finish)
+ </li>
+<li class="listitem">
+ range<Policies,Target>(start, finish)
+ </li>
</ul></div>
<p>
Here, start/finish may be one of:
</p>
-<div class="itemizedlist"><ul type="disc">
-<li>
- member data pointers
- </li>
-<li>
- member function pointers
- </li>
-<li>
- adaptable function object (use Target parameter)
- </li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ member data pointers
+ </li>
+<li class="listitem">
+ member function pointers
+ </li>
+<li class="listitem">
+ adaptable function object (use Target parameter)
+ </li>
</ul></div>
<p>
- <span class="bold"><b>iterator</b></span>
+ <span class="bold"><strong>iterator</strong></span>
</p>
-<div class="itemizedlist"><ul type="disc"><li>
- iterator<T, Policies>()
- </li></ul></div>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+ iterator<T, Policies>()
+ </li></ul></div>
<p>
- Given a container <tt class="literal">T</tt>, iterator is a shortcut that simply
- calls <tt class="literal">range</tt> with &T::begin, &T::end.
+ Given a container <code class="literal">T</code>, iterator is a shortcut that simply
+ calls <code class="literal">range</code> with &T::begin, &T::end.
</p>
<p>
Let's put this into action... Here's an example from some hypothetical bogon
@@ -147,14 +147,14 @@
<span class="special">.</span><span class="identifier">property</span><span class="special">(</span><span class="string">"bogons"</span><span class="special">,</span> <span class="identifier">range</span><span class="special">(&</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">b_begin</span><span class="special">,</span> <span class="special">&</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">b_end</span><span class="special">));</span>
</pre>
<p>
- <span class="bold"><b>stl_input_iterator</b></span>
+ <span class="bold"><strong>stl_input_iterator</strong></span>
</p>
<p>
So far, we have seen how to expose C++ iterators and ranges to Python. Sometimes
we wish to go the other way, though: we'd like to pass a Python sequence to
an STL algorithm or use it to initialize an STL container. We need to make
- a Python iterator look like an STL iterator. For that, we use <tt class="computeroutput"><span class="identifier">stl_input_iterator</span><span class="special"><></span></tt>.
- Consider how we might implement a function that exposes <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">assign</span><span class="special">()</span></tt> to Python:
+ a Python iterator look like an STL iterator. For that, we use <code class="computeroutput"><span class="identifier">stl_input_iterator</span><span class="special"><></span></code>.
+ Consider how we might implement a function that exposes <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special"><</span><span class="keyword">int</span><span class="special">>::</span><span class="identifier">assign</span><span class="special">()</span></code> to Python:
</p>
<p>
</p>
@@ -172,7 +172,7 @@
</span> <span class="special">;</span>
</pre>
<p>
- Now in Python, we can assign any integer sequence to <tt class="computeroutput"><span class="identifier">list_int</span></tt>
+ Now in Python, we can assign any integer sequence to <code class="computeroutput"><span class="identifier">list_int</span></code>
objects:
</p>
<p>
@@ -183,7 +183,7 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
de Guzman, David Abrahams<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
@@ -193,7 +193,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="embedding.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="exception.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="embedding.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exception.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
Modified: trunk/libs/python/doc/tutorial/doc/html/python/object.html
==============================================================================
--- trunk/libs/python/doc/tutorial/doc/html/python/object.html (original)
+++ trunk/libs/python/doc/tutorial/doc/html/python/object.html 2010-07-01 18:13:45 EDT (Thu, 01 Jul 2010)
@@ -1,11 +1,11 @@
<html>
<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Object Interface</title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Object Interface</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../index.html" title="Chapter 1. python 2.0">
+<link rel="up" href="../index.html" title="Chapter 1. python 2.0">
<link rel="prev" href="functions.html" title="Functions">
<link rel="next" href="embedding.html" title="Embedding">
</head>
@@ -20,9 +20,9 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="python.object"></a> Object Interface</h2></div></div></div>
<div class="toc"><dl>
@@ -35,26 +35,26 @@
Python is dynamically typed, unlike C++ which is statically typed. Python variables
may hold an integer, a float, list, dict, tuple, str, long etc., among other
things. In the viewpoint of Boost.Python and C++, these Pythonic variables
- are just instances of class <tt class="literal">object</tt>. We will see in this
+ are just instances of class <code class="literal">object</code>. We will see in this
chapter how to deal with Python objects.
</p>
<p>
As mentioned, one of the goals of Boost.Python is to provide a bidirectional
mapping between C++ and Python while maintaining the Python feel. Boost.Python
- C++ <tt class="literal">object</tt>s are as close as possible to Python. This should
+ C++ <code class="literal">object</code>s are as close as possible to Python. This should
minimize the learning curve significantly.
</p>
<p>
<span class="inlinemediaobject"><img src="../images/python.png" alt="python"></span>
</p>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.basic_interface"></a>Basic Interface</h3></div></div></div>
<p>
- Class <tt class="literal">object</tt> wraps <tt class="literal">PyObject*</tt>. All the
- intricacies of dealing with <tt class="literal">PyObject</tt>s such as managing
- reference counting are handled by the <tt class="literal">object</tt> class. C++
- object interoperability is seamless. Boost.Python C++ <tt class="literal">object</tt>s
+ Class <code class="literal">object</code> wraps <code class="literal">PyObject*</code>. All the
+ intricacies of dealing with <code class="literal">PyObject</code>s such as managing
+ reference counting are handled by the <code class="literal">object</code> class. C++
+ object interoperability is seamless. Boost.Python C++ <code class="literal">object</code>s
can in fact be explicitly constructed from any C++ object.
</p>
<p>
@@ -93,57 +93,57 @@
in C++, the look and feel should be immediately apparent to the Python coder.
</p>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.derived_object_types"></a>Derived Object types</h3></div></div></div>
<p>
- Boost.Python comes with a set of derived <tt class="literal">object</tt> types
+ Boost.Python comes with a set of derived <code class="literal">object</code> types
corresponding to that of Python's:
</p>
-<div class="itemizedlist"><ul type="disc">
-<li>
- list
- </li>
-<li>
- dict
- </li>
-<li>
- tuple
- </li>
-<li>
- str
- </li>
-<li>
- long_
- </li>
-<li>
- enum
- </li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ list
+ </li>
+<li class="listitem">
+ dict
+ </li>
+<li class="listitem">
+ tuple
+ </li>
+<li class="listitem">
+ str
+ </li>
+<li class="listitem">
+ long_
+ </li>
+<li class="listitem">
+ enum
+ </li>
</ul></div>
<p>
- These derived <tt class="literal">object</tt> types act like real Python types.
+ These derived <code class="literal">object</code> types act like real Python types.
For instance:
</p>
<pre class="programlisting"><span class="identifier">str</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">==></span> <span class="string">"1"</span>
</pre>
<p>
- Wherever appropriate, a particular derived <tt class="literal">object</tt> has
- corresponding Python type's methods. For instance, <tt class="literal">dict</tt>
- has a <tt class="literal">keys()</tt> method:
+ Wherever appropriate, a particular derived <code class="literal">object</code> has
+ corresponding Python type's methods. For instance, <code class="literal">dict</code>
+ has a <code class="literal">keys()</code> method:
</p>
<pre class="programlisting"><span class="identifier">d</span><span class="special">.</span><span class="identifier">keys</span><span class="special">()</span>
</pre>
<p>
- <tt class="literal">make_tuple</tt> is provided for declaring <span class="emphasis"><em>tuple literals</em></span>.
+ <code class="literal">make_tuple</code> is provided for declaring <span class="emphasis"><em>tuple literals</em></span>.
Example:
</p>
<pre class="programlisting"><span class="identifier">make_tuple</span><span class="special">(</span><span class="number">123</span><span class="special">,</span> <span class="char">'D'</span><span class="special">,</span> <span class="string">"Hello, World"</span><span class="special">,</span> <span class="number">0.0</span><span class="special">);</span>
</pre>
<p>
- In C++, when Boost.Python <tt class="literal">object</tt>s are used as arguments
+ In C++, when Boost.Python <code class="literal">object</code>s are used as arguments
to functions, subtype matching is required. For example, when a function
- <tt class="literal">f</tt>, as declared below, is wrapped, it will only accept
- instances of Python's <tt class="literal">str</tt> type and subtypes.
+ <code class="literal">f</code>, as declared below, is wrapped, it will only accept
+ instances of Python's <code class="literal">str</code> type and subtypes.
</p>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
<span class="special">{</span>
@@ -164,15 +164,18 @@
<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">msg</span> <span class="special">=</span> <span class="string">"%s is bigger than %s"</span> <span class="special">%</span> <span class="identifier">make_tuple</span><span class="special">(</span><span class="identifier">NAME</span><span class="special">,</span><span class="identifier">name</span><span class="special">);</span>
</pre>
<p>
- Demonstrates that you can write the C++ equivalent of <tt class="literal">"format"
- % x,y,z</tt> in Python, which is useful since there's no easy way to
+ Demonstrates that you can write the C++ equivalent of <code class="literal">"format"
+ % x,y,z</code> in Python, which is useful since there's no easy way to
do that in std C++.
</p>
-<div class="sidebar"><p>
- <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><b>Beware</b></span> the common pitfall
+<div class="sidebar">
+<p class="title"><b></b></p>
+<p>
+ <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><strong>Beware</strong></span> the common pitfall
of forgetting that the constructors of most of Python's mutable types make
copies, just as in Python.
- </p></div>
+ </p>
+</div>
<p>
Python:
</p>
@@ -185,12 +188,12 @@
<pre class="programlisting"><span class="identifier">dict</span> <span class="identifier">d</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span> <span class="comment">// copies x.__dict__
</span><span class="identifier">d</span><span class="special">[</span><span class="char">'whatever'</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span> <span class="comment">// modifies the copy
</span></pre>
-<a name="derived_object_types.class__lt_t_gt__as_objects"></a><h2>
-<a name="id470756"></a>
+<a name="derived_object_types.class__lt_t_gt__as_objects"></a><h3>
+<a name="id771905"></a>
class_<T> as objects
- </h2>
+ </h3>
<p>
- Due to the dynamic nature of Boost.Python objects, any <tt class="literal">class_<T></tt>
+ Due to the dynamic nature of Boost.Python objects, any <code class="literal">class_<T></code>
may also be one of these types! The following code snippet wraps the class
(type) object.
</p>
@@ -206,19 +209,19 @@
<span class="identifier">assert</span><span class="special">(</span><span class="identifier">vec345</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">)</span> <span class="special">==</span> <span class="number">5.0</span><span class="special">);</span>
</pre>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.extracting_c___objects"></a>Extracting C++ objects</h3></div></div></div>
<p>
At some point, we will need to get C++ values out of object instances. This
- can be achieved with the <tt class="literal">extract<T></tt> function. Consider
+ can be achieved with the <code class="literal">extract<T></code> function. Consider
the following:
</p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">);</span> <span class="comment">// compile error
</span></pre>
<p>
- In the code above, we got a compiler error because Boost.Python <tt class="literal">object</tt>
- can't be implicitly converted to <tt class="literal">double</tt>s. Instead, what
+ In the code above, we got a compiler error because Boost.Python <code class="literal">object</code>
+ can't be implicitly converted to <code class="literal">double</code>s. Instead, what
we wanted to do above can be achieved by writing:
</p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">l</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special"><</span><span class="keyword">double</span><span class="special">>(</span><span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">));</span>
@@ -227,14 +230,14 @@
</pre>
<p>
The first line attempts to extract the "length" attribute of the
- Boost.Python <tt class="literal">object</tt>. The second line attempts to <span class="emphasis"><em>extract</em></span>
- the <tt class="literal">Vec2</tt> object from held by the Boost.Python <tt class="literal">object</tt>.
+ Boost.Python <code class="literal">object</code>. The second line attempts to <span class="emphasis"><em>extract</em></span>
+ the <code class="literal">Vec2</code> object from held by the Boost.Python <code class="literal">object</code>.
</p>
<p>
Take note that we said "attempt to" above. What if the Boost.Python
- <tt class="literal">object</tt> does not really hold a <tt class="literal">Vec2</tt>
+ <code class="literal">object</code> does not really hold a <code class="literal">Vec2</code>
type? This is certainly a possibility considering the dynamic nature of Python
- <tt class="literal">object</tt>s. To be on the safe side, if the C++ type can't
+ <code class="literal">object</code>s. To be on the safe side, if the C++ type can't
be extracted, an appropriate exception is thrown. To avoid an exception,
we need to test for extractibility:
</p>
@@ -243,20 +246,20 @@
<span class="identifier">Vec2</span><span class="special">&</span> <span class="identifier">v</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">();</span> <span class="special">...</span>
</pre>
<p>
- <span class="inlinemediaobject"><img src="../images/tip.png" alt="tip"></span> The astute reader might have noticed that the <tt class="literal">extract<T></tt>
+ <span class="inlinemediaobject"><img src="../images/tip.png" alt="tip"></span> The astute reader might have noticed that the <code class="literal">extract<T></code>
facility in fact solves the mutable copying problem:
</p>
<pre class="programlisting"><span class="identifier">dict</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special"><</span><span class="identifier">dict</span><span class="special">>(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>
<span class="identifier">d</span><span class="special">[</span><span class="string">"whatever"</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span> <span class="comment">// modifies x.__dict__ !
</span></pre>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.enums"></a>Enums</h3></div></div></div>
<p>
Boost.Python has a nifty facility to capture and wrap C++ enums. While Python
- has no <tt class="literal">enum</tt> type, we'll often want to expose our C++ enums
- to Python as an <tt class="literal">int</tt>. Boost.Python's enum facility makes
+ has no <code class="literal">enum</code> type, we'll often want to expose our C++ enums
+ to Python as an <code class="literal">int</code>. Boost.Python's enum facility makes
this easy while taking care of the proper conversions from Python's dynamic
typing to C++'s strong static typing (in C++, ints cannot be implicitly converted
to enums). To illustrate, given a C++ enum:
@@ -273,18 +276,18 @@
</pre>
<p>
can be used to expose to Python. The new enum type is created in the current
- <tt class="literal">scope()</tt>, which is usually the current module. The snippet
- above creates a Python class derived from Python's <tt class="literal">int</tt>
+ <code class="literal">scope()</code>, which is usually the current module. The snippet
+ above creates a Python class derived from Python's <code class="literal">int</code>
type which is associated with the C++ type passed as its first parameter.
</p>
<div class="note"><table border="0" summary="Note">
<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
-<tr><td colspan="2" align="left" valign="top">
+<tr><td align="left" valign="top">
<p>
- <span class="bold"><b>what is a scope?</b></span>
+ <span class="bold"><strong>what is a scope?</strong></span>
</p>
<p>
The scope is a class that has an associated global Python object which
@@ -322,7 +325,7 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
de Guzman, David Abrahams<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
@@ -332,7 +335,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
Modified: trunk/libs/python/doc/tutorial/doc/html/python/techniques.html
==============================================================================
--- trunk/libs/python/doc/tutorial/doc/html/python/techniques.html (original)
+++ trunk/libs/python/doc/tutorial/doc/html/python/techniques.html 2010-07-01 18:13:45 EDT (Thu, 01 Jul 2010)
@@ -1,12 +1,12 @@
<html>
<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> General Techniques</title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="prev" href="exception.html" title=" Exception Translation">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>General Techniques</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../index.html" title="Chapter 1. python 2.0">
+<link rel="up" href="../index.html" title="Chapter 1. python 2.0">
+<link rel="prev" href="exception.html" title="Exception Translation">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@@ -19,9 +19,9 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="exception.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a>
+<a accesskey="p" href="exception.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="python.techniques"></a> General Techniques</h2></div></div></div>
<div class="toc"><dl>
@@ -33,7 +33,7 @@
Here are presented some useful techniques that you can use while wrapping code
with Boost.Python.
</p>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.creating_packages"></a>Creating Packages</h3></div></div></div>
<p>
@@ -50,7 +50,7 @@
<p>
We have a C++ library that works with sounds: reading and writing various
formats, applying filters to the sound data, etc. It is named (conveniently)
- <tt class="literal">sounds</tt>. Our library already has a neat C++ namespace hierarchy,
+ <code class="literal">sounds</code>. Our library already has a neat C++ namespace hierarchy,
like so:
</p>
<pre class="programlisting"><span class="identifier">sounds</span><span class="special">::</span><span class="identifier">core</span>
@@ -90,18 +90,18 @@
<span class="special">}</span>
</pre>
<p>
- Compiling these files will generate the following Python extensions: <tt class="literal">core.pyd</tt>,
- <tt class="literal">io.pyd</tt> and <tt class="literal">filters.pyd</tt>.
+ Compiling these files will generate the following Python extensions: <code class="literal">core.pyd</code>,
+ <code class="literal">io.pyd</code> and <code class="literal">filters.pyd</code>.
</p>
<div class="note"><table border="0" summary="Note">
<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
-<tr><td colspan="2" align="left" valign="top"><p>
- The extension <tt class="literal">.pyd</tt> is used for python extension modules,
+<tr><td align="left" valign="top"><p>
+ The extension <code class="literal">.pyd</code> is used for python extension modules,
which are just shared libraries. Using the default for your system, like
- <tt class="literal">.so</tt> for Unix and <tt class="literal">.dll</tt> for Windows,
+ <code class="literal">.so</code> for Unix and <code class="literal">.dll</code> for Windows,
works just as well.
</p></td></tr>
</table></div>
@@ -115,12 +115,12 @@
io.pyd
</pre>
<p>
- The file <tt class="literal">__init__.py</tt> is what tells Python that the directory
- <tt class="literal">sounds/</tt> is actually a Python package. It can be a empty
+ The file <code class="literal">__init__.py</code> is what tells Python that the directory
+ <code class="literal">sounds/</code> is actually a Python package. It can be a empty
file, but can also perform some magic, that will be shown later.
</p>
<p>
- Now our package is ready. All the user has to do is put <tt class="literal">sounds</tt>
+ Now our package is ready. All the user has to do is put <code class="literal">sounds</code>
into his PYTHONPATH
and fire up the interpreter:
</p>
@@ -157,7 +157,7 @@
</pre>
<p>
Note that we added an underscore to the module name. The filename will have
- to be changed to <tt class="literal">_core.pyd</tt> as well, and we do the same
+ to be changed to <code class="literal">_core.pyd</code> as well, and we do the same
to the other extension modules. Now, we change our package hierarchy like
so:
</p>
@@ -184,11 +184,11 @@
<span class="special">>>></span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span><span class="special">.</span><span class="identifier">foo</span><span class="special">(...)</span>
</pre>
<p>
- which is not what we want. But here enters the <tt class="literal">__init__.py</tt>
- magic: everything that is brought to the <tt class="literal">__init__.py</tt> namespace
+ which is not what we want. But here enters the <code class="literal">__init__.py</code>
+ magic: everything that is brought to the <code class="literal">__init__.py</code> namespace
can be accessed directly by the user. So, all we have to do is bring the
- entire namespace from <tt class="literal">_core.pyd</tt> to <tt class="literal">core/__init__.py</tt>.
- So add this line of code to <tt class="literal">sounds<span class="emphasis"><em>core</em></span>__init__.py</tt>:
+ entire namespace from <code class="literal">_core.pyd</code> to <code class="literal">core/__init__.py</code>.
+ So add this line of code to <code class="literal">sounds<span class="emphasis"><em>core</em></span>__init__.py</code>:
</p>
<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">_core</span> <span class="keyword">import</span> <span class="special">*</span>
</pre>
@@ -203,10 +203,10 @@
with the additional benefit that we can easily add pure Python functions
to any module, in a way that the user can't tell the difference between a
C++ function and a Python function. Let's add a <span class="emphasis"><em>pure</em></span>
- Python function, <tt class="literal">echo_noise</tt>, to the <tt class="literal">filters</tt>
- package. This function applies both the <tt class="literal">echo</tt> and <tt class="literal">noise</tt>
- filters in sequence in the given <tt class="literal">sound</tt> object. We create
- a file named <tt class="literal">sounds/filters/echo_noise.py</tt> and code our
+ Python function, <code class="literal">echo_noise</code>, to the <code class="literal">filters</code>
+ package. This function applies both the <code class="literal">echo</code> and <code class="literal">noise</code>
+ filters in sequence in the given <code class="literal">sound</code> object. We create
+ a file named <code class="literal">sounds/filters/echo_noise.py</code> and code our
function:
</p>
<pre class="programlisting"><span class="keyword">import</span> <span class="identifier">_filters</span>
@@ -216,19 +216,19 @@
<span class="keyword">return</span> <span class="identifier">s</span>
</pre>
<p>
- Next, we add this line to <tt class="literal">sounds<span class="emphasis"><em>filters</em></span>__init__.py</tt>:
+ Next, we add this line to <code class="literal">sounds<span class="emphasis"><em>filters</em></span>__init__.py</code>:
</p>
<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">echo_noise</span> <span class="keyword">import</span> <span class="identifier">echo_noise</span>
</pre>
<p>
And that's it. The user now accesses this function like any other function
- from the <tt class="literal">filters</tt> package:
+ from the <code class="literal">filters</code> package:
</p>
<pre class="programlisting"><span class="special">>>></span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
<span class="special">>>></span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo_noise</span><span class="special">(...)</span>
</pre>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.extending_wrapped_objects_in_python"></a>Extending Wrapped Objects in Python</h3></div></div></div>
<p>
@@ -254,7 +254,7 @@
</p>
<p>
We can do the same with classes that were wrapped with Boost.Python. Suppose
- we have a class <tt class="literal">point</tt> in C++:
+ we have a class <code class="literal">point</code> in C++:
</p>
<p>
</p>
@@ -266,8 +266,8 @@
<span class="special">}</span>
</pre>
<p>
- If we are using the technique from the previous session, <a href="techniques.html#python.creating_packages" title="Creating Packages">Creating
- Packages</a>, we can code directly into <tt class="literal">geom/__init__.py</tt>:
+ If we are using the technique from the previous session, <a class="link" href="techniques.html#python.creating_packages" title="Creating Packages">Creating
+ Packages</a>, we can code directly into <code class="literal">geom/__init__.py</code>:
</p>
<p>
</p>
@@ -281,23 +281,23 @@
</span><span class="identifier">point</span><span class="special">.</span><span class="identifier">__str__</span> <span class="special">=</span> <span class="identifier">point_str</span>
</pre>
<p>
- <span class="bold"><b>All</b></span> point instances created from C++ will
+ <span class="bold"><strong>All</strong></span> point instances created from C++ will
also have this member function! This technique has several advantages:
</p>
-<div class="itemizedlist"><ul type="disc">
-<li>
- Cut down compile times to zero for these additional functions
- </li>
-<li>
- Reduce the memory footprint to virtually zero
- </li>
-<li>
- Minimize the need to recompile
- </li>
-<li>
- Rapid prototyping (you can move the code to C++ if required without changing
- the interface)
- </li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ Cut down compile times to zero for these additional functions
+ </li>
+<li class="listitem">
+ Reduce the memory footprint to virtually zero
+ </li>
+<li class="listitem">
+ Minimize the need to recompile
+ </li>
+<li class="listitem">
+ Rapid prototyping (you can move the code to C++ if required without changing
+ the interface)
+ </li>
</ul></div>
<p>
You can even add a little syntactic sugar with the use of metaclasses. Let's
@@ -346,7 +346,7 @@
support.
</p>
</div>
-<div class="section" lang="en">
+<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="python.reducing_compiling_time"></a>Reducing Compiling Time</h3></div></div></div>
<p>
@@ -376,7 +376,7 @@
<span class="special">}</span>
</pre>
<p>
- Now you create a file <tt class="literal">main.cpp</tt>, which contains the <tt class="literal">BOOST_PYTHON_MODULE</tt>
+ Now you create a file <code class="literal">main.cpp</code>, which contains the <code class="literal">BOOST_PYTHON_MODULE</code>
macro, and call the various export functions inside it.
</p>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">export_point</span><span class="special">();</span>
@@ -412,21 +412,21 @@
</p>
<div class="note"><table border="0" summary="Note">
<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
-<tr><td colspan="2" align="left" valign="top"><p>
+<tr><td align="left" valign="top"><p>
If you're exporting your classes with Pyste,
- take a look at the <tt class="literal">--multiple</tt> option, that generates
+ take a look at the <code class="literal">--multiple</code> option, that generates
the wrappers in various files as demonstrated here.
</p></td></tr>
</table></div>
<div class="note"><table border="0" summary="Note">
<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
-<tr><td colspan="2" align="left" valign="top"><p>
+<tr><td align="left" valign="top"><p>
This method is useful too if you are getting the error message <span class="emphasis"><em>"fatal
error C1204:Compiler limit:internal structure overflow"</em></span>
when compiling a large source file, as explained in the FAQ.
@@ -436,7 +436,7 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
de Guzman, David Abrahams<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
@@ -446,7 +446,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="exception.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a>
+<a accesskey="p" href="exception.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a>
</div>
</body>
</html>
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk