Boost-Commit :

Date view	Thread view	Subject view	Author view

From: joel_at_[hidden]
Date: 2008-03-24 19:02:58

Next message: joel_at_[hidden]: "[Boost-commit] svn:boost r43849 - branches/release/libs/python/doc/tutorial/doc/html/python"
Previous message: anthony_at_[hidden]: "[Boost-commit] svn:boost r43847 - in trunk/boost/thread: . detail"

Author: djowel
Date: 2008-03-24 19:02:57 EDT (Mon, 24 Mar 2008)
New Revision: 43848
URL: http://svn.boost.org/trac/boost/changeset/43848

Log:
Added note about --preserve-test-targets
Text files modified:
   branches/release/libs/python/doc/tutorial/doc/html/python/embedding.html | 80 ++++++++--------
   branches/release/libs/python/doc/tutorial/doc/html/python/exception.html | 12 +-
   branches/release/libs/python/doc/tutorial/doc/html/python/exposing.html | 184 +++++++++++++++++++--------------------
   branches/release/libs/python/doc/tutorial/doc/html/python/functions.html | 163 +++++++++++++++++-----------------
   branches/release/libs/python/doc/tutorial/doc/html/python/hello.html | 70 ++++++++------
   branches/release/libs/python/doc/tutorial/doc/html/python/iterators.html | 36 +++---
   branches/release/libs/python/doc/tutorial/doc/html/python/object.html | 89 +++++++++----------
   branches/release/libs/python/doc/tutorial/doc/html/python/techniques.html | 68 +++++++-------
   8 files changed, 353 insertions(+), 349 deletions(-)

Modified: branches/release/libs/python/doc/tutorial/doc/html/python/embedding.html
==============================================================================
--- branches/release/libs/python/doc/tutorial/doc/html/python/embedding.html (original)
+++ branches/release/libs/python/doc/tutorial/doc/html/python/embedding.html 2008-03-24 19:02:57 EDT (Mon, 24 Mar 2008)
@@ -3,19 +3,19 @@
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Embedding</title>
<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<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="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">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
</tr></table>
<hr>
@@ -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... <img src="../images/smiley.png" alt="smiley">
 
-<a name="embedding.building_embedded_programs"></a><h3>
-<a name="id2648523"></a>
+<a name="embedding.building_embedded_programs"></a><h2>
+<a name="id471329"></a>
 Building embedded programs
- </h3>
+ </h2>

 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.
 

 Boost.Python's library comes in two variants. Both are located in Boost's
- <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
+ <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
 find the libraries, you probably haven't built Boost.Python yet. See Building and Testing on how to do this.
 

- Python's library can be found in the <code class="literal">/libs</code> subdirectory
+ Python's library can be found in the <tt class="literal">/libs</tt> subdirectory
 of your Python directory. On Windows it is called pythonXY.lib where X.Y is
 your major Python version number.
 

- Additionally, Python's <code class="literal">/include</code> subdirectory has to be added
+ Additionally, Python's <tt class="literal">/include</tt> subdirectory has to be added
 to your include path.
 

@@ -81,21 +81,21 @@
 <library-path>$(PYTHON_LIB_PATH)
 <find-library>$(PYTHON_EMBEDDED_LIBRARY) ;
</pre>
-<a name="embedding.getting_started"></a><h3>
-<a name="id2648620"></a>
+<a name="embedding.getting_started"></a><h2>
+<a name="id471434"></a>
 Getting started
- </h3>
+ </h2>

 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:
 
<div class="orderedlist"><ol type="1">
<li>
- #include <code class="literal"><boost/python.hpp></code>
+ #include <tt class="literal"><boost/python.hpp></tt>
</li>
<li>
 Call Py_Initialize()
- to start the interpreter and create the <code class="literal">_main_</code>
+ to start the interpreter and create the <tt class="literal">_main_</tt>
 module.
 </li>
<li>
@@ -107,9 +107,9 @@
<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 align="left" valign="top">
- 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.
+<tr><td colspan="2" align="left" valign="top">
+ 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.
 </td></tr>
</table></div>

@@ -119,8 +119,8 @@

 

- Now that we can embed the interpreter in
- our programs, lets see how to put it to use...
+ Now that we can embed the interpreter in
+ our programs, lets see how to put it to use...
 

 
@@ -130,7 +130,7 @@
<a name="python.using_the_interpreter"></a>Using the interpreter</h3></div></div></div>

 As you probably already know, objects in Python are reference-counted. Naturally,
- the <code class="literal">PyObject</code>s of the Python/C API are also reference-counted.
+ the <tt class="literal">PyObject</tt>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 PythonC API requires you to do it [@http:/www.python.org/doc/current/api/refcounts.html
 by hand]. This is messy and especially hard to get right in the presence
@@ -138,10 +138,10 @@
 and object class templates to
 automate the process.
 
-<a name="using_the_interpreter.running_python_code"></a><h3>
-<a name="id2648770"></a>
+<a name="using_the_interpreter.running_python_code"></a><h2>
+<a name="id471597"></a>
 Running Python code
- </h3>
+ </h2>

 Boost.python provides three related functions to run Python code from C++.
 
@@ -156,10 +156,10 @@
 and exec_file executes the code contained in the given file.
 

- The <code class="literal">globals</code> and <code class="literal">locals</code> parameters are
+ The <tt class="literal">globals</tt> and <tt class="literal">locals</tt> 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 <code class="literal">_main_</code>
+ dictionary of the <tt class="literal">_main_</tt>
 module for both parameters.
 

@@ -173,7 +173,7 @@
 first), and returns it.
 

- Let's import the <code class="literal">_main_</code>
+ Let's import the <tt class="literal">_main_</tt>
 module and run some Python code in its namespace:
 
<pre class="programlisting">
@@ -189,15 +189,15 @@
 This should create a file called 'hello.txt' in the current directory containing
 a phrase that is well-known in programming circles.
 
-<a name="using_the_interpreter.manipulating_python_objects"></a><h3>
-<a name="id2649302"></a>
+<a name="using_the_interpreter.manipulating_python_objects"></a><h2>
+<a name="id472185"></a>
 Manipulating Python objects
- </h3>
+ </h2>

 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 <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>.
+ 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>.
 The following examples should further illustrate this fact:
 
<pre class="programlisting">
@@ -207,7 +207,7 @@
int five_squared = extract<int>(main_namespace["result"]);
</pre>

- Here we create a dictionary object for the <code class="literal">_main_</code>
+ Here we create a dictionary object for the <tt class="literal">_main_</tt>
 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:
@@ -216,10 +216,10 @@
object result = eval("5 ** 2");
int five_squared = extract<int>(result);
</pre>
-<a name="using_the_interpreter.exception_handling"></a><h3>
-<a name="id2649638"></a>
+<a name="using_the_interpreter.exception_handling"></a><h2>
+<a name="id472557"></a>
 Exception handling
- </h3>
+ </h2>

 If an exception occurs in the evaluation of the python expression, error_already_set
 is thrown:
@@ -237,7 +237,7 @@
}
</pre>

- The <code class="literal">error_already_set</code> exception class doesn't carry any
+ The <tt class="literal">error_already_set</tt> 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 PythonC API in your catch-statement.

Modified: branches/release/libs/python/doc/tutorial/doc/html/python/exception.html
==============================================================================
--- branches/release/libs/python/doc/tutorial/doc/html/python/exception.html (original)
+++ branches/release/libs/python/doc/tutorial/doc/html/python/exception.html 2008-03-24 19:02:57 EDT (Mon, 24 Mar 2008)
@@ -1,21 +1,21 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Exception Translation</title>
+<title> Exception Translation</title>
<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<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="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>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
</tr></table>
<hr>

Modified: branches/release/libs/python/doc/tutorial/doc/html/python/exposing.html
==============================================================================
--- branches/release/libs/python/doc/tutorial/doc/html/python/exposing.html (original)
+++ branches/release/libs/python/doc/tutorial/doc/html/python/exposing.html 2008-03-24 19:02:57 EDT (Mon, 24 Mar 2008)
@@ -1,21 +1,21 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Exposing Classes</title>
+<title> Exposing Classes</title>
<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<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">
+<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">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
</tr></table>
<hr>
@@ -64,9 +64,9 @@
}
</pre>

- 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
+ 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
 session:
 

@@ -82,7 +82,7 @@
<div class="titlepage"><div><div><h3 class="title">
<a name="python.constructors"></a>Constructors</h3></div></div></div>

- Our previous example didn't have any explicit constructors. Since <code class="literal">World</code>
+ Our previous example didn't have any explicit constructors. Since <tt class="literal">World</tt>
 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
@@ -106,9 +106,9 @@
};
</pre>

- This time <code class="literal">World</code> has no default constructor; our previous
+ This time <tt class="literal">World</tt> has no default constructor; our previous
 wrapping code would fail to compile when the library tried to expose it.
- We have to tell <code class="literal">class_<World></code> about the constructor
+ We have to tell <tt class="literal">class_<World></tt> about the constructor
 we want to expose instead.
 
<pre class="programlisting">
@@ -124,13 +124,13 @@
}
</pre>

- <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">"_init_"</code>").
+ <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">"_init_"</tt>").
 

- 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
+ 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
 another World constructor taking in two doubles:
 
<pre class="programlisting">
@@ -142,13 +142,13 @@
</pre>

 On the other hand, if we do not wish to expose any constructors at all, we
- may use <code class="literal">no_init</code> instead:
+ may use <tt class="literal">no_init</tt> instead:
 
<pre class="programlisting">
class_<Abstract>("Abstract", no_init)
</pre>

- This actually adds an <code class="literal">_init_</code>
+ This actually adds an <tt class="literal">_init_</tt>
 method which always raises a Python RuntimeError exception.
 
</div>
@@ -158,8 +158,8 @@

 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 read-only
- or read-write. Consider this class <code class="literal">Var</code>:
+ to be exposed may be regarded as read-only
+ or read-write. Consider this class <tt class="literal">Var</tt>:
 
<pre class="programlisting">
struct Var
@@ -170,7 +170,7 @@
};
</pre>

- Our C++ <code class="literal">Var</code> class and its data members can be exposed
+ Our C++ <tt class="literal">Var</tt> class and its data members can be exposed
 to Python:
 
<pre class="programlisting">
@@ -191,8 +191,8 @@
pi is around 3.14
</pre>

- Note that <code class="literal">name</code> is exposed as read-only
- while <code class="literal">value</code> is exposed as read-write.
+ Note that <tt class="literal">name</tt> is exposed as read-only
+ while <tt class="literal">value</tt> is exposed as read-write.
 
<pre class="programlisting">
>>> x.name = 'e' # can't change name
@@ -224,7 +224,7 @@

 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 <code class="literal">Num</code>
+ can just be a different syntax for a method call. Wrapping our <tt class="literal">Num</tt>
 class using Boost.Python:
 
<pre class="programlisting">
@@ -245,8 +245,8 @@
>>> x.rovalue = 2.17 # error!
</pre>

- Take note that the class property <code class="literal">rovalue</code> is exposed as
- read-only since the <code class="literal">rovalue</code>
+ Take note that the class property <tt class="literal">rovalue</tt> is exposed as
+ read-only since the <tt class="literal">rovalue</tt>
 setter member function is not passed in:
 

@@ -273,7 +273,7 @@
struct Derived : Base {};
</pre>

- And a set of C++ functions operating on <code class="literal">Base</code> and <code class="literal">Derived</code>
+ And a set of C++ functions operating on <tt class="literal">Base</tt> and <tt class="literal">Derived</tt>
 object instances:
 
<pre class="programlisting">
@@ -282,7 +282,7 @@
Base* factory() { return new Derived; }
</pre>

- We've seen how we can wrap the base class <code class="literal">Base</code>:
+ We've seen how we can wrap the base class <tt class="literal">Base</tt>:
 
<pre class="programlisting">
class_<Base>("Base")
@@ -290,8 +290,8 @@
 ;
</pre>

- 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:
+ 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:
 
<pre class="programlisting">
class_<Derived, bases<Base> >("Derived")
@@ -307,15 +307,15 @@
 member functions)
 </li>
<li>
-If Base is polymorphic, <code class="literal">Derived</code>
+If Base is polymorphic, <tt class="literal">Derived</tt>
 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.
+ <tt class="literal">Base</tt> can be passed where a pointer or reference to
+ <tt class="literal">Derived</tt> is expected.
 </li>
</ol></div>

- 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>:
+ 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>:
 
<pre class="programlisting">
def("b", b);
@@ -323,12 +323,12 @@
def("factory", factory);
</pre>

- 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
+ 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
 policies</a> later.
 
<pre class="programlisting">
@@ -343,7 +343,7 @@

 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 <code class="literal">Base</code> class:
+ to our <tt class="literal">Base</tt> class:
 
<pre class="programlisting">
struct Base
@@ -356,11 +356,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 <code class="computeroutput">Base</code>. Yet, when
+ to our class <tt class="computeroutput">Base</tt>. Yet, when
 you have a virtual function that's going to be overridden in Python and called
- polymorphically from C++, we'll need to
+ polymorphically from C++, we'll need to
 add some scaffoldings to make things work properly. What we'll do is write
- a class wrapper that derives from <code class="computeroutput">Base</code>
+ a class wrapper that derives from <tt class="computeroutput">Base</tt>
 that will unintrusively hook into the virtual functions so that a Python
 override may be called:
 
@@ -374,29 +374,28 @@
};
</pre>

- Notice too that in addition to inheriting from <code class="computeroutput">Base</code>,
- we also multiply- inherited <code class="computeroutput">wrapper<Base></code> (See Wrapper).
- The <code class="computeroutput">wrapper</code> template makes
+ Notice too that in addition to inheriting from <tt class="computeroutput">Base</tt>,
+ we also multiply- inherited <tt class="computeroutput">wrapper<Base></tt> (See Wrapper).
+ The <tt class="computeroutput">wrapper</tt> template makes
 the job of wrapping classes that are meant to overridden in Python, easier.
 
<div class="sidebar">
-

- <img src="../images/alert.png" alt="alert"> MSVC6/7 Workaround
+ <img src="../images/alert.png" alt="alert"> MSVC6/7 Workaround
 

- If you are using Microsoft Visual C++ 6 or 7, you have to write <code class="computeroutput">f</code> as:
+ If you are using Microsoft Visual C++ 6 or 7, you have to write <tt class="computeroutput">f</tt> as:
 

- <code class="computeroutput">return call<int>(this->get_override("f").ptr());</code>.
+ <tt class="computeroutput">return call<int>(this->get_override("f").ptr());</tt>.
 
</div>

- BaseWrap's overridden virtual member function <code class="computeroutput">f</code>
- in effect calls the corresponding method of the Python object through <code class="computeroutput">get_override</code>.
+ BaseWrap's overridden virtual member function <tt class="computeroutput">f</tt>
+ in effect calls the corresponding method of the Python object through <tt class="computeroutput">get_override</tt>.
 

- Finally, exposing <code class="computeroutput">Base</code>:
+ Finally, exposing <tt class="computeroutput">Base</tt>:
 
<pre class="programlisting">
class_<BaseWrap, boost::noncopyable>("Base")
@@ -404,8 +403,8 @@
 ;
</pre>

- <code class="computeroutput">pure_virtual</code> signals Boost.Python
- that the function <code class="computeroutput">f</code> is a
+ <tt class="computeroutput">pure_virtual</tt> signals Boost.Python
+ that the function <tt class="computeroutput">f</tt> is a
 pure virtual function.
 
<div class="note"><table border="0" summary="Note">
@@ -413,13 +412,13 @@
<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 align="left" valign="top">
+<tr><td colspan="2" align="left" valign="top">

- member function and methods
+ member function and methods
 

- Python, like many object oriented languages uses the term methods.
- Methods correspond roughly to C++'s member functions
+ Python, like many object oriented languages uses the term methods.
+ Methods correspond roughly to C++'s member functions
 
</td></tr>
</table></div>
@@ -430,11 +429,11 @@

 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 non-pure-virtual
+ wrapper</a> facilities. If we wish to wrap non-pure-virtual
 functions instead, the mechanism is a bit different.
 

- Recall that in the <a class="link" href="exposing.html#python.class_virtual_functions" title="Class Virtual Functions">previous
+ Recall that in the <a 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:
 
@@ -445,8 +444,8 @@
};
</pre>

- 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:
+ 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:
 
<pre class="programlisting">
struct Base
@@ -472,21 +471,20 @@
};
</pre>

- Notice how we implemented <code class="computeroutput">BaseWrap::f</code>. Now,
- we have to check if there is an override for <code class="computeroutput">f</code>.
- If none, then we call <code class="computeroutput">Base::f()</code>.
+ Notice how we implemented <tt class="computeroutput">BaseWrap::f</tt>. Now,
+ we have to check if there is an override for <tt class="computeroutput">f</tt>.
+ If none, then we call <tt class="computeroutput">Base::f()</tt>.
 
<div class="sidebar">
-

- <img src="../images/alert.png" alt="alert"> MSVC6/7 Workaround
+ <img src="../images/alert.png" alt="alert"> MSVC6/7 Workaround
 

 If you are using Microsoft Visual C++ 6 or 7, you have to rewrite the line
- with the <code class="computeroutput">*note*</code> as:
+ with the <tt class="computeroutput">*note*</tt> as:
 

- <code class="computeroutput">return call<char const*>(f.ptr());</code>.
+ <tt class="computeroutput">return call<char const*>(f.ptr());</tt>.
 
</div>

@@ -498,10 +496,10 @@
 ;
</pre>

- Take note that we expose both <code class="computeroutput">&Base::f</code> and <code class="computeroutput">&BaseWrap::default_f</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.
+ Take note that we expose both <tt class="computeroutput">&Base::f</tt> and <tt class="computeroutput">&BaseWrap::default_f</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.
 

 In Python, the results would be as expected:
@@ -517,14 +515,14 @@
>>> derived = Derived()
</pre>

- Calling <code class="literal">base.f()</code>:
+ Calling <tt class="literal">base.f()</tt>:
 
<pre class="programlisting">
>>> base.f()
0
</pre>

- Calling <code class="literal">derived.f()</code>:
+ Calling <tt class="literal">derived.f()</tt>:
 
<pre class="programlisting">
>>> derived.f()
@@ -534,17 +532,17 @@
<div class="section" lang="en">
<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><h3>
-<a name="id2640280"></a>
+<a name="class_operators_special_functions.python_operators"></a><h2>
+<a name="id461481"></a>
 Python Operators
- </h3>
+ </h2>

 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.
 

- Consider a file position class <code class="literal">FilePos</code> and a set of operators
+ Consider a file position class <tt class="literal">FilePos</tt> and a set of operators
 that take on FilePos instances:
 

@@ -577,16 +575,16 @@

 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
- <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
+ <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
 expressions".
 
-<a name="class_operators_special_functions.special_methods"></a><h3>
-<a name="id2640915"></a>
+<a name="class_operators_special_functions.special_methods"></a><h2>
+<a name="id462238"></a>
 Special Methods
- </h3>
+ </h2>

 Python has a few more Special Methods. Boost.Python
 supports all of the standard special method names supported by real Python
@@ -617,9 +615,9 @@
<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 align="left" valign="top">
- What is the business of <code class="computeroutput">operator<<</code>? Well, the method <code class="computeroutput">str</code> requires the <code class="computeroutput">operator<<</code> to do its work (i.e. <code class="computeroutput">operator<<</code>
- is used by the method defined by <code class="computeroutput">def(str(self))</code>.
+<tr><td colspan="2" align="left" valign="top">
+ What is the business of <tt class="computeroutput">operator<<</tt>? Well, the method <tt class="computeroutput">str</tt> requires the <tt class="computeroutput">operator<<</tt> to do its work (i.e. <tt class="computeroutput">operator<<</tt>
+ is used by the method defined by <tt class="computeroutput">def(str(self))</tt>.
 </td></tr>
</table></div>
</div>

Modified: branches/release/libs/python/doc/tutorial/doc/html/python/functions.html
==============================================================================
--- branches/release/libs/python/doc/tutorial/doc/html/python/functions.html (original)
+++ branches/release/libs/python/doc/tutorial/doc/html/python/functions.html 2008-03-24 19:02:57 EDT (Mon, 24 Mar 2008)
@@ -3,19 +3,19 @@
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Functions</title>
<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<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="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>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
</tr></table>
<hr>
@@ -49,7 +49,7 @@
</blockquote></div>

 But before you do, you might want to fire up Python 2.2 or later and type
- <code class="literal">>>> import this</code>.
+ <tt class="literal">>>> import this</tt>.
 
<pre class="programlisting">>>> import this
The Zen of Python, by Tim Peters
@@ -68,7 +68,7 @@
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 right now.
+Although never is often better than right 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!
@@ -126,19 +126,19 @@
 
<div class="orderedlist"><ol type="1">
<li>
-<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>
+<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 <code class="literal">y.x</code> is returned
+ A reference to <tt class="literal">y.x</tt> is returned
 </li>
<li>
-<code class="literal">y</code> is deleted. <code class="literal">x</code> is a dangling reference
+<tt class="literal">y</tt> is deleted. <tt class="literal">x</tt> is a dangling reference
 </li>
<li>
-<code class="literal">x.some_method()</code> is called
+<tt class="literal">x.some_method()</tt> is called
 </li>
-<li>BOOM!</li>
+<li>BOOM!</li>
</ol></div>

 We could copy result into a new object:
@@ -168,7 +168,7 @@
};
</pre>

- Notice that the data member <code class="literal">z</code> is held by class Y using
+ Notice that the data member <tt class="literal">z</tt> is held by class Y using
 a raw pointer. Now we have a potential dangling pointer problem inside Y:
 
<pre class="programlisting">
@@ -177,7 +177,7 @@
>>> y.z_value() # CRASH!
</pre>

- For reference, here's the implementation of <code class="literal">f</code> again:
+ For reference, here's the implementation of <tt class="literal">f</tt> again:
 
<pre class="programlisting">
X& f(Y& y, Z* z)
@@ -191,33 +191,33 @@
 
<div class="orderedlist"><ol type="1">
<li>
-<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>
+<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 <code class="literal">z</code> is held by <code class="literal">y</code>
+ A pointer to <tt class="literal">z</tt> is held by <tt class="literal">y</tt>
</li>
<li>
- A reference to <code class="literal">y.x</code> is returned
+ A reference to <tt class="literal">y.x</tt> is returned
 </li>
<li>
-<code class="literal">z</code> is deleted. <code class="literal">y.z</code> is a dangling pointer
+<tt class="literal">z</tt> is deleted. <tt class="literal">y.z</tt> is a dangling pointer
 </li>
<li>
-<code class="literal">y.z_value()</code> is called
+<tt class="literal">y.z_value()</tt> is called
 </li>
<li>
-<code class="literal">z->value()</code> is called
+<tt class="literal">z->value()</tt> is called
 </li>
-<li>BOOM!</li>
+<li>BOOM!</li>
</ol></div>
-<a name="call_policies.call_policies"></a><h3>
-<a name="id2642493"></a>
+<a name="call_policies.call_policies"></a><h2>
+<a name="id464235"></a>
 Call Policies
- </h3>
+ </h2>

 Call Policies may be used in situations such as the example detailed above.
- In our example, <code class="literal">return_internal_reference</code> and <code class="literal">with_custodian_and_ward</code>
+ In our example, <tt class="literal">return_internal_reference</tt> and <tt class="literal">with_custodian_and_ward</tt>
 are our friends:
 
<pre class="programlisting">
@@ -226,27 +226,27 @@
 with_custodian_and_ward<1, 2> >());
</pre>

- What are the <code class="literal">1</code> and <code class="literal">2</code> parameters, you
+ What are the <tt class="literal">1</tt> and <tt class="literal">2</tt> parameters, you
 ask?
 
<pre class="programlisting">
return_internal_reference<1
</pre>

- 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>".
+ 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>".
 
<pre class="programlisting">
with_custodian_and_ward<1, 2>
</pre>

 Informs Boost.Python that the lifetime of the argument indicated by ward
- (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>).
+ (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>).
 

 It is also important to note that we have defined two policies above. Two
@@ -263,41 +263,40 @@
 
<div class="itemizedlist"><ul type="disc">
<li>
-with_custodian_and_ward: Ties lifetimes
+with_custodian_and_ward: Ties lifetimes
 of the arguments
 </li>
<li>
-with_custodian_and_ward_postcall: Ties
+with_custodian_and_ward_postcall: Ties
 lifetimes of the arguments and results
 </li>
<li>
-return_internal_reference: Ties lifetime
+return_internal_reference: Ties lifetime
 of one argument to that of result
 </li>
<li>
-return_value_policy<T> with T one of:<div class="itemizedlist"><ul type="circle">
+return_value_policy<T> with T one of:<div class="itemizedlist"><ul type="circle">
<li>
-reference_existing_object: naive (dangerous)
+reference_existing_object: naive (dangerous)
 approach
 </li>
<li>
-copy_const_reference: Boost.Python
+copy_const_reference: Boost.Python
 v1 approach
 </li>
<li>
-copy_non_const_reference:
+copy_non_const_reference:
 </li>
<li>
-manage_new_object: Adopt a pointer
+manage_new_object: Adopt a pointer
 and hold the instance
 </li>
</ul></div>
</li>
</ul></div>
<div class="sidebar">
-

- <img src="../images/smiley.png" alt="smiley"> Remember the Zen, Luke:
+ <img src="../images/smiley.png" alt="smiley"> Remember the Zen, Luke:
 

 "Explicit is better than implicit"
@@ -367,21 +366,21 @@
<a name="python.default_arguments"></a>Default Arguments</h3></div></div></div>

 Boost.Python wraps (member) function pointers. Unfortunately, C++ function
- pointers carry no default argument info. Take a function <code class="literal">f</code>
+ pointers carry no default argument info. Take a function <tt class="literal">f</tt>
 with default arguments:
 
<pre class="programlisting">
int f(int, double = 3.14, char const* = "hello");
</pre>

- But the type of a pointer to the function <code class="literal">f</code> has no information
+ But the type of a pointer to the function <tt class="literal">f</tt> has no information
 about its default arguments:
 
<pre class="programlisting">
int(*g)(int,double,char const*) = f; // defaults lost!
</pre>

- When we pass this function pointer to the <code class="literal">def</code> function,
+ When we pass this function pointer to the <tt class="literal">def</tt> function,
 there is no way to retrieve the default arguments:
 
<pre class="programlisting">
@@ -389,7 +388,7 @@
</pre>

 Because of this, when wrapping C++ code, we had to resort to manual wrapping
- as outlined in the <a class="link" href="functions.html#python.overloading" title="Overloading">previous section</a>,
+ as outlined in the previous section,
 or writing thin wrappers:
 
<pre class="programlisting">
@@ -415,10 +414,10 @@
 are overloaded with a common sequence of initial arguments
 </li>
</ul></div>
-<a name="default_arguments.boost_python_function_overloads"></a><h3>
-<a name="id2644222"></a>
+<a name="default_arguments.boost_python_function_overloads"></a><h2>
+<a name="id466276"></a>
 BOOST_PYTHON_FUNCTION_OVERLOADS
- </h3>
+ </h2>

 Boost.Python now has a way to make it easier. For instance, given a function:
 
@@ -436,19 +435,19 @@
</pre>

 will automatically create the thin wrappers for us. This macro will create
- a class <code class="literal">foo_overloads</code> that can be passed on to <code class="literal">def(...)</code>.
+ a class <tt class="literal">foo_overloads</tt> that can be passed on to <tt class="literal">def(...)</tt>.
 The third and fourth macro argument are the minimum arguments and maximum
- 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>
+ 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>
 function will automatically add all the foo variants for us:
 
<pre class="programlisting">
def("foo", foo, foo_overloads());
</pre>
-<a name="default_arguments.boost_python_member_function_overloads"></a><h3>
-<a name="id2644493"></a>
+<a name="default_arguments.boost_python_member_function_overloads"></a><h2>
+<a name="id466594"></a>
 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS
- </h3>
+ </h2>

 Objects here, objects there, objects here there everywhere. More frequently
 than anything else, we need to expose member functions of our classes to
@@ -457,7 +456,7 @@
 play. Another macro is provided to make this a breeze.
 

- Like <code class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</code>, <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code>
+ Like <tt class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</tt>, <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt>
 may be used to automatically create the thin wrappers for wrapping member
 functions. Let's have an example:
 
@@ -478,11 +477,11 @@
BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(george_overloads, wack_em, 1, 3)
</pre>

- will generate a set of thin wrappers for george's <code class="literal">wack_em</code>
+ will generate a set of thin wrappers for george's <tt class="literal">wack_em</tt>
 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 <code class="literal">george_overloads</code> that can then be used
- as an argument to <code class="literal">def(...)</code>:
+ in a class named <tt class="literal">george_overloads</tt> that can then be used
+ as an argument to <tt class="literal">def(...)</tt>:
 
<pre class="programlisting">
.def("wack_em", &george::wack_em, george_overloads());
@@ -491,13 +490,13 @@
 See the <a href="../../../../v2/overloads.html#BOOST_PYTHON_FUNCTION_OVERLOADS-spec" target="_top">overloads
 reference</a> for details.
 
-<a name="default_arguments.init_and_optional"></a><h3>
-<a name="id2644801"></a>
+<a name="default_arguments.init_and_optional"></a><h2>
+<a name="id466958"></a>
 init and optional
- </h3>
+ </h2>

 A similar facility is provided for class constructors, again, with default
- arguments or a sequence of overloads. Remember <code class="literal">init<...></code>?
+ arguments or a sequence of overloads. Remember <tt class="literal">init<...></tt>?
 For example, given a class X with a constructor:
 
<pre class="programlisting">
@@ -514,7 +513,7 @@
.def(init<int, optional<char, std::string, double> >())
</pre>

- Notice the use of <code class="literal">init<...></code> and <code class="literal">optional<...></code>
+ Notice the use of <tt class="literal">init<...></tt> and <tt class="literal">optional<...></tt>
 to signify the default (optional arguments).
 
</div>
@@ -522,8 +521,8 @@
<div class="titlepage"><div><div><h3 class="title">
<a name="python.auto_overloading"></a>Auto-Overloading</h3></div></div></div>

- 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
+ 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
 used for overloaded functions and member functions with a common sequence
 of initial arguments. Here is an example:
 
@@ -565,24 +564,24 @@
 Notice though that we have a situation now where we have a minimum of zero
 (0) arguments and a maximum of 3 arguments.
 
-<a name="auto_overloading.manual_wrapping"></a><h3>
-<a name="id2645458"></a>
+<a name="auto_overloading.manual_wrapping"></a><h2>
+<a name="id467739"></a>
 Manual Wrapping
- </h3>
+ </h2>

- It is important to emphasize however that the overloaded
- functions must have a common sequence of initial arguments. Otherwise,
+ It is important to emphasize however that the overloaded
+ functions must have a common sequence of initial arguments. Otherwise,
 our scheme above will not work. If this is not the case, we have to wrap
- our functions <a class="link" href="functions.html#python.overloading" title="Overloading">manually</a>.
+ our functions manually.
 

 Actually, we can mix and match manual wrapping of overloaded functions and
- 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
+ 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
 overloading</a>, since the first 4 overload functins have a common sequence
- 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
+ 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
 manually wrap just the last. Here's how we'll do this:
 
<pre class="programlisting">

Modified: branches/release/libs/python/doc/tutorial/doc/html/python/hello.html
==============================================================================
--- branches/release/libs/python/doc/tutorial/doc/html/python/hello.html (original)
+++ branches/release/libs/python/doc/tutorial/doc/html/python/hello.html 2008-03-24 19:02:57 EDT (Mon, 24 Mar 2008)
@@ -1,21 +1,21 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Building Hello World</title>
+<title> Building Hello World</title>
<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<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">
+<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>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
</tr></table>
<hr>
@@ -25,29 +25,29 @@
<div class="section" lang="en">
<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><h3>
-<a name="id2586502"></a>
+<a name="hello.from_start_to_finish"></a><h2>
+<a name="id386189"></a>
 From Start To Finish
- </h3>
+ </h2>

 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: bjam.
+ distribution: bjam.
 
<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 align="left" valign="top">
+<tr><td colspan="2" align="left" valign="top">

- Building without bjam
+ Building without bjam
 

 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 <code class="literal">bjam</code>.
+ are of course other build tools apart from <tt class="literal">bjam</tt>.
 

 Take note however that the preferred build tool for Boost.Python is bjam.
@@ -65,7 +65,7 @@
 and run a python program using the extension.
 

- The tutorial example can be found in the directory: <code class="literal">libs/python/example/tutorial</code>.
+ The tutorial example can be found in the directory: <tt class="literal">libs/python/example/tutorial</tt>.
 There, you can find:
 
<div class="itemizedlist"><ul type="disc">
@@ -80,37 +80,37 @@
 </li>
</ul></div>

- The <code class="literal">hello.cpp</code> file is our C++ hello world example. The
- <code class="literal">Jamroot</code> is a minimalist bjam 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>.
+ The <tt class="literal">hello.cpp</tt> file is our C++ hello world example. The
+ <tt class="literal">Jamroot</tt> is a minimalist bjam 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>.
 

 Before anything else, you should have the bjam executable in your boost directory
- or somewhere in your path such that <code class="literal">bjam</code> can be executed
+ or somewhere in your path such that <tt class="literal">bjam</tt> 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.
 
-<a name="hello.let_s_jam_"></a><h3>
-<a name="id2585377"></a>
+<a name="hello.let_s_jam_"></a><h2>
+<a name="id386347"></a>
 Let's Jam!
- </h3>
+ </h2>

 <img src="../images/jam.png" alt="jam">
 

 <a href="../../../../../example/tutorial/Jamroot" target="_top">Here</a> is our minimalist
- Jamroot file. Simply copy the file and tweak <code class="literal">use-project boost</code>
+ Jamroot file. Simply copy the file and tweak <tt class="literal">use-project boost</tt>
 to where your boost root directory is and your OK.
 

 The comments contained in the Jamrules file above should be sufficient to get
 you going.
 
-<a name="hello.running_bjam"></a><h3>
-<a name="id2585427"></a>
+<a name="hello.running_bjam"></a><h2>
+<a name="id386404"></a>
 Running bjam
- </h3>
+ </h2>

 bjam is run using your operating system's command line
 interpreter.
@@ -144,13 +144,13 @@

 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 <code class="literal">C:/dev/tools/Python/</code>.
+ located. The above assumes that the Python installation is in <tt class="literal">C:/dev/tools/Python/</tt>.
 If you have one fairly "standard" python installation for your platform,
 you might not need to do this.
 

- 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>
+ 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>
 is situated.
 

@@ -180,11 +180,21 @@
 Or something similar. If all is well, you should now have built the DLLs and
 run the Python program.
 
+<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">
+ Starting from Boost 1.35, bjam erases the generated executables (e.g. pyd
+ file). To keep bjam from doing that, Pass --preserve-test-targets to bjam.
+ </td></tr>
+</table></div>
<div class="blockquote"><blockquote class="blockquote">

 

- There you go... Have fun!
+ There you go... Have fun!

Modified: branches/release/libs/python/doc/tutorial/doc/html/python/iterators.html
==============================================================================
--- branches/release/libs/python/doc/tutorial/doc/html/python/iterators.html (original)
+++ branches/release/libs/python/doc/tutorial/doc/html/python/iterators.html 2008-03-24 19:02:57 EDT (Mon, 24 Mar 2008)
@@ -3,19 +3,19 @@
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Iterators</title>
<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<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="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>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
</tr></table>
<hr>
@@ -30,7 +30,7 @@
 iterators, but these are two very different beasts.
 

- C++ iterators:
+ C++ iterators:
 
<div class="itemizedlist"><ul type="disc">
<li>
@@ -45,7 +45,7 @@
 </li>
</ul></div>

- Python Iterators:
+ Python Iterators:
 
<div class="itemizedlist"><ul type="disc">
<li>
@@ -59,8 +59,8 @@
 </li>
</ul></div>

- The typical Python iteration protocol: <code class="literal">for y
- in x...</code> is as follows:
+ The typical Python iteration protocol: <tt class="literal">for y
+ in x...</tt> is as follows:
 

 
@@ -74,7 +74,7 @@
</pre>

 Boost.Python provides some mechanisms to make C++ iterators play along nicely
- as Python iterators. What we need to do is to produce appropriate <code class="computeroutput">__iter__</code> function from C++ iterators that
+ as Python iterators. What we need to do is to produce appropriate <tt class="computeroutput">__iter__</tt> function from C++ iterators that
 is compatible with the Python iteration protocol. For example:
 

@@ -91,7 +91,7 @@
.def("__iter__", iterator<vector<int> >())
</pre>

- range
+ range
 

 We can create a Python savvy iterator using the range function:
@@ -119,14 +119,14 @@
 </li>
</ul></div>

- iterator
+ iterator
 
<div class="itemizedlist"><ul type="disc"><li>
 iterator<T, Policies>()
 </li></ul></div>

- 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.
+ 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.
 

 Let's put this into action... Here's an example from some hypothetical bogon
@@ -152,14 +152,14 @@
 .property("bogons", range(&F::b_begin, &F::b_end));
</pre>

- stl_input_iterator
+ stl_input_iterator
 

 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 <code class="computeroutput">stl_input_iterator<></code>.
- Consider how we might implement a function that exposes <code class="computeroutput">std::list<int>::assign()</code> to Python:
+ a Python iterator look like an STL iterator. For that, we use <tt class="computeroutput">stl_input_iterator<></tt>.
+ Consider how we might implement a function that exposes <tt class="computeroutput">std::list<int>::assign()</tt> to Python:
 

 
@@ -178,7 +178,7 @@
 ;
</pre>

- Now in Python, we can assign any integer sequence to <code class="computeroutput">list_int</code>
+ Now in Python, we can assign any integer sequence to <tt class="computeroutput">list_int</tt>
 objects:

Modified: branches/release/libs/python/doc/tutorial/doc/html/python/object.html
==============================================================================
--- branches/release/libs/python/doc/tutorial/doc/html/python/object.html (original)
+++ branches/release/libs/python/doc/tutorial/doc/html/python/object.html 2008-03-24 19:02:57 EDT (Mon, 24 Mar 2008)
@@ -1,9 +1,9 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Object Interface</title>
+<title> Object Interface</title>
<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<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="functions.html" title="Functions">
@@ -12,10 +12,10 @@
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
</tr></table>
<hr>
@@ -35,13 +35,13 @@
 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 <code class="literal">object</code>. We will see in this
+ are just instances of class <tt class="literal">object</tt>. We will see in this
 chapter how to deal with Python objects.
 

 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++ <code class="literal">object</code>s are as close as possible to Python. This should
+ C++ <tt class="literal">object</tt>s are as close as possible to Python. This should
 minimize the learning curve significantly.
 

@@ -51,10 +51,10 @@
<div class="titlepage"><div><div><h3 class="title">
<a name="python.basic_interface"></a>Basic Interface</h3></div></div></div>

- 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
+ 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
 can in fact be explicitly constructed from any C++ object.
 

@@ -99,7 +99,7 @@
<div class="titlepage"><div><div><h3 class="title">
<a name="python.derived_object_types"></a>Derived Object types</h3></div></div></div>

- Boost.Python comes with a set of derived <code class="literal">object</code> types
+ Boost.Python comes with a set of derived <tt class="literal">object</tt> types
 corresponding to that of Python's:
 
<div class="itemizedlist"><ul type="disc">
@@ -123,32 +123,32 @@
 </li>
</ul></div>

- These derived <code class="literal">object</code> types act like real Python types.
+ These derived <tt class="literal">object</tt> types act like real Python types.
 For instance:
 
<pre class="programlisting">
str(1) ==> "1"
</pre>

- 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:
+ 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:
 
<pre class="programlisting">
d.keys()
</pre>

- <code class="literal">make_tuple</code> is provided for declaring tuple literals.
+ <tt class="literal">make_tuple</tt> is provided for declaring tuple literals.
 Example:
 
<pre class="programlisting">
make_tuple(123, 'D', "Hello, World", 0.0);
</pre>

- In C++, when Boost.Python <code class="literal">object</code>s are used as arguments
+ In C++, when Boost.Python <tt class="literal">object</tt>s are used as arguments
 to functions, subtype matching is required. For example, when a function
- <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.
+ <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.
 
<pre class="programlisting">
void f(str name)
@@ -172,18 +172,15 @@
object msg = "%s is bigger than %s" % make_tuple(NAME,name);
</pre>

- 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
+ 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
 do that in std C++.
 
-<div class="sidebar">
-
-
- <img src="../images/alert.png" alt="alert"> Beware the common pitfall
+<div class="sidebar">
+ <img src="../images/alert.png" alt="alert"> Beware the common pitfall
 of forgetting that the constructors of most of Python's mutable types make
 copies, just as in Python.
- 
-</div>
+ </div>

 Python:
 
@@ -198,12 +195,12 @@
dict d(x.attr("__dict__")); // copies x.__dict__
d['whatever'] = 3; // modifies the copy
</pre>
-<a name="derived_object_types.class__lt_t_gt__as_objects"></a><h3>
-<a name="id2647133"></a>
+<a name="derived_object_types.class__lt_t_gt__as_objects"></a><h2>
+<a name="id469744"></a>
 class_<T> as objects
- </h3>
+ </h2>

- Due to the dynamic nature of Boost.Python objects, any <code class="literal">class_<T></code>
+ Due to the dynamic nature of Boost.Python objects, any <tt class="literal">class_<T></tt>
 may also be one of these types! The following code snippet wraps the class
 (type) object.
 
@@ -225,15 +222,15 @@
<a name="python.extracting_c___objects"></a>Extracting C++ objects</h3></div></div></div>

 At some point, we will need to get C++ values out of object instances. This
- can be achieved with the <code class="literal">extract<T></code> function. Consider
+ can be achieved with the <tt class="literal">extract<T></tt> function. Consider
 the following:
 
<pre class="programlisting">
double x = o.attr("length"); // compile error
</pre>

- 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
+ 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
 we wanted to do above can be achieved by writing:
 
<pre class="programlisting">
@@ -243,14 +240,14 @@
</pre>

 The first line attempts to extract the "length" attribute of the
- Boost.Python <code class="literal">object</code>. The second line attempts to extract
- the <code class="literal">Vec2</code> object from held by the Boost.Python <code class="literal">object</code>.
+ Boost.Python <tt class="literal">object</tt>. The second line attempts to extract
+ the <tt class="literal">Vec2</tt> object from held by the Boost.Python <tt class="literal">object</tt>.
 

 Take note that we said "attempt to" above. What if the Boost.Python
- <code class="literal">object</code> does not really hold a <code class="literal">Vec2</code>
+ <tt class="literal">object</tt> does not really hold a <tt class="literal">Vec2</tt>
 type? This is certainly a possibility considering the dynamic nature of Python
- <code class="literal">object</code>s. To be on the safe side, if the C++ type can't
+ <tt class="literal">object</tt>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:
 
@@ -260,7 +257,7 @@
 Vec2& v = x(); ...
</pre>

- <img src="../images/tip.png" alt="tip"> The astute reader might have noticed that the <code class="literal">extract<T></code>
+ <img src="../images/tip.png" alt="tip"> The astute reader might have noticed that the <tt class="literal">extract<T></tt>
 facility in fact solves the mutable copying problem:
 
<pre class="programlisting">
@@ -273,8 +270,8 @@
<a name="python.enums"></a>Enums</h3></div></div></div>

 Boost.Python has a nifty facility to capture and wrap C++ enums. While Python
- 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
+ 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
 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:
@@ -293,8 +290,8 @@
</pre>

 can be used to expose to Python. The new enum type is created in the current
- <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>
+ <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>
 type which is associated with the C++ type passed as its first parameter.
 
<div class="note"><table border="0" summary="Note">
@@ -302,9 +299,9 @@
<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 align="left" valign="top">
+<tr><td colspan="2" align="left" valign="top">

- what is a scope?
+ what is a scope?
 

 The scope is a class that has an associated global Python object which

Modified: branches/release/libs/python/doc/tutorial/doc/html/python/techniques.html
==============================================================================
--- branches/release/libs/python/doc/tutorial/doc/html/python/techniques.html (original)
+++ branches/release/libs/python/doc/tutorial/doc/html/python/techniques.html 2008-03-24 19:02:57 EDT (Mon, 24 Mar 2008)
@@ -1,20 +1,20 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>General Techniques</title>
+<title> General Techniques</title>
<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<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">
+<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>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
</tr></table>
<hr>
@@ -50,7 +50,7 @@

 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)
- <code class="literal">sounds</code>. Our library already has a neat C++ namespace hierarchy,
+ <tt class="literal">sounds</tt>. Our library already has a neat C++ namespace hierarchy,
 like so:
 
<pre class="programlisting">
@@ -93,18 +93,18 @@
}
</pre>

- 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>.
+ 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>.
 
<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 align="left" valign="top">
- The extension <code class="literal">.pyd</code> is used for python extension modules,
+<tr><td colspan="2" align="left" valign="top">
+ The extension <tt class="literal">.pyd</tt> is used for python extension modules,
 which are just shared libraries. Using the default for your system, like
- <code class="literal">.so</code> for Unix and <code class="literal">.dll</code> for Windows,
+ <tt class="literal">.so</tt> for Unix and <tt class="literal">.dll</tt> for Windows,
 works just as well.
 </td></tr>
</table></div>
@@ -118,12 +118,12 @@
 io.pyd
</pre>

- 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
+ 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
 file, but can also perform some magic, that will be shown later.
 

- Now our package is ready. All the user has to do is put <code class="literal">sounds</code>
+ Now our package is ready. All the user has to do is put <tt class="literal">sounds</tt>
 into his PYTHONPATH
 and fire up the interpreter:
 
@@ -162,7 +162,7 @@
</pre>

 Note that we added an underscore to the module name. The filename will have
- to be changed to <code class="literal">_core.pyd</code> as well, and we do the same
+ to be changed to <tt class="literal">_core.pyd</tt> as well, and we do the same
 to the other extension modules. Now, we change our package hierarchy like
 so:
 
@@ -190,11 +190,11 @@
>>> sounds.core._core.foo(...)
</pre>

- 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
+ 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
 can be accessed directly by the user. So, all we have to do is bring the
- 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">soundscore__init__.py</code>:
+ 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">soundscore__init__.py</tt>:
 
<pre class="programlisting">
from _core import *
@@ -211,10 +211,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 pure
- 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
+ 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
 function:
 
<pre class="programlisting">
@@ -225,14 +225,14 @@
 return s
</pre>

- Next, we add this line to <code class="literal">soundsfilters__init__.py</code>:
+ Next, we add this line to <tt class="literal">soundsfilters__init__.py</tt>:
 
<pre class="programlisting">
from echo_noise import echo_noise
</pre>

 And that's it. The user now accesses this function like any other function
- from the <code class="literal">filters</code> package:
+ from the <tt class="literal">filters</tt> package:
 
<pre class="programlisting">
>>> import sounds.filters
@@ -266,7 +266,7 @@
 

 We can do the same with classes that were wrapped with Boost.Python. Suppose
- we have a class <code class="literal">point</code> in C++:
+ we have a class <tt class="literal">point</tt> in C++:
 

 
@@ -279,8 +279,8 @@
}
</pre>

- 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>:
+ 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>:
 

 
@@ -295,7 +295,7 @@
point.__str__ = point_str
</pre>

- All point instances created from C++ will
+ All point instances created from C++ will
 also have this member function! This technique has several advantages:
 
<div class="itemizedlist"><ul type="disc">
@@ -394,7 +394,7 @@
}
</pre>

- Now you create a file <code class="literal">main.cpp</code>, which contains the <code class="literal">BOOST_PYTHON_MODULE</code>
+ Now you create a file <tt class="literal">main.cpp</tt>, which contains the <tt class="literal">BOOST_PYTHON_MODULE</tt>
 macro, and call the various export functions inside it.
 
<pre class="programlisting">
@@ -435,9 +435,9 @@
<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 align="left" valign="top">
+<tr><td colspan="2" align="left" valign="top">
 If you're exporting your classes with Pyste,
- take a look at the <code class="literal">--multiple</code> option, that generates
+ take a look at the <tt class="literal">--multiple</tt> option, that generates
 the wrappers in various files as demonstrated here.
 </td></tr>
</table></div>
@@ -446,7 +446,7 @@
<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 align="left" valign="top">
+<tr><td colspan="2" align="left" valign="top">
 This method is useful too if you are getting the error message "fatal
 error C1204:Compiler limit:internal structure overflow"
 when compiling a large source file, as explained in the FAQ.

Next message: joel_at_[hidden]: "[Boost-commit] svn:boost r43849 - branches/release/libs/python/doc/tutorial/doc/html/python"
Previous message: anthony_at_[hidden]: "[Boost-commit] svn:boost r43847 - in trunk/boost/thread: . detail"

Date view	Thread view	Subject view	Author view

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