Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r49867 - in trunk/libs/python/doc/tutorial/doc: . html html/python
From: joel_at_[hidden]
Date: 2008-11-21 22:25:42

Next message: garcia_at_[hidden]: "[Boost-commit] svn:boost r49868 - website/public_html/live/community"
Previous message: gennadiy.rozental_at_[hidden]: "[Boost-commit] svn:boost r49866 - trunk/libs/test"

Author: djowel
Date: 2008-11-21 22:25:41 EST (Fri, 21 Nov 2008)
New Revision: 49867
URL: http://svn.boost.org/trac/boost/changeset/49867

Log:
Cosmetic fixes (improper links)
Text files modified:
   trunk/libs/python/doc/tutorial/doc/html/index.html | 21 +++----
   trunk/libs/python/doc/tutorial/doc/html/python/embedding.html | 51 +++++++----------
   trunk/libs/python/doc/tutorial/doc/html/python/exception.html | 12 +--
   trunk/libs/python/doc/tutorial/doc/html/python/exposing.html | 115 +++++++++++++--------------------------
   trunk/libs/python/doc/tutorial/doc/html/python/functions.html | 112 +++++++++++++-------------------------
   trunk/libs/python/doc/tutorial/doc/html/python/hello.html | 26 ++++++--
   trunk/libs/python/doc/tutorial/doc/html/python/iterators.html | 27 +++-----
   trunk/libs/python/doc/tutorial/doc/html/python/object.html | 65 ++++++++--------------
   trunk/libs/python/doc/tutorial/doc/html/python/techniques.html | 66 ++++++++--------------
   trunk/libs/python/doc/tutorial/doc/tutorial.qbk | 8 +-
   10 files changed, 194 insertions(+), 309 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 2008-11-21 22:25:41 EST (Fri, 21 Nov 2008)
@@ -10,10 +10,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>
@@ -31,7 +31,7 @@
<div>Copyright © 2002-2005 Joel
 de Guzman, David Abrahams</div>
<div><div class="legalnotice">
-<a name="id455917"></a>
+<a name="id457106"></a>
 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>)
@@ -94,15 +94,14 @@
 (IDL).
 
<a name="quickstart.hello_world"></a><h2>
-<a name="id385257"></a>
+<a name="id386707"></a>
 Hello World
 </h2>

 Following C/C++ tradition, let's start with the "hello, world". A
 C++ Function:
 
-<pre class="programlisting">
-char const* greet()
+<pre class="programlisting">char const* greet()
{
 return "hello, world";
}
@@ -110,8 +109,7 @@

 can be exposed to Python by writing a Boost.Python wrapper:
 
-<pre class="programlisting">
-#include <boost/python.hpp>
+<pre class="programlisting">#include <boost/python.hpp>

BOOST_PYTHON_MODULE(hello_ext)
{
@@ -125,8 +123,7 @@
 

 
-<pre class="programlisting">
->>> import hello_ext
+<pre class="programlisting">>>> import hello_ext
>>> print hello.greet()
hello, world
</pre>
@@ -145,7 +142,7 @@
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: November 07, 2007 at 03:34:24 GMT</td>
+<td align="left">Last revised: November 22, 2008 at 03:24:11 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

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 2008-11-21 22:25:41 EST (Fri, 21 Nov 2008)
@@ -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>
@@ -40,7 +40,7 @@
 Python/C API at all. So stay tuned... <img src="../images/smiley.png" alt="smiley">
 
<a name="embedding.building_embedded_programs"></a><h2>
-<a name="id471171"></a>
+<a name="id472330"></a>
 Building embedded programs
 </h2>

@@ -82,7 +82,7 @@
 <find-library>$(PYTHON_EMBEDDED_LIBRARY) ;
</pre>
<a name="embedding.getting_started"></a><h2>
-<a name="id471276"></a>
+<a name="id472435"></a>
 Getting started
 </h2>

@@ -130,23 +130,22 @@
<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 <tt class="literal">PyObject</tt>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
+ 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
 of C++ exceptions. Fortunately Boost.Python provides the handle
 and object class templates to
 automate the process.
 
<a name="using_the_interpreter.running_python_code"></a><h2>
-<a name="id471439"></a>
+<a name="id472601"></a>
 Running Python code
 </h2>

 Boost.python provides three related functions to run Python code from C++.
 
-<pre class="programlisting">
-object eval(str expression, object globals = object(), object locals = object())
+<pre class="programlisting">object eval(str expression, object globals = object(), object locals = object())
object exec(str code, object globals = object(), object locals = object())
object exec_file(str filename, object globals = object(), object locals = object())
</pre>
@@ -165,8 +164,7 @@

 Boost.python provides a function to import a module:
 
-<pre class="programlisting">
-object import(str name)
+<pre class="programlisting">object import(str name)
</pre>

 import imports a python module (potentially loading it into the running process
@@ -176,8 +174,7 @@
 Let's import the <tt class="literal">_main_</tt>
 module and run some Python code in its namespace:
 
-<pre class="programlisting">
-object main_module = import("__main__");
+<pre class="programlisting">object main_module = import("__main__");
object main_namespace = main_module.attr("__dict__");

object ignored = exec("hello = file('hello.txt', 'w')\n"
@@ -190,7 +187,7 @@
 a phrase that is well-known in programming circles.
 
<a name="using_the_interpreter.manipulating_python_objects"></a><h2>
-<a name="id472027"></a>
+<a name="id473185"></a>
 Manipulating Python objects
 </h2>

@@ -200,8 +197,7 @@
 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">
-object main_module = import("__main__");
+<pre class="programlisting">object main_module = import("__main__");
object main_namespace = main_module.attr("__dict__");
object ignored = exec("result = 5 ** 2", main_namespace);
int five_squared = extract<int>(main_namespace["result"]);
@@ -212,20 +208,18 @@
 this variable from the dictionary. Another way to achieve the same result
 is to use eval instead, which returns the result directly:
 
-<pre class="programlisting">
-object result = eval("5 ** 2");
+<pre class="programlisting">object result = eval("5 ** 2");
int five_squared = extract<int>(result);
</pre>
<a name="using_the_interpreter.exception_handling"></a><h2>
-<a name="id472399"></a>
+<a name="id473554"></a>
 Exception handling
 </h2>

 If an exception occurs in the evaluation of the python expression, error_already_set
 is thrown:
 
-<pre class="programlisting">
-try
+<pre class="programlisting">try
{
 object result = eval("5/0");
 // execution will never get here:
@@ -240,14 +234,13 @@
 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.
- This can be as simple as calling [@http:/www.python.org/doc/api/exceptionHandling.html#l2h-70
- PyErr_Print()] to print the exception's traceback to the console, or comparing
- the type of the exception with those of the <a href="http://www.python.org/doc/api/standardExceptions.html" target="_top">standard
+ handling functions</a> of the Python C API in your catch-statement. This
+ can be as simple as calling PyErr_Print()
+ to print the exception's traceback to the console, or comparing the type
+ of the exception with those of the <a href="http://www.python.org/doc/api/standardExceptions.html" target="_top">standard
 exceptions</a>:
 
-<pre class="programlisting">
-catch(error_already_set const &)
+<pre class="programlisting">catch(error_already_set const &)
{
 if (PyErr_ExceptionMatches(PyExc_ZeroDivisionError))
 {

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 2008-11-21 22:25:41 EST (Fri, 21 Nov 2008)
@@ -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>
@@ -30,14 +30,12 @@
 is the point where C++ meets Python. Boost.Python provides a default exception
 handler that translates selected standard exceptions, then gives up:
 
-<pre class="programlisting">
-raise RuntimeError, 'unidentifiable C++ Exception'
+<pre class="programlisting">raise RuntimeError, 'unidentifiable C++ Exception'
</pre>

 Users may provide custom translation. Here's an example:
 
-<pre class="programlisting">
-struct PodBayDoorException;
+<pre class="programlisting">struct PodBayDoorException;
void translator(PodBayDoorException const& x) {
 PyErr_SetString(PyExc_UserWarning, "I'm sorry Dave...");
}

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 2008-11-21 22:25:41 EST (Fri, 21 Nov 2008)
@@ -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>
@@ -40,8 +40,7 @@

 Consider a C++ class/struct that we want to expose to Python:
 
-<pre class="programlisting">
-struct World
+<pre class="programlisting">struct World
{
 void set(std::string msg) { this->msg = msg; }
 std::string greet() { return msg; }
@@ -51,8 +50,7 @@

 We can expose this to Python by writing a corresponding Boost.Python C++ Wrapper:
 
-<pre class="programlisting">
-#include <boost/python.hpp>
+<pre class="programlisting">#include <boost/python.hpp>
using namespace boost::python;

BOOST_PYTHON_MODULE(hello)
@@ -71,8 +69,7 @@
 

 
-<pre class="programlisting">
->>> import hello
+<pre class="programlisting">>>> import hello
>>> planet = hello.World()
>>> planet.set('howdy')
>>> planet.greet()
@@ -87,8 +84,7 @@
 exposes the default constructor by default, which is why we were able to
 write
 
-<pre class="programlisting">
->>> planet = hello.World()
+<pre class="programlisting">>>> planet = hello.World()
</pre>

 We may wish to wrap a class with a non-default constructor. Let us build
@@ -96,8 +92,7 @@
 

 
-<pre class="programlisting">
-struct World
+<pre class="programlisting">struct World
{
 World(std::string msg): msg(msg) {} // added constructor
 void set(std::string msg) { this->msg = msg; }
@@ -111,8 +106,7 @@
 We have to tell <tt class="literal">class_<World></tt> about the constructor
 we want to expose instead.
 
-<pre class="programlisting">
-#include <boost/python.hpp>
+<pre class="programlisting">#include <boost/python.hpp>
using namespace boost::python;

BOOST_PYTHON_MODULE(hello)
@@ -133,8 +127,7 @@
 to the <tt class="literal">def()</tt> member function. Say for example we have
 another World constructor taking in two doubles:
 
-<pre class="programlisting">
-class_<World>("World", init<std::string>())
+<pre class="programlisting">class_<World>("World", init<std::string>())
 .def(init<double, double>())
 .def("greet", &World::greet)
 .def("set", &World::set)
@@ -144,8 +137,7 @@
 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:
 
-<pre class="programlisting">
-class_<Abstract>("Abstract", no_init)
+<pre class="programlisting">class_<Abstract>("Abstract", no_init)
</pre>

 This actually adds an <tt class="literal">_init_</tt>
@@ -161,8 +153,7 @@
 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
+<pre class="programlisting">struct Var
{
 Var(std::string name) : name(name), value() {}
 std::string const name;
@@ -173,8 +164,7 @@
 Our C++ <tt class="literal">Var</tt> class and its data members can be exposed
 to Python:
 
-<pre class="programlisting">
-class_<Var>("Var", init<std::string>())
+<pre class="programlisting">class_<Var>("Var", init<std::string>())
 .def_readonly("name", &Var::name)
 .def_readwrite("value", &Var::value);
</pre>
@@ -184,8 +174,7 @@
 

 
-<pre class="programlisting">
->>> x = hello.Var('pi')
+<pre class="programlisting">>>> x = hello.Var('pi')
>>> x.value = 3.14
>>> print x.name, 'is around', x.value
pi is around 3.14
@@ -194,8 +183,7 @@
 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
+<pre class="programlisting">>>> x.name = 'e' # can't change name
Traceback (most recent call last):
 File "<stdin>", line 1, in #
AttributeError: can#t set attribute
@@ -212,8 +200,7 @@
 

 
-<pre class="programlisting">
-struct Num
+<pre class="programlisting">struct Num
{
 Num();
 float get() const;
@@ -227,8 +214,7 @@
 can just be a different syntax for a method call. Wrapping our <tt class="literal">Num</tt>
 class using Boost.Python:
 
-<pre class="programlisting">
-class_<Num>("Num")
+<pre class="programlisting">class_<Num>("Num")
 .add_property("rovalue", &Num::get)
 .add_property("value", &Num::get, &Num::set);
</pre>
@@ -237,8 +223,7 @@
 

 
-<pre class="programlisting">
->>> x = Num()
+<pre class="programlisting">>>> x = Num()
>>> x.value = 3.14
>>> x.value, x.rovalue
(3.14, 3.14)
@@ -251,8 +236,7 @@
 

 
-<pre class="programlisting">
-.add_property("rovalue", &Num::get)
+<pre class="programlisting">.add_property("rovalue", &Num::get)
</pre>
</div>
<div class="section" lang="en">
@@ -268,24 +252,21 @@

 Consider this trivial inheritance structure:
 
-<pre class="programlisting">
-struct Base { virtual ~Base(); };
+<pre class="programlisting">struct Base { virtual ~Base(); };
struct Derived : Base {};
</pre>

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

 We've seen how we can wrap the base class <tt class="literal">Base</tt>:
 
-<pre class="programlisting">
-class_<Base>("Base")
+<pre class="programlisting">class_<Base>("Base")
 /*...*/
 ;
</pre>
@@ -293,8 +274,7 @@
 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")
+<pre class="programlisting">class_<Derived, bases<Base> >("Derived")
 /*...*/
 ;
</pre>
@@ -317,8 +297,7 @@
 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);
+<pre class="programlisting">def("b", b);
def("d", d);
def("factory", factory);
</pre>
@@ -331,8 +310,7 @@
 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">
-// Tell Python to take ownership of factory's result
+<pre class="programlisting">// Tell Python to take ownership of factory's result
def("factory", factory,
 return_value_policy<manage_new_object>());
</pre>
@@ -345,8 +323,7 @@
 through virtual functions. Continuing our example, let us add a virtual function
 to our <tt class="literal">Base</tt> class:
 
-<pre class="programlisting">
-struct Base
+<pre class="programlisting">struct Base
{
 virtual ~Base() {}
 virtual int f() = 0;
@@ -364,8 +341,7 @@
 that will unintrusively hook into the virtual functions so that a Python
 override may be called:
 
-<pre class="programlisting">
-struct BaseWrap : Base, wrapper<Base>
+<pre class="programlisting">struct BaseWrap : Base, wrapper<Base>
{
 int f()
 {
@@ -397,8 +373,7 @@

 Finally, exposing <tt class="computeroutput">Base</tt>:
 
-<pre class="programlisting">
-class_<BaseWrap, boost::noncopyable>("Base")
+<pre class="programlisting">class_<BaseWrap, boost::noncopyable>("Base")
 .def("f", pure_virtual(&Base::f))
 ;
</pre>
@@ -437,8 +412,7 @@
 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:
 
-<pre class="programlisting">
-struct Base
+<pre class="programlisting">struct Base
{
 virtual int f() = 0;
};
@@ -447,8 +421,7 @@
 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
+<pre class="programlisting">struct Base
{
 virtual ~Base() {}
 virtual int f() { return 0; }
@@ -457,8 +430,7 @@

 We wrap it this way:
 
-<pre class="programlisting">
-struct BaseWrap : Base, wrapper<Base>
+<pre class="programlisting">struct BaseWrap : Base, wrapper<Base>
{
 int f()
 {
@@ -490,8 +462,7 @@

 Finally, exposing:
 
-<pre class="programlisting">
-class_<BaseWrap, boost::noncopyable>("Base")
+<pre class="programlisting">class_<BaseWrap, boost::noncopyable>("Base")
 .def("f", &Base::f, &BaseWrap::default_f)
 ;
</pre>
@@ -506,8 +477,7 @@
 

 
-<pre class="programlisting">
->>> base = Base()
+<pre class="programlisting">>>> base = Base()
>>> class Derived(Base):
... def f(self):
... return 42
@@ -517,15 +487,13 @@

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

 Calling <tt class="literal">derived.f()</tt>:
 
-<pre class="programlisting">
->>> derived.f()
+<pre class="programlisting">>>> derived.f()
42
</pre>
</div>
@@ -533,7 +501,7 @@
<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="id461460"></a>
+<a name="id462548"></a>
 Python Operators
 </h2>

@@ -547,8 +515,7 @@
 

 
-<pre class="programlisting">
-class FilePos { /*...*/ };
+<pre class="programlisting">class FilePos { /*...*/ };

FilePos operator+(FilePos, int);
FilePos operator+(int, FilePos);
@@ -562,8 +529,7 @@
 The class and the various operators can be mapped to Python rather easily
 and intuitively:
 
-<pre class="programlisting">
-class_<FilePos>("FilePos")
+<pre class="programlisting">class_<FilePos>("FilePos")
 .def(self + int()) // __add__
 .def(int() + self) // __radd__
 .def(self - self) // __sub__
@@ -582,7 +548,7 @@
 expressions".
 
<a name="class_operators_special_functions.special_methods"></a><h2>
-<a name="id462216"></a>
+<a name="id463302"></a>
 Special Methods
 </h2>

@@ -592,8 +558,7 @@
 wrap C++ functions that correspond to these Python special functions.
 Example:
 
-<pre class="programlisting">
-class Rational
+<pre class="programlisting">class Rational
{ public: operator double() const; };

Rational pow(Rational, Rational);

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 2008-11-21 22:25:41 EST (Fri, 21 Nov 2008)
@@ -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>
@@ -87,16 +87,14 @@
 so Boost.Python must deal with them. To do this, it may need your help. Consider
 the following C++ function:
 
-<pre class="programlisting">
-X& f(Y& y, Z* z);
+<pre class="programlisting">X& f(Y& y, Z* z);
</pre>

 How should the library wrap this function? A naive approach builds a Python
 X object around result reference. This strategy might or might not work out.
 Here's an example where it didn't
 
-<pre class="programlisting">
->>> x = f(y, z) # x refers to some C++ X
+<pre class="programlisting">>>> x = f(y, z) # x refers to some C++ X
>>> del y
>>> x.some_method() # CRASH!
</pre>
@@ -106,8 +104,7 @@

 Well, what if f() was implemented as shown below:
 
-<pre class="programlisting">
-X& f(Y& y, Z* z)
+<pre class="programlisting">X& f(Y& y, Z* z)
{
 y.z = z;
 return y.x;
@@ -145,8 +142,7 @@
 

 
-<pre class="programlisting">
->>> f(y, z).set(42) # Result disappears
+<pre class="programlisting">>>> f(y, z).set(42) # Result disappears
>>> y.x.get() # No crash, but still bad
3.14
</pre>
@@ -160,8 +156,7 @@
 

 
-<pre class="programlisting">
-struct Y
+<pre class="programlisting">struct Y
{
 X x; Z* z;
 int z_value() { return z->value(); }
@@ -171,16 +166,14 @@
 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">
->>> x = f(y, z) # y refers to z
+<pre class="programlisting">>>> x = f(y, z) # y refers to z
>>> del z # Kill the z object
>>> y.z_value() # CRASH!
</pre>

 For reference, here's the implementation of <tt class="literal">f</tt> again:
 
-<pre class="programlisting">
-X& f(Y& y, Z* z)
+<pre class="programlisting">X& f(Y& y, Z* z)
{
 y.z = z;
 return y.x;
@@ -212,7 +205,7 @@
<li>BOOM!</li>
</ol></div>
<a name="call_policies.call_policies"></a><h2>
-<a name="id464076"></a>
+<a name="id465291"></a>
 Call Policies
 </h2>

@@ -220,8 +213,7 @@
 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">
-def("f", f,
+<pre class="programlisting">def("f", f,
 return_internal_reference<1,
 with_custodian_and_ward<1, 2> >());
</pre>
@@ -229,8 +221,7 @@
 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 class="programlisting">return_internal_reference<1
</pre>

 Informs Boost.Python that the first argument, in our case <tt class="literal">Y&
@@ -239,8 +230,7 @@
 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 class="programlisting">with_custodian_and_ward<1, 2>
</pre>

 Informs Boost.Python that the lifetime of the argument indicated by ward
@@ -252,8 +242,7 @@
 It is also important to note that we have defined two policies above. Two
 or more policies can be composed by chaining. Here's the general syntax:
 
-<pre class="programlisting">
-policy1<args...,
+<pre class="programlisting">policy1<args...,
 policy2<args...,
 policy3<args...> > >
</pre>
@@ -317,8 +306,7 @@

 We have here our C++ class:
 
-<pre class="programlisting">
-struct X
+<pre class="programlisting">struct X
{
 bool f(int a)
 {
@@ -345,8 +333,7 @@
 Class X has 4 overloaded functions. We will start by introducing some member
 function pointer variables:
 
-<pre class="programlisting">
-bool (X::*fx1)(int) = &X::f;
+<pre class="programlisting">bool (X::*fx1)(int) = &X::f;
bool (X::*fx2)(int, double) = &X::f;
bool (X::*fx3)(int, double, char)= &X::f;
int (X::*fx4)(int, int, int) = &X::f;
@@ -354,8 +341,7 @@

 With these in hand, we can proceed to define and wrap this for Python:
 
-<pre class="programlisting">
-.def("f", fx1)
+<pre class="programlisting">.def("f", fx1)
.def("f", fx2)
.def("f", fx3)
.def("f", fx4)
@@ -369,30 +355,26 @@
 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 class="programlisting">int f(int, double = 3.14, char const* = "hello");
</pre>

 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 class="programlisting">int(*g)(int,double,char const*) = f; // defaults lost!
</pre>

 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">
-def("f", f); // defaults lost!
+<pre class="programlisting">def("f", f); // defaults lost!
</pre>

 Because of this, when wrapping C++ code, we had to resort to manual wrapping
 as outlined in the previous section,
 or writing thin wrappers:
 
-<pre class="programlisting">
-// write "thin wrappers"
+<pre class="programlisting">// write "thin wrappers"
int f1(int x) { f(x); }
int f2(int x, double y) { f(x,y); }

@@ -415,14 +397,13 @@
 </li>
</ul></div>
<a name="default_arguments.boost_python_function_overloads"></a><h2>
-<a name="id466117"></a>
+<a name="id467317"></a>
 BOOST_PYTHON_FUNCTION_OVERLOADS
 </h2>

 Boost.Python now has a way to make it easier. For instance, given a function:
 
-<pre class="programlisting">
-int foo(int a, char b = 1, unsigned c = 2, double d = 3)
+<pre class="programlisting">int foo(int a, char b = 1, unsigned c = 2, double d = 3)
{
 /*...*/
}
@@ -430,8 +411,7 @@

 The macro invocation:
 
-<pre class="programlisting">
-BOOST_PYTHON_FUNCTION_OVERLOADS(foo_overloads, foo, 1, 4)
+<pre class="programlisting">BOOST_PYTHON_FUNCTION_OVERLOADS(foo_overloads, foo, 1, 4)
</pre>

 will automatically create the thin wrappers for us. This macro will create
@@ -441,11 +421,10 @@
 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 class="programlisting">def("foo", foo, foo_overloads());
</pre>
<a name="default_arguments.boost_python_member_function_overloads"></a><h2>
-<a name="id466436"></a>
+<a name="id467632"></a>
 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS
 </h2>

@@ -460,8 +439,7 @@
 may be used to automatically create the thin wrappers for wrapping member
 functions. Let's have an example:
 
-<pre class="programlisting">
-struct george
+<pre class="programlisting">struct george
{
 void
 wack_em(int a, int b = 0, char c = 'x')
@@ -473,8 +451,7 @@

 The macro invocation:
 
-<pre class="programlisting">
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(george_overloads, wack_em, 1, 3)
+<pre class="programlisting">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(george_overloads, wack_em, 1, 3)
</pre>

 will generate a set of thin wrappers for george's <tt class="literal">wack_em</tt>
@@ -483,15 +460,14 @@
 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());
+<pre class="programlisting">.def("wack_em", &george::wack_em, george_overloads());
</pre>

 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><h2>
-<a name="id466799"></a>
+<a name="id467992"></a>
 init and optional
 </h2>

@@ -499,8 +475,7 @@
 arguments or a sequence of overloads. Remember <tt class="literal">init<...></tt>?
 For example, given a class X with a constructor:
 
-<pre class="programlisting">
-struct X
+<pre class="programlisting">struct X
{
 X(int a, char b = 'D', std::string c = "constructor", double d = 0.0);
 /*...*/
@@ -509,8 +484,7 @@

 You can easily add this constructor to Boost.Python in one shot:
 
-<pre class="programlisting">
-.def(init<int, optional<char, std::string, double> >())
+<pre class="programlisting">.def(init<int, optional<char, std::string, double> >())
</pre>

 Notice the use of <tt class="literal">init<...></tt> and <tt class="literal">optional<...></tt>
@@ -526,8 +500,7 @@
 used for overloaded functions and member functions with a common sequence
 of initial arguments. Here is an example:
 
-<pre class="programlisting">
-void foo()
+<pre class="programlisting">void foo()
{
 /*...*/
}
@@ -551,21 +524,19 @@
 Like in the previous section, we can generate thin wrappers for these overloaded
 functions in one-shot:
 
-<pre class="programlisting">
-BOOST_PYTHON_FUNCTION_OVERLOADS(foo_overloads, foo, 0, 3)
+<pre class="programlisting">BOOST_PYTHON_FUNCTION_OVERLOADS(foo_overloads, foo, 0, 3)
</pre>

 Then...
 
-<pre class="programlisting">
-.def("foo", (void(*)(bool, int, char))0, foo_overloads());
+<pre class="programlisting">.def("foo", (void(*)(bool, int, char))0, foo_overloads());
</pre>

 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><h2>
-<a name="id467581"></a>
+<a name="id468767"></a>
 Manual Wrapping
 </h2>

@@ -584,21 +555,18 @@
 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">
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(xf_overloads, f, 1, 4)
+<pre class="programlisting">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(xf_overloads, f, 1, 4)
</pre>

 Create a member function pointers as above for both X::f overloads:
 
-<pre class="programlisting">
-bool (X::*fx1)(int, double, char) = &X::f;
+<pre class="programlisting">bool (X::*fx1)(int, double, char) = &X::f;
int (X::*fx2)(int, int, int) = &X::f;
</pre>

 Then...
 
-<pre class="programlisting">
-.def("f", fx1, xf_overloads());
+<pre class="programlisting">.def("f", fx1, xf_overloads());
.def("f", fx2)
</pre>
</div>

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 2008-11-21 22:25:41 EST (Fri, 21 Nov 2008)
@@ -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>
@@ -26,7 +26,7 @@
<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="id387672"></a>
+<a name="id388718"></a>
 From Start To Finish
 </h2>

@@ -92,7 +92,7 @@
 platforms. The complete list of Bjam executables can be found here.
 
<a name="hello.let_s_jam_"></a><h2>
-<a name="id386265"></a>
+<a name="id387300"></a>
 Let's Jam!
 </h2>

@@ -108,7 +108,7 @@
 you going.
 
<a name="hello.running_bjam"></a><h2>
-<a name="id386322"></a>
+<a name="id387357"></a>
 Running bjam
 </h2>

@@ -156,8 +156,7 @@

 Finally:
 
-<pre class="programlisting">
-bjam
+<pre class="programlisting">bjam
</pre>

 It should be building now:
@@ -180,6 +179,17 @@
 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) after the test has concluded to conserve disk space. To keep bjam from
+ doing that, pass --preserve-test-targets to bjam.
+ </td></tr>
+</table></div>
<div class="blockquote"><blockquote class="blockquote">

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 2008-11-21 22:25:41 EST (Fri, 21 Nov 2008)
@@ -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>
@@ -64,8 +64,7 @@
 

 
-<pre class="programlisting">
-iter = x.__iter__() # get iterator
+<pre class="programlisting">iter = x.__iter__() # get iterator
try:
 while 1:
 y = iter.next() # get each item
@@ -79,16 +78,14 @@
 

 
-<pre class="programlisting">
-object get_iterator = iterator<vector<int> >();
+<pre class="programlisting">object get_iterator = iterator<vector<int> >();
object iter = get_iterator(v);
object first = iter.next();
</pre>

 Or for use in class_<>:
 
-<pre class="programlisting">
-.def("__iter__", iterator<vector<int> >())
+<pre class="programlisting">.def("__iter__", iterator<vector<int> >())
</pre>

 range
@@ -134,8 +131,7 @@
 

 
-<pre class="programlisting">
-f = Field()
+<pre class="programlisting">f = Field()
for x in f.pions:
 smash(x)
for y in f.bogons:
@@ -146,8 +142,7 @@
 

 
-<pre class="programlisting">
-class_<F>("Field")
+<pre class="programlisting">class_<F>("Field")
 .property("pions", range(&F::p_begin, &F::p_end))
 .property("bogons", range(&F::b_begin, &F::b_end));
</pre>
@@ -163,8 +158,7 @@
 

 
-<pre class="programlisting">
-template<typename T>
+<pre class="programlisting">template<typename T>
void list_assign(std::list<T>& l, object o) {
 // Turn a Python sequence into an STL input range
 stl_input_iterator<T> begin(o), end;
@@ -183,8 +177,7 @@
 

 
-<pre class="programlisting">
-x = list_int();
+<pre class="programlisting">x = list_int();
x.assign([1,2,3,4,5])
</pre>
</div>

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 2008-11-21 22:25:41 EST (Fri, 21 Nov 2008)
@@ -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>
@@ -62,8 +62,7 @@
 

 
-<pre class="programlisting">
-def f(x, y):
+<pre class="programlisting">def f(x, y):
 if (y == 'foo'):
 x[3:7] = 'bar'
 else:
@@ -78,8 +77,7 @@
 

 
-<pre class="programlisting">
-object f(object x, object y) {
+<pre class="programlisting">object f(object x, object y) {
 if (y == "foo")
 x.slice(3,7) = "bar";
 else
@@ -126,23 +124,20 @@
 These derived <tt class="literal">object</tt> types act like real Python types.
 For instance:
 
-<pre class="programlisting">
-str(1) ==> "1"
+<pre class="programlisting">str(1) ==> "1"
</pre>

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

 <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 class="programlisting">make_tuple(123, 'D', "Hello, World", 0.0);
</pre>

 In C++, when Boost.Python <tt class="literal">object</tt>s are used as arguments
@@ -150,8 +145,7 @@
 <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)
+<pre class="programlisting">void f(str name)
{
 object n2 = name.attr("upper")(); // NAME = name.upper()
 str NAME = name.upper(); // better
@@ -161,15 +155,13 @@

 In finer detail:
 
-<pre class="programlisting">
-str NAME = name.upper();
+<pre class="programlisting">str NAME = name.upper();
</pre>

 Illustrates that we provide versions of the str type's methods as C++ member
 functions.
 
-<pre class="programlisting">
-object msg = "%s is bigger than %s" % make_tuple(NAME,name);
+<pre class="programlisting">object msg = "%s is bigger than %s" % make_tuple(NAME,name);
</pre>

 Demonstrates that you can write the C++ equivalent of <tt class="literal">"format"
@@ -184,19 +176,17 @@

 Python:
 
-<pre class="programlisting">
->>> d = dict(x.__dict__) # copies x.__dict__
+<pre class="programlisting">>>> d = dict(x.__dict__) # copies x.__dict__
>>> d['whatever'] = 3 # modifies the copy
</pre>

 C++:
 
-<pre class="programlisting">
-dict d(x.attr("__dict__")); // copies x.__dict__
+<pre class="programlisting">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><h2>
-<a name="id469586"></a>
+<a name="id470756"></a>
 class_<T> as objects
 </h2>

@@ -207,8 +197,7 @@

 We can use this to create wrapped instances. Example:
 
-<pre class="programlisting">
-object vec345 = (
+<pre class="programlisting">object vec345 = (
 class_<Vec2>("Vec2", init<double, double>())
 .def_readonly("length", &Point::length)
 .def_readonly("angle", &Point::angle)
@@ -225,16 +214,14 @@
 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 class="programlisting">double x = o.attr("length"); // compile error
</pre>

 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">
-double l = extract<double>(o.attr("length"));
+<pre class="programlisting">double l = extract<double>(o.attr("length"));
Vec2& v = extract<Vec2&>(o);
assert(l == v.length());
</pre>
@@ -251,8 +238,7 @@
 be extracted, an appropriate exception is thrown. To avoid an exception,
 we need to test for extractibility:
 
-<pre class="programlisting">
-extract<Vec2&> x(o);
+<pre class="programlisting">extract<Vec2&> x(o);
if (x.check()) {
 Vec2& v = x(); ...
</pre>
@@ -260,8 +246,7 @@
 <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">
-dict d = extract<dict>(x.attr("__dict__"));
+<pre class="programlisting">dict d = extract<dict>(x.attr("__dict__"));
d["whatever"] = 3; // modifies x.__dict__ !
</pre>
</div>
@@ -276,14 +261,12 @@
 typing to C++'s strong static typing (in C++, ints cannot be implicitly converted
 to enums). To illustrate, given a C++ enum:
 
-<pre class="programlisting">
-enum choice { red, blue };
+<pre class="programlisting">enum choice { red, blue };
</pre>

 the construct:
 
-<pre class="programlisting">
-enum_<choice>("choice")
+<pre class="programlisting">enum_<choice>("choice")
 .value("red", red)
 .value("blue", blue)
 ;
@@ -315,8 +298,7 @@
 

 
-<pre class="programlisting">
->>> my_module.choice.red
+<pre class="programlisting">>>> my_module.choice.red
my_module.choice.red
</pre>

@@ -325,8 +307,7 @@
 

 
-<pre class="programlisting">
-scope in_X = class_<X>("X")
+<pre class="programlisting">scope in_X = class_<X>("X")
 .def( ... )
 .def( ... )
 ;

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 2008-11-21 22:25:41 EST (Fri, 21 Nov 2008)
@@ -11,10 +11,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>
@@ -53,8 +53,7 @@
 <tt class="literal">sounds</tt>. Our library already has a neat C++ namespace hierarchy,
 like so:
 
-<pre class="programlisting">
-sounds::core
+<pre class="programlisting">sounds::core
sounds::io
sounds::filters
</pre>
@@ -62,16 +61,14 @@
 We would like to present this same hierarchy to the Python user, allowing
 him to write code like this:
 
-<pre class="programlisting">
-import sounds.filters
+<pre class="programlisting">import sounds.filters
sounds.filters.echo(...) # echo is a C++ function
</pre>

 The first step is to write the wrapping code. We have to export each module
 separately with Boost.Python, like this:
 
-<pre class="programlisting">
-/* file core.cpp */
+<pre class="programlisting">/* file core.cpp */
BOOST_PYTHON_MODULE(core)
{
 /* export everything in the sounds::core namespace */
@@ -129,8 +126,7 @@
 

 
-<pre class="programlisting">
->>> import sounds.io
+<pre class="programlisting">>>> import sounds.io
>>> import sounds.filters
>>> sound = sounds.io.open('file.mp3')
>>> new_sound = sounds.filters.echo(sound, 1.0)
@@ -152,8 +148,7 @@
 

 
-<pre class="programlisting">
-/* file core.cpp */
+<pre class="programlisting">/* file core.cpp */
BOOST_PYTHON_MODULE(_core)
{
 ...
@@ -185,8 +180,7 @@
 

 
-<pre class="programlisting">
->>> import sounds.core._core
+<pre class="programlisting">>>> import sounds.core._core
>>> sounds.core._core.foo(...)
</pre>

@@ -196,15 +190,13 @@
 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 *
+<pre class="programlisting">from _core import *
</pre>

 We do the same for the other packages. Now the user accesses the functions
 and classes in the extension modules like before:
 
-<pre class="programlisting">
->>> import sounds.filters
+<pre class="programlisting">>>> import sounds.filters
>>> sounds.filters.echo(...)
</pre>

@@ -217,8 +209,7 @@
 a file named <tt class="literal">sounds/filters/echo_noise.py</tt> and code our
 function:
 
-<pre class="programlisting">
-import _filters
+<pre class="programlisting">import _filters
def echo_noise(sound):
 s = _filters.echo(sound)
 s = _filters.noise(sound)
@@ -227,15 +218,13 @@

 Next, we add this line to <tt class="literal">soundsfilters__init__.py</tt>:
 
-<pre class="programlisting">
-from echo_noise import echo_noise
+<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 <tt class="literal">filters</tt> package:
 
-<pre class="programlisting">
->>> import sounds.filters
+<pre class="programlisting">>>> import sounds.filters
>>> sounds.filters.echo_noise(...)
</pre>
</div>
@@ -246,8 +235,7 @@
 Thanks to Python's flexibility, you can easily add new methods to a class,
 even after it was already created:
 
-<pre class="programlisting">
->>> class C(object): pass
+<pre class="programlisting">>>> class C(object): pass
>>>
>>> # a regular function
>>> def C_str(self): return 'A C instance!'
@@ -270,8 +258,7 @@
 

 
-<pre class="programlisting">
-class point {...};
+<pre class="programlisting">class point {...};

BOOST_PYTHON_MODULE(_geom)
{
@@ -284,8 +271,7 @@
 

 
-<pre class="programlisting">
-from _geom import *
+<pre class="programlisting">from _geom import *

# a regular function
def point_str(self):
@@ -317,8 +303,7 @@
 You can even add a little syntactic sugar with the use of metaclasses. Let's
 create a special metaclass that "injects" methods in other classes.
 
-<pre class="programlisting">
-# The one Boost.Python uses for all wrapped classes.
+<pre class="programlisting"># The one Boost.Python uses for all wrapped classes.
# You can use here any class exported by Boost instead of "point"
BoostPythonMetaclass = point.__class__

@@ -341,8 +326,7 @@

 Now let's see how it got:
 
-<pre class="programlisting">
->>> print point()
+<pre class="programlisting">>>> print point()
Point(x=10, y=10)
>>> point().foo()
foo!
@@ -350,8 +334,7 @@

 Another useful idea is to replace constructors with factory functions:
 
-<pre class="programlisting">
-_point = point
+<pre class="programlisting">_point = point

def point(x=0, y=0):
 return _point(x, y)
@@ -374,8 +357,7 @@
 

 
-<pre class="programlisting">
-/* file point.cpp */
+<pre class="programlisting">/* file point.cpp */
#include <point.h>
#include <boost/python.hpp>

@@ -397,8 +379,7 @@
 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">
-void export_point();
+<pre class="programlisting">void export_point();
void export_triangle();

BOOST_PYTHON_MODULE(_geom)
@@ -411,8 +392,7 @@
 Compiling and linking together all this files produces the same result as
 the usual approach:
 
-<pre class="programlisting">
-#include <boost/python.hpp>
+<pre class="programlisting">#include <boost/python.hpp>
#include <point.h>
#include <triangle.h>

Modified: trunk/libs/python/doc/tutorial/doc/tutorial.qbk
==============================================================================
--- trunk/libs/python/doc/tutorial/doc/tutorial.qbk (original)
+++ trunk/libs/python/doc/tutorial/doc/tutorial.qbk 2008-11-21 22:25:41 EST (Fri, 21 Nov 2008)
@@ -1385,10 +1385,10 @@
[section Using the interpreter]

As you probably already know, objects in Python are reference-counted.
-Naturally, the [^PyObject]s of the Python\/C API are also reference-counted.
+Naturally, the [^PyObject]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
-[@http://www.python.org/doc/current/api/refcounts.html by hand]. This is
+automatic in Python, the Python C API requires you to do it
+[@http://www.python.org/doc/current/c-api/refcounting.html by hand]. This is
messy and especially hard to get right in the presence of C++ exceptions.
Fortunately Boost.Python provides the [@../../../v2/handle.html handle] and
[@../../../v2/object.html object] class templates to automate the process.
@@ -1470,7 +1470,7 @@
The [^error_already_set] exception class doesn't carry any information in itself.
To find out more about the Python exception that occurred, you need to use the
[@http://www.python.org/doc/api/exceptionHandling.html exception handling functions]
-of the Python/C API in your catch-statement. This can be as simple as calling
+of the Python C API in your catch-statement. This can be as simple as calling
[@http://www.python.org/doc/api/exceptionHandling.html#l2h-70 PyErr_Print()] to
print the exception's traceback to the console, or comparing the type of the
exception with those of the [@http://www.python.org/doc/api/standardExceptions.html

Next message: garcia_at_[hidden]: "[Boost-commit] svn:boost r49868 - website/public_html/live/community"
Previous message: gennadiy.rozental_at_[hidden]: "[Boost-commit] svn:boost r49866 - trunk/libs/test"

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