This commit was manufactured by cvs2svn to create tag

'Version_1_33_1_beta'.

[SVN r31604]

build/Jamfile

@@ -63,6 +63,7 @@ if [ check-python-config ]
       $(bpl-linkflags)
         <msvc-stlport><release>$(msvc-stlport-workarounds)
         <darwin><*><linkflags>-bind_at_load
+        <gcc-3_3-darwin><*><linkflags>-bind_at_load
       ;
 
   template extension

build/Jamfile.v2

@@ -1,67 +1,39 @@
 import os ;
 import modules ;
 
-# Use a very crude way to sense there python is locatted
+import python ;
 
-
-local PYTHON_PATH = [ modules.peek : PYTHON_PATH ] ;
-
-if [ GLOB /usr/local/include/python2.2 : * ]
-{
-    PYTHON_PATH = /usr/local ;
-}
-else if [ GLOB /usr/include/python2.2 : * ] 
-{
-    PYTHON_PATH = /usr ;
-}
-
-if [ os.name ] in CYGWIN NT
-{
-    lib_condition = <link>shared: ;
-    defines = USE_DL_IMPORT ;
-   
-    # Declare a target for the python interpreter library
-    lib python : : <name>python22 <search>$(PYTHON_PATH)/libs ;
-    PYTHON_LIB = python ;    
-} 
-else 
-{
-   lib python : : <name>python2.2 ;
-   PYTHON_LIB = python ;    
-}
-
-
-
-if $(PYTHON_PATH) {
+if [ python.configured ] {
     
 
 project boost/python
     : source-location ../src
-        : requirements <include>$(PYTHON_PATH)/include
-          $(lib_condition)<library-path>$(PYTHON_PATH)/libs
-            <link>shared:<library>$(PYTHON_LIB)
-            <define>$(defines)
-        : usage-requirements # requirement that will be propageted to *users* of this library
-          <include>$(PYTHON_PATH)/include
+        : requirements 
+	#<include>$(PYTHON_PATH)/include
+        #  $(lib_condition)<library-path>$(PYTHON_PATH)/libs
+        #    <link>shared:<library>$(PYTHON_LIB)
+        #    <define>$(defines)
+        #: usage-requirements # requirement that will be propageted to *users* of this library
+        #  <include>$(PYTHON_PATH)/include
 
 # We have a bug which causes us to conclude that conditionalized
 # properties in this section are not free.
 #          $(lib_condition)<library-path>$(PYTHON_PATH)/lib/python2.2/config
 #            <shared>true:<find-library>$(PYTHON_LIB)
             
-          <library-path>$(PYTHON_PATH)/lib/python2.2/config
-            <library>$(PYTHON_LIB)
+        # <library-path>$(PYTHON_PATH)/lib/python2.2/config
+        #    <library>$(PYTHON_LIB)
     ;
 
 lib boost_python
     : 
     numeric.cpp
-
     list.cpp
     long.cpp
     dict.cpp
     tuple.cpp
     str.cpp
+    slice.cpp
 
     aix_init_module.cpp
     converter/from_python.cpp
@@ -80,8 +52,15 @@ lib boost_python
     object/iterator.cpp
     object_protocol.cpp
     object_operators.cpp
+    wrapper.cpp
     :   <link>static:<define>BOOST_PYTHON_STATIC_LIB 
         <define>BOOST_PYTHON_SOURCE
+	<library>/python//python
     : <link>shared
-      ;
+    ;
+}
+else
+{
+    ECHO "warning: Python location is not configured" ;
+    ECHO "warning: the Boost.Python library won't be built" ;
 }

build/VisualStudio/boost_python.dsp

@@ -175,6 +175,10 @@ SOURCE=..\..\src\converter\registry.cpp
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\src\slice.cpp
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\src\str.cpp
 # End Source File
 # Begin Source File
@@ -185,6 +189,10 @@ SOURCE=..\..\src\tuple.cpp
 
 SOURCE=..\..\src\converter\type_id.cpp
 # End Source File
+# Begin Source File
+
+SOURCE=..\..\src\wrapper.cpp
+# End Source File
 # End Group
 # Begin Group "Header Files"
 

doc/PyConDC_2003/bpl.txt

@@ -1,947 +1 @@
-+++++++++++++++++++++++++++++++++++++++++++
- Building Hybrid Systems with Boost.Python
-+++++++++++++++++++++++++++++++++++++++++++
-
-:Author: David Abrahams
-:Contact: dave@boost-consulting.com
-:organization: `Boost Consulting`_
-:date: $Date$
-
-:Author: Ralf W. Grosse-Kunstleve
-
-:copyright: Copyright David Abrahams and Ralf W. Grosse-Kunstleve 2003. All rights reserved
-
-.. contents:: Table of Contents
-
-.. _`Boost Consulting`: http://www.boost-consulting.com
-
-==========
- Abstract
-==========
-
-Boost.Python is an open source C++ library which provides a concise
-IDL-like interface for binding C++ classes and functions to
-Python. Leveraging the full power of C++ compile-time introspection
-and of recently developed metaprogramming techniques, this is achieved
-entirely in pure C++, without introducing a new syntax.
-Boost.Python's rich set of features and high-level interface make it
-possible to engineer packages from the ground up as hybrid systems,
-giving programmers easy and coherent access to both the efficient
-compile-time polymorphism of C++ and the extremely convenient run-time
-polymorphism of Python.
-
-==============
- Introduction
-==============
-
-Python and C++ are in many ways as different as two languages could
-be: while C++ is usually compiled to machine-code, Python is
-interpreted.  Python's dynamic type system is often cited as the
-foundation of its flexibility, while in C++ static typing is the
-cornerstone of its efficiency. C++ has an intricate and difficult
-compile-time meta-language, while in Python, practically everything
-happens at runtime.
-
-Yet for many programmers, these very differences mean that Python and
-C++ complement one another perfectly.  Performance bottlenecks in
-Python programs can be rewritten in C++ for maximal speed, and
-authors of powerful C++ libraries choose Python as a middleware
-language for its flexible system integration capabilities.
-Furthermore, the surface differences mask some strong similarities:
-
-* 'C'-family control structures (if, while, for...)
-
-* Support for object-orientation, functional programming, and generic
-  programming (these are both *multi-paradigm* programming languages.)
-
-* Comprehensive operator overloading facilities, recognizing the
-  importance of syntactic variability for readability and
-  expressivity.
-
-* High-level concepts such as collections and iterators.
-
-* High-level encapsulation facilities (C++: namespaces, Python: modules)
-  to support the design of re-usable libraries.
-
-* Exception-handling for effective management of error conditions.
-
-* C++ idioms in common use, such as handle/body classes and
-  reference-counted smart pointers mirror Python reference semantics.
-
-Given Python's rich 'C' interoperability API, it should in principle
-be possible to expose C++ type and function interfaces to Python with
-an analogous interface to their C++ counterparts.  However, the
-facilities provided by Python alone for integration with C++ are
-relatively meager.  Compared to C++ and Python, 'C' has only very
-rudimentary abstraction facilities, and support for exception-handling
-is completely missing.  'C' extension module writers are required to
-manually manage Python reference counts, which is both annoyingly
-tedious and extremely error-prone. Traditional extension modules also
-tend to contain a great deal of boilerplate code repetition which
-makes them difficult to maintain, especially when wrapping an evolving
-API.
-
-These limitations have lead to the development of a variety of wrapping
-systems.  SWIG_ is probably the most popular package for the
-integration of C/C++ and Python. A more recent development is SIP_,
-which was specifically designed for interfacing Python with the Qt_
-graphical user interface library.  Both SWIG and SIP introduce their
-own specialized languages for customizing inter-language bindings.
-This has certain advantages, but having to deal with three different
-languages (Python, C/C++ and the interface language) also introduces
-practical and mental difficulties.  The CXX_ package demonstrates an
-interesting alternative.  It shows that at least some parts of
-Python's 'C' API can be wrapped and presented through a much more
-user-friendly C++ interface. However, unlike SWIG and SIP, CXX does
-not include support for wrapping C++ classes as new Python types.
-
-The features and goals of Boost.Python_ overlap significantly with
-many of these other systems.  That said, Boost.Python attempts to
-maximize convenience and flexibility without introducing a separate
-wrapping language.  Instead, it presents the user with a high-level
-C++ interface for wrapping C++ classes and functions, managing much of
-the complexity behind-the-scenes with static metaprogramming.
-Boost.Python also goes beyond the scope of earlier systems by
-providing:
-
-* Support for C++ virtual functions that can be overridden in Python.
-
-* Comprehensive lifetime management facilities for low-level C++
-  pointers and references.
-
-* Support for organizing extensions as Python packages,
-  with a central registry for inter-language type conversions.
-
-* A safe and convenient mechanism for tying into Python's powerful
-  serialization engine (pickle).
-
-* Coherence with the rules for handling C++ lvalues and rvalues that
-  can only come from a deep understanding of both the Python and C++
-  type systems.
-
-The key insight that sparked the development of Boost.Python is that
-much of the boilerplate code in traditional extension modules could be
-eliminated using C++ compile-time introspection.  Each argument of a
-wrapped C++ function must be extracted from a Python object using a
-procedure that depends on the argument type.  Similarly the function's
-return type determines how the return value will be converted from C++
-to Python.  Of course argument and return types are part of each
-function's type, and this is exactly the source from which
-Boost.Python deduces most of the information required.
-
-This approach leads to *user guided wrapping*: as much information is
-extracted directly from the source code to be wrapped as is possible
-within the framework of pure C++, and some additional information is
-supplied explicitly by the user.  Mostly the guidance is mechanical
-and little real intervention is required.  Because the interface
-specification is written in the same full-featured language as the
-code being exposed, the user has unprecedented power available when
-she does need to take control.
-
-.. _Python: http://www.python.org/
-.. _SWIG: http://www.swig.org/
-.. _SIP: http://www.riverbankcomputing.co.uk/sip/index.php
-.. _Qt: http://www.trolltech.com/
-.. _CXX: http://cxx.sourceforge.net/
-.. _Boost.Python: http://www.boost.org/libs/python/doc
-
-===========================
- Boost.Python Design Goals 
-===========================
-
-The primary goal of Boost.Python is to allow users to expose C++
-classes and functions to Python using nothing more than a C++
-compiler.  In broad strokes, the user experience should be one of
-directly manipulating C++ objects from Python.
-
-However, it's also important not to translate all interfaces *too*
-literally: the idioms of each language must be respected.  For
-example, though C++ and Python both have an iterator concept, they are
-expressed very differently.  Boost.Python has to be able to bridge the
-interface gap.
-
-It must be possible to insulate Python users from crashes resulting
-from trivial misuses of C++ interfaces, such as accessing
-already-deleted objects.  By the same token the library should
-insulate C++ users from low-level Python 'C' API, replacing
-error-prone 'C' interfaces like manual reference-count management and
-raw ``PyObject`` pointers with more-robust alternatives.
-
-Support for component-based development is crucial, so that C++ types
-exposed in one extension module can be passed to functions exposed in
-another without loss of crucial information like C++ inheritance
-relationships.
-
-Finally, all wrapping must be *non-intrusive*, without modifying or
-even seeing the original C++ source code.  Existing C++ libraries have
-to be wrappable by third parties who only have access to header files
-and binaries.
-
-==========================
- Hello Boost.Python World
-==========================
-
-And now for a preview of Boost.Python, and how it improves on the raw
-facilities offered by Python. Here's a function we might want to
-expose::
-
-    char const* greet(unsigned x)
-    {
-       static char const* const msgs[] = { "hello", "Boost.Python", "world!" };
-
-       if (x > 2) 
-           throw std::range_error("greet: index out of range");
-
-       return msgs[x];
-    }
-
-To wrap this function in standard C++ using the Python 'C' API, we'd
-need something like this::
-
-    extern "C" // all Python interactions use 'C' linkage and calling convention
-    {
-        // Wrapper to handle argument/result conversion and checking
-        PyObject* greet_wrap(PyObject* args, PyObject * keywords)
-        {
-             int x;
-             if (PyArg_ParseTuple(args, "i", &x))    // extract/check arguments
-             {
-                 char const* result = greet(x);      // invoke wrapped function
-                 return PyString_FromString(result); // convert result to Python
-             }
-             return 0;                               // error occurred
-        }
-
-        // Table of wrapped functions to be exposed by the module
-        static PyMethodDef methods[] = {
-            { "greet", greet_wrap, METH_VARARGS, "return one of 3 parts of a greeting" }
-            , { NULL, NULL, 0, NULL } // sentinel
-        };
-
-        // module initialization function
-        DL_EXPORT init_hello()
-        {
-            (void) Py_InitModule("hello", methods); // add the methods to the module
-        }
-    }
-
-Now here's the wrapping code we'd use to expose it with Boost.Python::
-
-    #include <boost/python.hpp>
-    using namespace boost::python;
-    BOOST_PYTHON_MODULE(hello)
-    {
-        def("greet", greet, "return one of 3 parts of a greeting");
-    }
-
-and here it is in action::
-
-    >>> import hello
-    >>> for x in range(3):
-    ...     print hello.greet(x)
-    ...
-    hello
-    Boost.Python
-    world!
-
-Aside from the fact that the 'C' API version is much more verbose,
-it's worth noting a few things that it doesn't handle correctly:
-
-* The original function accepts an unsigned integer, and the Python
-  'C' API only gives us a way of extracting signed integers. The
-  Boost.Python version will raise a Python exception if we try to pass
-  a negative number to ``hello.greet``, but the other one will proceed
-  to do whatever the C++ implementation does when converting an
-  negative integer to unsigned (usually wrapping to some very large
-  number), and pass the incorrect translation on to the wrapped
-  function.
-
-* That brings us to the second problem: if the C++ ``greet()``
-  function is called with a number greater than 2, it will throw an
-  exception.  Typically, if a C++ exception propagates across the
-  boundary with code generated by a 'C' compiler, it will cause a
-  crash.  As you can see in the first version, there's no C++
-  scaffolding there to prevent this from happening.  Functions wrapped
-  by Boost.Python automatically include an exception-handling layer
-  which protects Python users by translating unhandled C++ exceptions
-  into a corresponding Python exception.
-
-* A slightly more-subtle limitation is that the argument conversion
-  used in the Python 'C' API case can only get that integer ``x`` in
-  *one way*.  PyArg_ParseTuple can't convert Python ``long`` objects
-  (arbitrary-precision integers) which happen to fit in an ``unsigned
-  int`` but not in a ``signed long``, nor will it ever handle a
-  wrapped C++ class with a user-defined implicit ``operator unsigned
-  int()`` conversion. Boost.Python's dynamic type conversion
-  registry allows users to add arbitrary conversion methods.
-
-==================
- Library Overview
-==================
-
-This section outlines some of the library's major features.  Except as
-neccessary to avoid confusion, details of library implementation are
-omitted.
-
-------------------
- Exposing Classes
-------------------
-
-C++ classes and structs are exposed with a similarly-terse interface.
-Given::
-
-    struct World
-    {
-        void set(std::string msg) { this->msg = msg; }
-        std::string greet() { return msg; }
-        std::string msg;
-    };
-
-The following code will expose it in our extension module::
-    
-    #include <boost/python.hpp>
-    BOOST_PYTHON_MODULE(hello)
-    {
-        class_<World>("World")
-            .def("greet", &World::greet)
-            .def("set", &World::set)
-        ;
-    }
-
-Although this code has a certain pythonic familiarity, people
-sometimes find the syntax bit confusing because it doesn't look like
-most of the C++ code they're used to. All the same, this is just
-standard C++.  Because of their flexible syntax and operator
-overloading, C++ and Python are great for defining domain-specific
-(sub)languages
-(DSLs), and that's what we've done in Boost.Python. To break it down::
-
-    class_<World>("World")
-
-constructs an unnamed object of type ``class_<World>`` and passes
-``"World"`` to its constructor.  This creates a new-style Python class
-called ``World`` in the extension module, and associates it with the
-C++ type ``World`` in the Boost.Python type conversion registry.  We
-might have also written::
-
-    class_<World> w("World");
-
-but that would've been more verbose, since we'd have to name ``w``
-again to invoke its ``def()`` member function::
-
-        w.def("greet", &World::greet)
-
-There's nothing special about the location of the dot for member
-access in the original example: C++ allows any amount of whitespace on
-either side of a token, and placing the dot at the beginning of each
-line allows us to chain as many successive calls to member functions
-as we like with a uniform syntax.  The other key fact that allows
-chaining is that ``class_<>`` member functions all return a reference
-to ``*this``.
-
-So the example is equivalent to::
-
-    class_<World> w("World");
-    w.def("greet", &World::greet);
-    w.def("set", &World::set);
-
-It's occasionally useful to be able to break down the components of a
-Boost.Python class wrapper in this way, but the rest of this article
-will stick to the terse syntax.
-
-For completeness, here's the wrapped class in use: ::
-
-    >>> import hello
-    >>> planet = hello.World()
-    >>> planet.set('howdy')
-    >>> planet.greet()
-    'howdy'
-
-Constructors
-============
-
-Since our ``World`` class is just a plain ``struct``, it has an
-implicit no-argument (nullary) constructor.  Boost.Python exposes the
-nullary constructor by default, which is why we were able to write: ::
-
-  >>> planet = hello.World()
-
-However, well-designed classes in any language may require constructor
-arguments in order to establish their invariants.  Unlike Python,
-where ``__init__`` is just a specially-named method, In C++
-constructors cannot be handled like ordinary member functions.  In
-particular, we can't take their address: ``&World::World`` is an
-error.  The library provides a different interface for specifying
-constructors.  Given::
-
-    struct World
-    {
-        World(std::string msg); // added constructor
-        ...
-
-we can modify our wrapping code as follows::
-
-    class_<World>("World", init<std::string>())
-        ...
-
-of course, a C++ class may have additional constructors, and we can
-expose those as well by passing more instances of ``init<...>`` to
-``def()``::
-
-    class_<World>("World", init<std::string>())
-        .def(init<double, double>())
-        ...
-
-Boost.Python allows wrapped functions, member functions, and
-constructors to be overloaded to mirror C++ overloading.
-
-Data Members and Properties
-===========================
-
-Any publicly-accessible data members in a C++ class can be easily
-exposed as either ``readonly`` or ``readwrite`` attributes::
-
-    class_<World>("World", init<std::string>())
-        .def_readonly("msg", &World::msg)
-        ...
-
-and can be used directly in Python: ::
-
-    >>> planet = hello.World('howdy')
-    >>> planet.msg
-    'howdy'
-
-This does *not* result in adding attributes to the ``World`` instance
-``__dict__``, which can result in substantial memory savings when
-wrapping large data structures.  In fact, no instance ``__dict__``
-will be created at all unless attributes are explicitly added from
-Python. Boost.Python owes this capability to the new Python 2.2 type
-system, in particular the descriptor interface and ``property`` type.
-
-In C++, publicly-accessible data members are considered a sign of poor
-design because they break encapsulation, and style guides usually
-dictate the use of "getter" and "setter" functions instead.  In
-Python, however, ``__getattr__``, ``__setattr__``, and since 2.2,
-``property`` mean that attribute access is just one more
-well-encapsulated syntactic tool at the programmer's disposal.
-Boost.Python bridges this idiomatic gap by making Python ``property``
-creation directly available to users.  If ``msg`` were private, we
-could still expose it as attribute in Python as follows::
-
-    class_<World>("World", init<std::string>())
-        .add_property("msg", &World::greet, &World::set)
-        ...
-
-The example above mirrors the familiar usage of properties in Python
-2.2+: ::
-
-    >>> class World(object):
-    ...     __init__(self, msg):
-    ...         self.__msg = msg
-    ...     def greet(self):
-    ...         return self.__msg
-    ...     def set(self, msg):
-    ...         self.__msg = msg
-    ...     msg = property(greet, set)
-
-Operator Overloading
-====================
-
-The ability to write arithmetic operators for user-defined types has
-been a major factor in the success of both languages for numerical
-computation, and the success of packages like NumPy_ attests to the
-power of exposing operators in extension modules.  Boost.Python
-provides a concise mechanism for wrapping operator overloads. The
-example below shows a fragment from a wrapper for the Boost rational
-number library::
-
-    class_<rational<int> >("rational_int")
-      .def(init<int, int>()) // constructor, e.g. rational_int(3,4)
-      .def("numerator", &rational<int>::numerator)
-      .def("denominator", &rational<int>::denominator)
-      .def(-self)        // __neg__ (unary minus)
-      .def(self + self)  // __add__ (homogeneous)
-      .def(self * self)  // __mul__
-      .def(self + int()) // __add__ (heterogenous)
-      .def(int() + self) // __radd__
-      ...
-
-The magic is performed using a simplified application of "expression
-templates" [VELD1995]_, a technique originally developed for
-optimization of high-performance matrix algebra expressions.  The
-essence is that instead of performing the computation immediately,
-operators are overloaded to construct a type *representing* the
-computation.  In matrix algebra, dramatic optimizations are often
-available when the structure of an entire expression can be taken into
-account, rather than evaluating each operation "greedily".
-Boost.Python uses the same technique to build an appropriate Python
-method object based on expressions involving ``self``.
-
-.. _NumPy: http://www.pfdubois.com/numpy/
-
-Inheritance
-===========
-
-C++ inheritance relationships can be represented to Boost.Python by adding
-an optional ``bases<...>`` argument to the ``class_<...>`` template
-parameter list as follows::
-
-     class_<Derived, bases<Base1,Base2> >("Derived")
-          ...
-
-This has two effects:  
-
-1. When the ``class_<...>`` is created, Python type objects
-   corresponding to ``Base1`` and ``Base2`` are looked up in
-   Boost.Python's registry, and are used as bases for the new Python
-   ``Derived`` type object, so methods exposed for the Python ``Base1``
-   and ``Base2`` types are automatically members of the ``Derived``
-   type.  Because the registry is global, this works correctly even if
-   ``Derived`` is exposed in a different module from either of its
-   bases.
-
-2. C++ conversions from ``Derived`` to its bases are added to the
-   Boost.Python registry.  Thus wrapped C++ methods expecting (a
-   pointer or reference to) an object of either base type can be
-   called with an object wrapping a ``Derived`` instance.  Wrapped
-   member functions of class ``T`` are treated as though they have an
-   implicit first argument of ``T&``, so these conversions are
-   neccessary to allow the base class methods to be called for derived
-   objects.
-
-Of course it's possible to derive new Python classes from wrapped C++
-class instances.  Because Boost.Python uses the new-style class
-system, that works very much as for the Python built-in types.  There
-is one significant detail in which it differs: the built-in types
-generally establish their invariants in their ``__new__`` function, so
-that derived classes do not need to call ``__init__`` on the base
-class before invoking its methods : ::
-
-    >>> class L(list):
-    ...      def __init__(self):
-    ...          pass
-    ...
-    >>> L().reverse()
-    >>> 
-
-Because C++ object construction is a one-step operation, C++ instance
-data cannot be constructed until the arguments are available, in the
-``__init__`` function: ::
-
-    >>> class D(SomeBoostPythonClass):
-    ...      def __init__(self):
-    ...          pass
-    ...
-    >>> D().some_boost_python_method()
-    Traceback (most recent call last):
-      File "<stdin>", line 1, in ?
-    TypeError: bad argument type for built-in operation
-
-This happened because Boost.Python couldn't find instance data of type
-``SomeBoostPythonClass`` within the ``D`` instance; ``D``'s ``__init__``
-function masked construction of the base class.  It could be corrected
-by either removing ``D``'s ``__init__`` function or having it call
-``SomeBoostPythonClass.__init__(...)`` explicitly.
-
-Virtual Functions
-=================
-
-Deriving new types in Python from extension classes is not very
-interesting unless they can be used polymorphically from C++.  In
-other words, Python method implementations should appear to override
-the implementation of C++ virtual functions when called *through base
-class pointers/references from C++*.  Since the only way to alter the
-behavior of a virtual function is to override it in a derived class,
-the user must build a special derived class to dispatch a polymorphic
-class' virtual functions::
-
-    //
-    // interface to wrap:
-    //
-    class Base
-    {
-     public:
-        virtual int f(std::string x) { return 42; }
-        virtual ~Base();
-    };
-
-    int calls_f(Base const& b, std::string x) { return b.f(x); }
-
-    //
-    // Wrapping Code
-    //
-
-    // Dispatcher class
-    struct BaseWrap : Base
-    {
-        // Store a pointer to the Python object
-        BaseWrap(PyObject* self_) : self(self_) {}
-        PyObject* self;
-
-        // Default implementation, for when f is not overridden
-        int f_default(std::string x) { return this->Base::f(x); }
-        // Dispatch implementation
-        int f(std::string x) { return call_method<int>(self, "f", x); }
-    };
-
-    ...
-        def("calls_f", calls_f);
-        class_<Base, BaseWrap>("Base")
-            .def("f", &Base::f, &BaseWrap::f_default)
-            ;
-
-Now here's some Python code which demonstrates: ::
-
-    >>> class Derived(Base):
-    ...     def f(self, s):
-    ...          return len(s)
-    ...
-    >>> calls_f(Base(), 'foo')
-    42
-    >>> calls_f(Derived(), 'forty-two')
-    9
-
-Things to notice about the dispatcher class:
-
-* The key element which allows overriding in Python is the
-  ``call_method`` invocation, which uses the same global type
-  conversion registry as the C++ function wrapping does to convert its
-  arguments from C++ to Python and its return type from Python to C++.
-
-* Any constructor signatures you wish to wrap must be replicated with
-  an initial ``PyObject*`` argument
-
-* The dispatcher must store this argument so that it can be used to
-  invoke ``call_method``
-
-* The ``f_default`` member function is needed when the function being
-  exposed is not pure virtual; there's no other way ``Base::f`` can be
-  called on an object of type ``BaseWrap``, since it overrides ``f``.
-
-Deeper Reflection on the Horizon?
-=================================
-
-Admittedly, this formula is tedious to repeat, especially on a project
-with many polymorphic classes.  That it is neccessary reflects some
-limitations in C++'s compile-time introspection capabilities: there's
-no way to enumerate the members of a class and find out which are
-virtual functions.  At least one very promising project has been
-started to write a front-end which can generate these dispatchers (and
-other wrapping code) automatically from C++ headers.  
-
-Pyste_ is being developed by Bruno da Silva de Oliveira.  It builds on
-GCC_XML_, which generates an XML version of GCC's internal program
-representation.  Since GCC is a highly-conformant C++ compiler, this
-ensures correct handling of the most-sophisticated template code and
-full access to the underlying type system.  In keeping with the
-Boost.Python philosophy, a Pyste interface description is neither
-intrusive on the code being wrapped, nor expressed in some unfamiliar
-language: instead it is a 100% pure Python script.  If Pyste is
-successful it will mark a move away from wrapping everything directly
-in C++ for many of our users.  It will also allow us the choice to
-shift some of the metaprogram code from C++ to Python.  We expect that
-soon, not only our users but the Boost.Python developers themselves
-will be "thinking hybrid" about their own code.
-
-.. _`GCC_XML`: http://www.gccxml.org/HTML/Index.html
-.. _`Pyste`: http://www.boost.org/libs/python/pyste
-
----------------
- Serialization
----------------
-
-*Serialization* is the process of converting objects in memory to a
-form that can be stored on disk or sent over a network connection. The
-serialized object (most often a plain string) can be retrieved and
-converted back to the original object. A good serialization system will
-automatically convert entire object hierarchies. Python's standard
-``pickle`` module is just such a system.  It leverages the language's strong
-runtime introspection facilities for serializing practically arbitrary
-user-defined objects. With a few simple and unintrusive provisions this
-powerful machinery can be extended to also work for wrapped C++ objects.
-Here is an example::
-
-    #include <string>
-
-    struct World
-    {
-        World(std::string a_msg) : msg(a_msg) {}
-        std::string greet() const { return msg; }
-        std::string msg;
-    };
-
-    #include <boost/python.hpp>
-    using namespace boost::python;
-
-    struct World_picklers : pickle_suite
-    {
-      static tuple
-      getinitargs(World const& w) { return make_tuple(w.greet()); }
-    };
-
-    BOOST_PYTHON_MODULE(hello)
-    {
-        class_<World>("World", init<std::string>())
-            .def("greet", &World::greet)
-            .def_pickle(World_picklers())
-        ;
-    }
-
-Now let's create a ``World`` object and put it to rest on disk::
-
-    >>> import hello
-    >>> import pickle
-    >>> a_world = hello.World("howdy")
-    >>> pickle.dump(a_world, open("my_world", "w"))
-
-In a potentially *different script* on a potentially *different
-computer* with a potentially *different operating system*::
-
-    >>> import pickle
-    >>> resurrected_world = pickle.load(open("my_world", "r"))
-    >>> resurrected_world.greet()
-    'howdy'
-
-Of course the ``cPickle`` module can also be used for faster
-processing.
-
-Boost.Python's ``pickle_suite`` fully supports the ``pickle`` protocol
-defined in the standard Python documentation. Like a __getinitargs__
-function in Python, the pickle_suite's getinitargs() is responsible for
-creating the argument tuple that will be use to reconstruct the pickled
-object.  The other elements of the Python pickling protocol,
-__getstate__ and __setstate__ can be optionally provided via C++
-getstate and setstate functions.  C++'s static type system allows the
-library to ensure at compile-time that nonsensical combinations of
-functions (e.g. getstate without setstate) are not used.
-
-Enabling serialization of more complex C++ objects requires a little
-more work than is shown in the example above. Fortunately the
-``object`` interface (see next section) greatly helps in keeping the
-code manageable.
-
-------------------
- Object interface
-------------------
-
-Experienced 'C' language extension module authors will be familiar
-with the ubiquitous ``PyObject*``, manual reference-counting, and the
-need to remember which API calls return "new" (owned) references or
-"borrowed" (raw) references.  These constraints are not just
-cumbersome but also a major source of errors, especially in the
-presence of exceptions.
-
-Boost.Python provides a class ``object`` which automates reference
-counting and provides conversion to Python from C++ objects of
-arbitrary type.  This significantly reduces the learning effort for
-prospective extension module writers.
-
-Creating an ``object`` from any other type is extremely simple::
-
-    object s("hello, world");  // s manages a Python string
-
-``object`` has templated interactions with all other types, with
-automatic to-python conversions. It happens so naturally that it's
-easily overlooked::
-
-   object ten_Os = 10 * s[4]; // -> "oooooooooo"
-
-In the example above, ``4`` and ``10`` are converted to Python objects
-before the indexing and multiplication operations are invoked.
-
-The ``extract<T>`` class template can be used to convert Python objects
-to C++ types::
-
-    double x = extract<double>(o);
-
-If a conversion in either direction cannot be performed, an
-appropriate exception is thrown at runtime.
-
-The ``object`` type is accompanied by a set of derived types
-that mirror the Python built-in types such as ``list``, ``dict``,
-``tuple``, etc. as much as possible. This enables convenient
-manipulation of these high-level types from C++::
-
-    dict d;
-    d["some"] = "thing";
-    d["lucky_number"] = 13;
-    list l = d.keys();
-
-This almost looks and works like regular Python code, but it is pure
-C++.  Of course we can wrap C++ functions which accept or return
-``object`` instances.
-
-=================
- Thinking hybrid
-=================
-
-Because of the practical and mental difficulties of combining
-programming languages, it is common to settle a single language at the
-outset of any development effort.  For many applications, performance
-considerations dictate the use of a compiled language for the core
-algorithms.  Unfortunately, due to the complexity of the static type
-system, the price we pay for runtime performance is often a
-significant increase in development time.  Experience shows that
-writing maintainable C++ code usually takes longer and requires *far*
-more hard-earned working experience than developing comparable Python
-code.  Even when developers are comfortable working exclusively in
-compiled languages, they often augment their systems by some type of
-ad hoc scripting layer for the benefit of their users without ever
-availing themselves of the same advantages.
-
-Boost.Python enables us to *think hybrid*.  Python can be used for
-rapidly prototyping a new application; its ease of use and the large
-pool of standard libraries give us a head start on the way to a
-working system.  If necessary, the working code can be used to
-discover rate-limiting hotspots.  To maximize performance these can
-be reimplemented in C++, together with the Boost.Python bindings
-needed to tie them back into the existing higher-level procedure.
-
-Of course, this *top-down* approach is less attractive if it is clear
-from the start that many algorithms will eventually have to be
-implemented in C++.  Fortunately Boost.Python also enables us to
-pursue a *bottom-up* approach.  We have used this approach very
-successfully in the development of a toolbox for scientific
-applications.  The toolbox started out mainly as a library of C++
-classes with Boost.Python bindings, and for a while the growth was
-mainly concentrated on the C++ parts.  However, as the toolbox is
-becoming more complete, more and more newly added functionality can be
-implemented in Python.
-
-.. image:: python_cpp_mix.jpg
-
-This figure shows the estimated ratio of newly added C++ and Python
-code over time as new algorithms are implemented.  We expect this
-ratio to level out near 70% Python.  Being able to solve new problems
-mostly in Python rather than a more difficult statically typed
-language is the return on our investment in Boost.Python.  The ability
-to access all of our code from Python allows a broader group of
-developers to use it in the rapid development of new applications.
-
-=====================
- Development history
-=====================
-
-The first version of Boost.Python was developed in 2000 by Dave
-Abrahams at Dragon Systems, where he was privileged to have Tim Peters
-as a guide to "The Zen of Python".  One of Dave's jobs was to develop
-a Python-based natural language processing system.  Since it was
-eventually going to be targeting embedded hardware, it was always
-assumed that the compute-intensive core would be rewritten in C++ to
-optimize speed and memory footprint [#proto]_.  The project also wanted to
-test all of its C++ code using Python test scripts [#test]_.  The only
-tool we knew of for binding C++ and Python was SWIG_, and at the time
-its handling of C++ was weak.  It would be false to claim any deep
-insight into the possible advantages of Boost.Python's approach at
-this point.  Dave's interest and expertise in fancy C++ template
-tricks had just reached the point where he could do some real damage,
-and Boost.Python emerged as it did because it filled a need and
-because it seemed like a cool thing to try.
-
-This early version was aimed at many of the same basic goals we've
-described in this paper, differing most-noticeably by having a
-slightly more cumbersome syntax and by lack of special support for
-operator overloading, pickling, and component-based development.
-These last three features were quickly added by Ullrich Koethe and
-Ralf Grosse-Kunstleve [#feature]_, and other enthusiastic contributors arrived
-on the scene to contribute enhancements like support for nested
-modules and static member functions.
-
-By early 2001 development had stabilized and few new features were
-being added, however a disturbing new fact came to light: Ralf had
-begun testing Boost.Python on pre-release versions of a compiler using
-the EDG_ front-end, and the mechanism at the core of Boost.Python
-responsible for handling conversions between Python and C++ types was
-failing to compile.  As it turned out, we had been exploiting a very
-common bug in the implementation of all the C++ compilers we had
-tested.  We knew that as C++ compilers rapidly became more
-standards-compliant, the library would begin failing on more
-platforms.  Unfortunately, because the mechanism was so central to the
-functioning of the library, fixing the problem looked very difficult.
-
-Fortunately, later that year Lawrence Berkeley and later Lawrence
-Livermore National labs contracted with `Boost Consulting`_ for support
-and development of Boost.Python, and there was a new opportunity to
-address fundamental issues and ensure a future for the library.  A
-redesign effort began with the low level type conversion architecture,
-building in standards-compliance and support for component-based
-development (in contrast to version 1 where conversions had to be
-explicitly imported and exported across module boundaries).  A new
-analysis of the relationship between the Python and C++ objects was
-done, resulting in more intuitive handling for C++ lvalues and
-rvalues.
-
-The emergence of a powerful new type system in Python 2.2 made the
-choice of whether to maintain compatibility with Python 1.5.2 easy:
-the opportunity to throw away a great deal of elaborate code for
-emulating classic Python classes alone was too good to pass up.  In
-addition, Python iterators and descriptors provided crucial and
-elegant tools for representing similar C++ constructs.  The
-development of the generalized ``object`` interface allowed us to
-further shield C++ programmers from the dangers and syntactic burdens
-of the Python 'C' API.  A great number of other features including C++
-exception translation, improved support for overloaded functions, and
-most significantly, CallPolicies for handling pointers and
-references, were added during this period.
-
-In October 2002, version 2 of Boost.Python was released.  Development
-since then has concentrated on improved support for C++ runtime
-polymorphism and smart pointers.  Peter Dimov's ingenious
-``boost::shared_ptr`` design in particular has allowed us to give the
-hybrid developer a consistent interface for moving objects back and
-forth across the language barrier without loss of information.  At
-first, we were concerned that the sophistication and complexity of the
-Boost.Python v2 implementation might discourage contributors, but the
-emergence of Pyste_ and several other significant feature
-contributions have laid those fears to rest.  Daily questions on the
-Python C++-sig and a backlog of desired improvements show that the
-library is getting used.  To us, the future looks bright.
-
-.. _`EDG`: http://www.edg.com
-
-=============
- Conclusions
-=============
-
-Boost.Python achieves seamless interoperability between two rich and
-complimentary language environments.  Because it leverages template
-metaprogramming to introspect about types and functions, the user
-never has to learn a third syntax: the interface definitions are
-written in concise and maintainable C++.  Also, the wrapping system
-doesn't have to parse C++ headers or represent the type system: the
-compiler does that work for us.
-
-Computationally intensive tasks play to the strengths of C++ and are
-often impossible to implement efficiently in pure Python, while jobs
-like serialization that are trivial in Python can be very difficult in
-pure C++.  Given the luxury of building a hybrid software system from
-the ground up, we can approach design with new confidence and power.
-
-===========
- Citations
-===========
-
-.. [VELD1995] T. Veldhuizen, "Expression Templates," C++ Report,
-   Vol. 7 No. 5 June 1995, pp. 26-31.
-   http://osl.iu.edu/~tveldhui/papers/Expression-Templates/exprtmpl.html
-
-===========
- Footnotes
-===========
-
-.. [#proto] In retrospect, it seems that "thinking hybrid" from the
-        ground up might have been better for the NLP system: the
-        natural component boundaries defined by the pure python
-        prototype turned out to be inappropriate for getting the
-        desired performance and memory footprint out of the C++ core,
-        which eventually caused some redesign overhead on the Python
-        side when the core was moved to C++.
-
-.. [#test] We also have some reservations about driving all C++
-        testing through a Python interface, unless that's the only way
-        it will be ultimately used.  Any transition across language
-        boundaries with such different object models can inevitably
-        mask bugs.
-
-.. [#feature] These features were expressed very differently in v1 of
-        Boost.Python
+This file has been moved to http://www.boost-consulting.com/writing/bpl.txt.

doc/PyConDC_2003/bpl_mods.txt

@@ -273,7 +273,7 @@ correctly:
 ==================
 
 This section outlines some of the library's major features.  Except as
-neccessary to avoid confusion, details of library implementation are
+necessary to avoid confusion, details of library implementation are
 omitted.
 
 -------------------------------------------
@@ -537,7 +537,7 @@ This has two effects:
    called with an object wrapping a ``Derived`` instance.  Wrapped
    member functions of class ``T`` are treated as though they have an
    implicit first argument of ``T&``, so these conversions are
-   neccessary to allow the base class methods to be called for derived
+   necessary to allow the base class methods to be called for derived
    objects.
 
 Of course it's possible to derive new Python classes from wrapped C++
@@ -650,7 +650,7 @@ Things to notice about the dispatcher class:
   called on an object of type ``BaseWrap``, since it overrides ``f``.
 
 Admittedly, this formula is tedious to repeat, especially on a project
-with many polymorphic classes; that it is neccessary reflects
+with many polymorphic classes; that it is necessary reflects
 limitations in C++'s compile-time reflection capabilities.  Several
 efforts are underway to write front-ends for Boost.Python which can
 generate these dispatchers (and other wrapping code) automatically.

doc/building.html

@@ -82,9 +82,12 @@
     boost installation (if you have already built boost from the top level
     this may have no effect, since the work is already done).</p>
 
-    <h3><a name="configuration">Basic Configuration</a></h3>
-    You may need to configure the following variables to point Boost.Build at
-    your Python installation: 
+    <h3><a name="configuration">Basic Configuration</a></h3> You may
+    need to configure the following variables to point Boost.Build at
+    your Python installation.  Variables can be either set in the
+    environment or passed on the <code>bjam</code> command-line
+    as <code>-s</code><i>name</i><code>=</code><i>value</i>.  Variable
+    names are case-sensitive.
 
     <table border="1" summary="build configuration variables">
       <tr>
@@ -98,28 +101,29 @@
       </tr>
 
       <tr>
-        <td><code>PYTHON_ROOT</code></td>
-
-        <td>The root directory of your Python installation</td>
-
-        <td>Windows:&nbsp;<code>c:/tools/python</code>
-        Unix:&nbsp;<code>/usr/local</code></td>
-
-        <td>On Unix, this is the <code>--with-prefix=</code> directory used
-        to configure Python</td>
-      </tr>
-
       <tr>
         <td><code>PYTHON_VERSION</code></td>
 
         <td>The The 2-part python Major.Minor version number</td>
 
-        <td><code>2.2</code></td>
+        <td><code>2.4</code></td>
 
         <td>Be sure not to include a third number, e.g. <b>not</b>
         "<code>2.2.1</code>", even if that's the version you have.</td>
       </tr>
 
+        <td><code>PYTHON_ROOT</code></td>
+
+        <td>The root directory of your Python installation</td>
+
+        <td>Windows:&nbsp;<code>c:/Python</code><i>(10*Version)</i>, e.g. <code>c:/Python24</code>
+<br>
+        *nix/Cygwin:&nbsp;<code>/usr</code></td>
+
+        <td>On *nix, this should be the <code>--prefix=</code> directory used
+        to configure Python when it was built and installed.</td>
+      </tr>
+
       <tr>
         <td><code>PYTHON_INCLUDES</code></td>
 
@@ -172,7 +176,7 @@
       <tr>
         <td><code>CYGWIN_PYTHON_[DEBUG_]ROOT</code></td>
 
-        <td>unix-style path containing the <code>include/</code> directory
+        <td>*nix-style path containing the <code>include/</code> directory
         containing
         <code>python$(CYGWIN_PYTHON_[DEBUG_]VERSION)/python.h</code>.</td>
 
@@ -219,8 +223,10 @@
     <h3><a name="mingw">Notes for MinGW (and Cygwin with -mno-cygwin) GCC
     Users</a></h3>
 
-    <p>You will need to create a MinGW-compatible version of the Python
-    library; the one shipped with Python will only work with a
+    <p>If you are using a version of Python prior to 2.4.1 with a
+    MinGW prior to 3.0.0 (with binutils-2.13.90-20030111-1), you will
+    need to create a MinGW-compatible version of the Python library;
+    the one shipped with Python will only work with a
     Microsoft-compatible linker. Follow the instructions in the
     "Non-Microsoft" section of the "Building Extensions: Tips And Tricks"
     chapter in <a href=
@@ -359,7 +365,7 @@ path-global BOOST_ROOT : ../../.. ;
     <p>The first two variants of the <code>boost_python</code> library are
     built by default, and are compatible with the default Python
     distribution. The <code>debug-python</code> variant corresponds to a
-    specially-built debugging version of Python. On Unix platforms, this
+    specially-built debugging version of Python. On *nix platforms, this
     python is built by adding <code>--with-pydebug</code> when configuring
     the Python build. On Windows, the debugging version of Python is
     generated by the "Win32 Debug" target of the <code>PCBuild.dsw</code>
@@ -437,7 +443,7 @@ path-global BOOST_ROOT : ../../.. ;
 
     <blockquote>
       <em>The Visual Studio project files are graciously contributed and
-      maintained by <a href="mailto:brett.calcott@paradise.net.nz">Brett
+        maintained by <a href="mailto:brett.calcott@gmail.com">Brett
       Calcott</a></em>.
     </blockquote>
     <hr>

doc/index.html

@@ -5,7 +5,7 @@
     <meta name="generator" content=
     "HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
     <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-    <link rel="stylesheet" type="text/css" href="boost.css">
+    <link rel="stylesheet" type="text/css" href="../../../boost.css">
 
     <title>Boost.Python</title>
   </head>
@@ -24,10 +24,60 @@
 
           <h2 align="center">Index</h2>
         </td>
+
+
+        <td align="right">
+
+          <form method="get" action="http://www.google.com/custom">
+            <p>
+              <span id= "search-choice">
+                Search
+                <select name="hq" id="hq">
+                  <option label="All Documentation" value=
+                          "site:www.boost.org inurl:www.boost.org/libs/python/doc">
+                    All Documentation
+                  </option>
+                  <option label="Tutorial" value=
+                          "site:www.boost.org inurl:www.boost.org/libs/python/doc/tutorial">
+                    Tutorial
+                  </option>
+                  <option label="Reference" value=
+                          "site:www.boost.org inurl:www.boost.org/libs/python/doc/v2">
+                    Reference
+                  </option>
+              </select>
+                <br>
+             </span> 
+
+              <span id="search-text">
+                <input type="text" name="q" id="q" size="31" maxlength="255" alt="Search Text" />
+              </span> 
+
+              <br>
+              <span id= "google">
+                <a href= "http://www.google.com/search"> 
+                  <img src="../../../more/google_logo_25wht.gif" alt="Google" border="0" /></a>Powered
+              </span> 
+
+              <span id="go">
+                <input type="image" name="search" src="../../../more/space.gif" alt="Search" id="search-button" />
+              </span> 
+
+              <br>
+              <input type="hidden" name="cof" value= "LW:277;L:http://www.boost.org/boost.png;LH:86;AH:center;GL:0;S:http://www.boost.org;AWFID:9b83d16ce652ed5a;" />
+              <input type="hidden" name="sa" value= "Google Search" /> 
+              <input type="hidden" name= "domains" value= "www.boost.org;mail.python.org" /></p>
+          </form>
+
+        </td>
+      </tr>
+<tr>
+
       </tr>
     </table>
     <hr>
 
+
     <h2>Synopsis</h2>
     Welcome to version 2 of <b>Boost.Python</b>, a C++ library which enables
     seamless interoperability between C++ and the <a href=
@@ -123,7 +173,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href="../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002-2003. All Rights Reserved.</i></p>
+    Abrahams</a> 2002-2003.</i></p>
   </body>
 </html>
 

doc/new-conversions.html

@@ -1,328 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-<title>A New Type Conversion Mechanism for Boost.Python</title>
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<p><img border="0" src="../../../boost.png" width="277" height="86"
-alt="boost logo"></p>
-
-<h1>A New Type Conversion Mechanism for Boost.Python</h1>
-
-<p>By <a href="../../../people/dave_abrahams.htm">David Abrahams</a>.
-
-<h2>Introduction</h2>
-
-This document describes a redesign of the mechanism for automatically
-converting objects between C++ and Python. The current implementation
-uses two functions for any type <tt>T</tt>:
-
-<blockquote><pre>
-U from_python(PyObject*, type&lt;T&gt;);
-void to_python(V);
-</pre></blockquote>
-
-where U is convertible to T and T is convertible to V. These functions
-are at the heart of C++/Python interoperability in Boost.Python, so
-why would we want to change them? There are many reasons:
-
-<h3>Bugs</h3>
-<p>Firstly, the current mechanism relies on a common C++ compiler
-bug. This is not just embarrassing: as compilers get to be more
-conformant, the library stops working. The issue, in detail, is the
-use of inline friend functions in templates to generate
-conversions. It is a very powerful, and legal technique as long as
-it's used correctly:
-
-<blockquote><pre>
-template &lt;class Derived&gt;
-struct add_some_functions
-{
-     friend <i>return-type</i> some_function1(..., Derived <i>cv-*-&amp;-opt</i>, ...);
-     friend <i>return-type</i> some_function2(..., Derived <i>cv-*-&amp;-opt</i>, ...);
-};
-
-template &lt;class T&gt;
-struct some_template : add_some_functions&lt;some_template&lt;T&gt; &gt;
-{
-};
-</pre></blockquote>
-
-The <tt>add_some_functions</tt> template generates free functions
-which operate on <tt>Derived</tt>, or on related types. Strictly
-speaking the related types are not just cv-qualified <tt>Derived</tt>
-values, pointers and/or references. Section 3.4.2 in the standard
-describes exactly which types you must use as parameters to these
-functions if you want the functions to be found
-(there is also a less-technical description in section 11.5.1 of
-C++PL3 <a href="#ref_1">[1]</a>). Suffice it to say that
-with the current design, the <tt>from_python</tt> and
-<tt>to_python</tt> functions are not supposed to be callable under any
-conditions!
-
-<h3>Compilation and Linking Time</h3>
-
-The conversion functions generated for each wrapped class using the
-above technique are not function templates, but regular functions. The
-upshot is that they must <i>all</i> be generated regardless of whether
-they are actually used. Generating all of those functions can slow
-down module compilation, and resolving the references can slow down
-linking.
-
-<h3>Efficiency</h3>
-
-The conversion functions are primarily used in (member) function
-wrappers to convert the arguments and return values. Being functions,
-converters have no interface which allows us to ask &quot;will the
-conversion succeed?&quot; without calling the function. Since the
-return value of the function must be the object to be passed as an
-argument, Boost.Python currently uses C++ exception-handling to detect
-an unsuccessful conversion. It's not a particularly good use of
-exception-handling, since the failure is not handled very far from
-where it occurred. More importantly, it means that C++ exceptions are
-thrown during overload resolution as we seek an overload that matches
-the arguments passed. Depending on the implementation, this approach
-can result in significant slowdowns.
-
-<p>It is also unclear that the current library generates a minimal
-amount of code for any type conversion. Many of the conversion
-functions are nontrivial, and partly because of compiler limitations,
-they are declared <tt>inline</tt>. Also, we could have done a better
-job separating the type-specific conversion code from the code which
-is type-independent.
-
-<h3>Cross-module Support</h3>
-
-The current strategy requires every module to contain the definition
-of conversions it uses. In general, a new module can never supply
-conversion code which is used by another module. Ralf Grosse-Kunstleve
-designed a clever system which imports conversions directly from one
-library into another using some explicit declarations, but it has some
-disadvantages also:
-
-<ol>
-<li>The system Ullrich Koethe designed for implicit conversion between
-wrapped classes related through inheritance does not currently work if
-the classes are defined in separate modules.
-
-<li>The writer of the importing module is required to know the name of
-the module supplying the imported conversions.
-
-<li>There can be only one way to extract any given C++ type from a
-Python object in a given module.
-</ol>
-
-The first item might be addressed by moving Boost.Python into a shared
-library, but the other two cannot. Ralf turned the limitation in item
-two into a feature: the required module is loaded implicitly when a
-conversion it defines is invoked. We will probably want to provide
-that functionality anyway, but it's not clear that we should require
-the declaration of all such conversions. The final item is a more
-serious limitation. If, for example, new numeric types are defined in
-separate modules, and these types can all be converted to
-<tt>double</tt>s, we have to choose just one conversion method.
-
-<h3>Ease-of-use</h3>
-
-One persistent source of confusion for users of Boost.Python has been
-the fact that conversions for a class are not be visible at
-compile-time until the declaration of that class has been seen. When
-the user tries to expose a (member) function operating on or returning
-an instance of the class in question, compilation fails...even though
-the user goes on to expose the class in the same translation unit!
-
-<p>
-The new system lifts all compile-time checks for the existence of
-particular type conversions and replaces them with runtime checks, in
-true Pythonic style. While this might seem cavalier, the compile-time
-checks are actually not much use in the current system if many classes
-are wrapped in separate modules, since the checks are based only on
-the user's declaration that the conversions exist.
-
-<h2>The New Design</h2>
-
-<h3>Motivation</h3>
-
-The new design was heavily influenced by a desire to generate as
-little code as possible in extension modules. Some of Boost.Python's
-clients are enormous projects where link time is proportional to the
-amount of object code, and there are many Python extension modules. As
-such, we try to keep type-specific conversion code out of modules
-other than the one the converters are defined in, and rely as much as
-possible on centralized control through a shared library.
-
-<h3>The Basics</h3>
-
-The library contains a <tt>registry</tt> which maps runtime type
-identifiers (actually an extension of <tt>std::type_info</tt> which
-preserves references and constness) to entries containing type
-converters. An <tt>entry</tt> can contain only one converter from C++ to Python
-(<tt>wrapper</tt>), but many converters from Python to C++
-(<tt>unwrapper</tt>s). <font color="#ff0000">What should happen if
-multiple modules try to register wrappers for the same type?</font>. Wrappers
-and unwrappers are known as <tt>body</tt> objects, and are accessed
-by the user and the library (in its function-wrapping code) through
-corresponding <tt>handle</tt> (<tt>wrap&lt;T&gt;</tt> and
-<tt>unwrap&lt;T&gt;</tt>) objects. The <tt>handle</tt> objects are
-extremely lightweight, and delegate <i>all</i> of their operations to
-the corresponding <tt>body</tt>.
-
-<p>
-When a <tt>handle</tt> object is constructed, it accesses the
-registry to find a corresponding <tt>body</tt> that can convert the
-handle's constructor argument. Actually the registry record for any
-type
-<tt>T</tt>used in a module is looked up only once and stored in a
-static <tt>registration&lt;T&gt;</tt> object for efficiency. For
-example, if the handle is an <tt>unwrap&lt;Foo&amp;&gt;</tt> object,
-the <tt>entry</tt> for <tt>Foo&amp;</tt> is looked up in the
-<tt>registry</tt>, and each <tt>unwrapper</tt> it contains is queried
-to determine if it can convert the
-<tt>PyObject*</tt> with which the <tt>unwrap</tt> was constructed. If
-a body object which can perform the conversion is found, a pointer to
-it is stored in the handle. A body object may at any point store
-additional data in the handle to speed up the conversion process.
-
-<p>
-Now that the handle has been constructed, the user can ask it whether
-the conversion can be performed. All handles can be tested as though
-they were convertible to <tt>bool</tt>; a <tt>true</tt> value
-indicates success. If the user forges ahead and tries to do the
-conversion without checking when no conversion is possible, an
-exception will be thrown as usual. The conversion itself is performed
-by the body object. 
-
-<h3>Handling complex conversions</h3>
-
-<p>Some conversions may require a dynamic allocation. For example,
-when a Python tuple is converted to a <tt>std::vector&lt;double&gt;
-const&amp;</tt>, we need some storage into which to construct the
-vector so that a reference to it can be formed. Furthermore, multiple
-conversions of the same type may need to be &quot;active&quot;
-simultaneously, so we can't keep a single copy of the storage
-anywhere. We could keep the storage in the <tt>body</tt> object, and
-have the body clone itself in case the storage is used, but in that
-case the storage in the body which lives in the registry is never
-used. If the storage was actually an object of the target type (the
-safest way in C++), we'd have to find a way to construct one for the
-body in the registry, since it may not have a default constructor.
-
-<p>
-The most obvious way out of this quagmire is to allocate the object using a
-<i>new-expression</i>, and store a pointer to it in the handle. Since
-the <tt>body</tt> object knows everything about the data it needs to
-allocate (if any), it is also given responsibility for destroying that
-data. When the <tt>handle</tt> is destroyed it asks the <tt>body</tt>
-object to tear down any data it may have stored there. In many ways,
-you can think of the <tt>body</tt> as a &quot;dynamically-determined
-vtable&quot; for the handle.
-
-<h3>Eliminating Redundancy</h3>
-
-If you look at the current Boost.Python code, you'll see that there
-are an enormous number of conversion functions generated for each
-wrapped class. For a given class <tt>T</tt>, functions are generated
-to extract the following types <tt>from_python</tt>:
-
-<blockquote><pre>
-T*
-T const*
-T const* const&amp;
-T* const&amp;
-T&amp;
-T const&amp;
-T
-std::auto_ptr&lt;T&gt;&amp;
-std::auto_ptr&lt;T&gt;
-std::auto_ptr&lt;T&gt; const&amp;
-boost::shared_ptr&lt;T&gt;&amp;
-boost::shared_ptr&lt;T&gt;
-boost::shared_ptr&lt;T&gt; const&amp;
-</pre></blockquote>
-
-Most of these are implemented in terms of just a few conversions, and
-<t>if you're lucky</t>, they will be inlined and cause no extra
-overhead. In the new system, however, a significant amount of data
-will be associated with each type that needs to be converted. We
-certainly don't want to register a separate unwrapper object for all
-of the above types.
-
-<p>Fortunately, much of the redundancy can be eliminated. For example,
-if we generate an unwrapper for <tt>T&</tt>, we don't need an
-unwrapper for <tt>T const&</tt> or <tt>T</tt>. Accordingly, the user's
-request to wrap/unwrap a given type is translated at compile-time into
-a request which helps to eliminate redundancy. The rules used to
-<tt>unwrap</tt> a type are:
-
-<ol>
-<li> Treat built-in types specially: when unwrapping a value or
-   constant reference to one of these, use a value for the target
-   type. It will bind to a const reference if neccessary, and more
-   importantly, avoids having to dynamically allocate room for
-   an lvalue of types which can be cheaply copied.
-<li>
- Reduce everything else to a reference to an un-cv-qualified type
-   where possible. Since cv-qualification is lost on Python
-   anyway, there's no point in trying to convert to a
-   <tt>const&amp;</tt>. <font color="#ff0000">What about conversions
-   to values like the tuple-&gt;vector example above? It seems to me
-   that we don't want to make a <tt>vector&lt;double&gt;&amp;</tt>
-   (non-const) converter available for that case. We may need to
-   rethink this slightly.</font>
-</ol>
-
-<p>To handle the problem described above in item 2, we modify the
-procedure slightly. To unwrap any non-scalar <tt>T</tt>, we seek an
-unwrapper for <tt>add_reference&lt;T&gt;::type</tt>. Unwrappers for
-<tt>T&nbsp;const&amp;</tt> always return <tt>T&amp;</tt>, and are
-registered under both <tt>T&nbsp;&amp;</tt> and
-<tt>T&nbsp;const&amp;</tt>.
-
-<p>For compilers not supporting partial specialization, unwrappers for
-<tt>T&nbsp;const&amp;</tt> must return <tt>T&nbsp;const&amp;</tt>
-(since constness can't be stripped), but a separate unwrapper object
-need to be registered for <tt>T&nbsp;&amp;</tt> and
-<tt>T&nbsp;const&amp;</tt> anyway, for the same reasons.
-
-<font color="#ff0000">We may want to make it possible to compile as
-though partial specialization were unavailable even on compilers where
-it is available, in case modules could be compiled by different
-compilers with compatible ABIs (e.g. Intel C++ and MSVC6).</font>
-
-<h3>Efficient Argument Conversion</h3>
-
-Since type conversions are primarily used in function wrappers, an
-optimization is provided for the case where a group of conversions are
-used together. Each <tt>handle</tt> class has a corresponding
-&quot;<tt>_more</tt>&quot; class which does the same job, but has a
-trivial destructor. Instead of asking each &quot;<tt>_more</tt>&quot;
-handle to destroy its own body, it is linked into an endogenous list
-managed by the first (ordinary) handle. The <tt>wrap</tt> and
-<tt>unwrap</tt> destructors are responsible for traversing that list
-and asking each <tt>body</tt> class to tear down its
-<tt>handle</tt>. This mechanism is also used to determine if all of
-the argument/return-value conversions can succeed with a single
-function call in the function wrapping code. <font color="#ff0000">We
-might need to handle return values in a separate step for Python
-callbacks, since the availablility of a conversion won't be known
-until the result object is retrieved.</font>
-
-<br>
-<hr>
-<h2>References</h2>
-
-<p><a name="ref_1">[1]</a>B. Stroustrup, The C++ Programming Language
-Special Edition Addison-Wesley, ISBN 0-201-70073-5.
-
-<hr>
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B %Y" startspan -->
-  13 November, 2002
-  <!--webbot bot="Timestamp" endspan i-checksum="31283" --></p>
-<p>© Copyright David Abrahams, 2001</p>
-
-</body>
-
-</html>

doc/new-conversions.txt

@@ -1,111 +0,0 @@
-This hierarchy contains converter handle classes.
-
-
-                +-------------+
-                | noncopyable |
-                +-------------+
-                      ^
-                      |            A common base class used so that
-             +--------+--------+   conversions can be linked into a
-             | conversion_base |   chain for efficient argument
-             +-----------------+   conversion
-                      ^
-                      |
-            +---------+-----------+
-            |                     |
-+-----------+----+         +------+-------+  only used for
-| unwrap_more<T> |         | wrap_more<T> |  chaining, and don't manage any
-+----------------+         +--------------+  resources.
-         ^                         ^
-         |                         |
-   +-----+-----+           +-------+-+  These converters are what users
-   | unwrap<T> |           | wrap<T> |  actually touch, but they do so
-   +-----------+           +---------+  through a type generator which
-                                        minimizes the number of converters
-                                        that must be generated, so they
-
-
-Each unwrap<T>, unwrap_more<T>, wrap<T>, wrap_more<T> converter holds
-a reference to an appropriate converter object
-
-This hierarchy contains converter body classes
-
-                                          Exposes use/release which
-                                          are needed in case the converter
-                           +-----------+  in the registry needs to be
-                           | converter |  cloned. That occurs when a
-                           +-----------+  unwrap target type is not
-                                 ^        contained within the Python object.
-                                 |
-              +------------------+-----+
-              |                        |
-     +--------+-------+ Exposes        |
-     | unwrapper_base | convertible()  |
-     +----------------+                |
-              ^                        |
-              |                        |
-     +--------+----+             +-----+-----+
-     | unwrapper<T>|             | wrapper<T>|
-     +-------------+             +-----------+
- Exposes T convert(PyObject*)    Exposes PyObject* convert(T)
-
-
-unwrap:
-
-    constructed with a PyObject*, whose reference count is
-    incremented.
-
-    find the registry entry for the target type
-
-    look in the collection of converters for one which claims to be
-    able to convert the PyObject to the target type.
-
-    stick a pointer to the unwrapper in the unwrap object
-
-    when unwrap is queried for convertibility, it checks to see
-    if it has a pointer to an unwrapper.
-
-    on conversion, the unwrapper is asked to allocate an
-    implementation if the unwrap object isn't already holding
-    one. The unwrap object "takes ownership" of the unwrapper's
-    implementation. No memory allocation will actually take place
-    unless this is a value conversion.
-
-    on destruction, the unwrapper is asked to free any implementation
-    held by the unwrap object. No memory deallocation actually
-    takes place unless this is a value conversion
-
-    on destruction, the reference count on the held PyObject is
-    decremented.
-
-    We need to make sure that by default, you can't instantiate
-    callback<> for reference and pointer return types: although the
-    unwrappers may exist, they may convert by-value, which would cause
-    the referent to be destroyed upon return.
-
-wrap:
-
-    find the registry entry for the source type
-
-    see if there is a converter. If found, stick a pointer to it in
-    the wrap object.
-
-    when queried for convertibility, it checks to see if it has a
-    pointer to a converter.
-
-    on conversion, a reference to the target PyObject is held by the
-    converter. Generally, the PyObject will have been created by the
-    converter, but in certain cases it may be a pre-existing object,
-    whose reference count will have been incremented.
-
-    when a wrap<T> x is used to return from a C++ function,
-    x.release() is returned so that x no longer holds a reference to
-    the PyObject when destroyed.
-
-    Otherwise, on destruction, any PyObject still held has its
-    reference-count decremented.
-
-
-When a converter is created by the user, the appropriate element must
-be added to the registry; when it is destroyed, it must be removed
-from the registry.

doc/news.html

@@ -1,87 +1,171 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
 <html>
-  <head>
-    <meta name="generator" content=
-    "HTML Tidy for Cygwin (vers 1st April 2002), see www.w3.org">
-    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-    <link rel="stylesheet" type="text/css" href="boost.css">
+<head>
+  <meta name="generator" content=
+  "HTML Tidy for Cygwin (vers 1st September 2004), see www.w3.org">
+  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
+  <link rel="stylesheet" type="text/css" href="boost.css">
 
-    <title>Boost.Python - News/Change Log</title>
-  </head>
+  <title>Boost.Python - News/Change Log</title>
+</head>
 
-  <body link="#0000ff" vlink="#800080">
-    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
-    "header">
-      <tr>
-        <td valign="top" width="300">
-          <h3><a href="../../../index.htm"><img height="86" width="277" alt=
-          "C++ Boost" src="../../../boost.png" border="0"></a></h3>
-        </td>
+<body link="#0000FF" vlink="#800080">
+  <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+  "header">
+    <tr>
+      <td valign="top" width="300">
+        <h3><a href="../../../index.htm"><img height="86" width="277" alt=
+        "C++ Boost" src="../../../boost.png" border="0"></a></h3>
+      </td>
 
-        <td valign="top">
-          <h1 align="center"><a href="index.html">Boost.Python</a></h1>
+      <td valign="top">
+        <h1 align="center"><a href="index.html">Boost.Python</a></h1>
 
-          <h2 align="center">News/Change Log</h2>
-        </td>
-      </tr>
-    </table>
-    <hr>
+        <h2 align="center">News/Change Log</h2>
+      </td>
+    </tr>
+  </table>
+  <hr>
 
-    <dl class="page-index">
-      <dt>8 Sept 2004</dt>
+  <dl class="page-index">
+    <dt>19 October 2005 - 1.33.1 release</dt>
 
-      <dd>
-        <ul>
-        Support for Python's Bool type, thanks to <a
-        mailto="dholth-at-fastmail.fm">Daniel Holth</a>.
-        </ul>
-      </dd>
+    <dd>
+      <ul>
+        <li><code>wrapper&lt;T&gt;</code> can now be used as expected with a
+        held type of <i>some-smart-pointer</i><code>&lt;T&gt;</code></li>
 
-      <dt>11 Sept 2003</dt>
+        <li>The build now assumes Python 2.4 by default, rather than 2.2</li>
 
-      <dd>
-        <ul>
-          <li>Changed the response to multiple to-python converters being
-          registered for the same type from a hard error into warning;
-          Boost.Python now reports the offending type in the message.</li>
+        <li>Support Python that's built without Unicode support</li>
 
-          <li>Added builtin <code>std::wstring</code> conversions</li>
+        <li>Support for wrapping classes with overloaded address-of
+        (<code>&amp;</code>) operators</li>
+      </ul>
+    </dd>
 
-          <li>Added <code>std::out_of_range</code> =&gt; Python
-          <code>IndexError</code> exception conversion, thanks to <a href=
-          "mailto:RaoulGough-at-yahoo.co.uk">Raoul Gough</a></li>
-        </ul>
-      </dd>
+    <dt>14 August 2005 - 1.33 release</dt>
 
-      <dt>9 Sept 2003</dt>
+    <dd>
+      <ul>
+        <li>Support for docstrings on nonstatic properties.</li>
 
-      <dd>Added new <code><a href="v2/str.html#str-spec">str</a></code></dd>
+        <li>We now export the client-provided docstrings for
+        <code>init&lt;optional&lt;&gt; &gt;</code> and
+        <i>XXX</i><code>_FUNCTION_OVERLOADS()</code> for only the last
+        overload.</li>
 
-      <dt>constructors which take a range of characters, allowing strings
-      containing nul (<code>'\0'</code>) characters.</dt>
+        <li>Fixed some support for Embedded VC++ 4</li>
 
-      <dt>8 Sept 2003</dt>
+        <li>Better support for rvalue from-python conversions of shared_ptr:
+        always return a pointer that holds the owning python object *unless*
+        the python object contains a NULL shared_ptr holder of the right
+        type.</li>
 
-      <dd>Added the ability to create methods from function objects (with an
-      <code>operator()</code>); see the <a href=
-      "v2/make_function.html#make_function-spec">make_function</a> docs for
-      more info.</dd>
+        <li>Support for exposing <code>vector&lt;T*&gt;</code> with the
+        indexing suite.</li>
 
-      <dt>10 August 2003</dt>
+        <li>Support for GCC-3.3 on MacOS.</li>
 
-      <dd>Added the new <code>properties</code> unit tests contributed by <a
-      href="mailto:romany-at-actimize.com">Roman Yakovenko</a> and documented
-      <code>add_static_property</code> at his urging.</dd>
+        <li>updated visual studio project build file to include two new files
+        (slice.cpp and wrapper.cpp)</li>
 
-      <dt>1 August 2003</dt>
+        <li>Added search feature to the index page.</li>
 
-      <dd>
-        Added the new <code>arg</code> class contributed by <a href=
-        "mailto:nickm-at-sitius.com">Nikolay Mladenov</a> which supplies the
-        ability to wrap functions that can be called with ommitted arguments
-        in the middle: 
-<pre>
+        <li>Numerous fixes to the tutorial</li>
+
+        <li>Numerous workarounds for MSVC 6 and 7, GCC 2.96, and EDG
+        2.45</li>
+      </ul>
+    </dd>
+
+    <dt>11 March 2005</dt>
+
+    <dd>
+      <ul>
+        <li>Added a hack that will fool PyDoc into working with Boost.Python,
+        thanks to Nick Rasmussen</li>
+      </ul>
+    </dd>
+
+    <dt>19 November 2004 - 1.32 release</dt>
+
+    <dd>
+      <ul>
+        <li>Updated to use the Boost Software License.</li>
+
+        <li>A new, <a href=
+        "tutorial/doc/html/python/exposing.html#python.class_virtual_functions">
+        better method of wrapping classes with virtual functions</a> has been
+        implemented.</li>
+
+        <li>Support for upcoming GCC symbol export control features have been
+        folded in, thanks to Niall Douglas.</li>
+
+        <li>Improved support for <code>std::auto_ptr</code>-like types.</li>
+
+        <li>The Visual C++ bug that makes top-level <i>cv-qualification</i>
+        of function parameter types part of the function type has been worked
+        around.</li>
+
+        <li>Components used by other libraries have been moved out of
+        <code>python/detail</code> and into <code>boost/detail</code> to
+        improve dependency relationships.</li>
+
+        <li>Miscellaneous bug fixes and compiler workarounds.</li>
+      </ul>
+    </dd>
+
+    <dt>8 Sept 2004</dt>
+
+    <dd>Support for Python's Bool type, thanks to <a href=
+    "mailto:dholth-at-fastmail.fm">Daniel Holth</a>.</dd>
+
+    <dt>11 Sept 2003</dt>
+
+    <dd>
+      <ul>
+        <li>Changed the response to multiple to-python converters being
+        registered for the same type from a hard error into warning;
+        Boost.Python now reports the offending type in the message.</li>
+
+        <li>Added builtin <code>std::wstring</code> conversions</li>
+
+        <li>Added <code>std::out_of_range</code> =&gt; Python
+        <code>IndexError</code> exception conversion, thanks to <a href=
+        "mailto:RaoulGough-at-yahoo.co.uk">Raoul Gough</a></li>
+      </ul>
+    </dd>
+
+    <dt>9 Sept 2003</dt>
+
+    <dd>Added new <code><a href="v2/str.html#str-spec">str</a></code></dd>
+
+    <dt>constructors which take a range of characters, allowing strings
+    containing nul (<code>'\0'</code>) characters.</dt>
+
+    <dt>8 Sept 2003</dt>
+
+    <dd>Added the ability to create methods from function objects (with an
+    <code>operator()</code>); see the <a href=
+    "v2/make_function.html#make_function-spec">make_function</a> docs for
+    more info.</dd>
+
+    <dt>10 August 2003</dt>
+
+    <dd>Added the new <code>properties</code> unit tests contributed by
+    <a href="mailto:romany-at-actimize.com">Roman Yakovenko</a> and
+    documented <code>add_static_property</code> at his urging.</dd>
+
+    <dt>1 August 2003</dt>
+
+    <dd>
+      Added the new <code>arg</code> class contributed by <a href=
+      "mailto:nickm-at-sitius.com">Nikolay Mladenov</a> which supplies the
+      ability to wrap functions that can be called with ommitted arguments in
+      the middle:
+      <pre>
 void f(int x = 0, double y = 3.14, std::string z = std::string("foo"));
 
 BOOST_PYTHON_MODULE(test)
@@ -90,111 +174,104 @@ BOOST_PYTHON_MODULE(test)
        , (arg("x", 0), arg("y", 3.14), arg("z", "foo")));
 }
  
-</pre>
-        And in Python: 
-<pre>
+</pre>And in Python:
+      <pre>
 &gt;&gt;&gt; import test
 &gt;&gt;&gt; f(0, z = "bar")
 &gt;&gt;&gt; f(z = "bar", y = 0.0)
-</pre>
-        Thanks, Nikolay!
-      </dd>
+</pre>Thanks, Nikolay!
+    </dd>
 
-      <dt>22 July 2003</dt>
+    <dt>22 July 2003</dt>
 
-      <dd>Killed the dreaded "bad argument type for builtin operation" error.
-      Argument errors now show the actual and expected argument types!</dd>
+    <dd>Killed the dreaded "bad argument type for builtin operation" error.
+    Argument errors now show the actual and expected argument types!</dd>
 
-      <dt>19 July 2003</dt>
+    <dt>19 July 2003</dt>
 
-      <dd>Added the new <code><a href=
-      "v2/return_arg.html">return_arg</a></code> policy from <a href=
-      "mailto:nickm-at-sitius.com">Nikolay Mladenov</a>. Thanks,
-      Nikolay!</dd>
+    <dd>Added the new <code><a href=
+    "v2/return_arg.html">return_arg</a></code> policy from <a href=
+    "mailto:nickm-at-sitius.com">Nikolay Mladenov</a>. Thanks, Nikolay!</dd>
 
-      <dt>18 March, 2003</dt>
+    <dt>18 March, 2003</dt>
 
-      <dd><a href="mailto:Gottfried.Ganssauge-at-haufe.de">Gottfried
-      Gan&szlig;auge</a> has contributed <a href=
-      "v2/opaque_pointer_converter.html">opaque pointer support</a>.<br>
-       <a href="mailto:nicodemus-at-globalite.com.br">Bruno da Silva de Oliveira</a>
-      has contributed the exciting <a href="../pyste/index.html">Pyste</a>
-      ("Pie-steh") package.</dd>
+    <dd><a href="mailto:Gottfried.Ganssauge-at-haufe.de">Gottfried
+    Gan&szlig;auge</a> has contributed <a href=
+    "v2/opaque_pointer_converter.html">opaque pointer support</a>.<br>
+    <a href="mailto:nicodemus-at-globalite.com.br">Bruno da Silva de
+    Oliveira</a> has contributed the exciting <a href=
+    "../pyste/index.html">Pyste</a> ("Pie-steh") package.</dd>
 
-      <dt>24 February 2003</dt>
+    <dt>24 February 2003</dt>
 
-      <dd>Finished improved support for <code>boost::shared_ptr</code>. Now
-      any wrapped object of C++ class <code>X</code> can be converted
-      automatically to <code>shared_ptr&lt;X&gt;</code>, regardless of how it
-      was wrapped. The <code>shared_ptr</code> will manage the lifetime of
-      the Python object which supplied the <code>X</code>, rather than just
-      the <code>X</code> object itself, and when such a
-      <code>shared_ptr</code> is converted back to Python, the original
-      Python object will be returned.</dd>
+    <dd>Finished improved support for <code>boost::shared_ptr</code>. Now any
+    wrapped object of C++ class <code>X</code> can be converted automatically
+    to <code>shared_ptr&lt;X&gt;</code>, regardless of how it was wrapped.
+    The <code>shared_ptr</code> will manage the lifetime of the Python object
+    which supplied the <code>X</code>, rather than just the <code>X</code>
+    object itself, and when such a <code>shared_ptr</code> is converted back
+    to Python, the original Python object will be returned.</dd>
 
-      <dt>19 January 2003</dt>
+    <dt>19 January 2003</dt>
 
-      <dd>Integrated <code>staticmethod</code> support from <a href=
-      "mailto:nickm-at-sitius.com">Nikolay Mladenov</a>. Thanks,
-      Nikolay!</dd>
+    <dd>Integrated <code>staticmethod</code> support from <a href=
+    "mailto:nickm-at-sitius.com">Nikolay Mladenov</a>. Thanks, Nikolay!</dd>
 
-      <dt>29 December 2002</dt>
+    <dt>29 December 2002</dt>
 
-      <dd>Added Visual Studio project file and instructions from Brett
-      Calcott. Thanks, Brett!</dd>
+    <dd>Added Visual Studio project file and instructions from Brett Calcott.
+    Thanks, Brett!</dd>
 
-      <dt>20 December 2002</dt>
+    <dt>20 December 2002</dt>
 
-      <dd>Added automatic downcasting for pointers, references, and smart
-      pointers to polymorphic class types upon conversion to python</dd>
+    <dd>Added automatic downcasting for pointers, references, and smart
+    pointers to polymorphic class types upon conversion to python</dd>
 
-      <dt>18 December 2002</dt>
+    <dt>18 December 2002</dt>
 
-      <dd>Optimized from_python conversions for wrapped classes by putting
-      the conversion logic in the shared library instead of registering
-      separate converters for each class in each extension module</dd>
+    <dd>Optimized from_python conversions for wrapped classes by putting the
+    conversion logic in the shared library instead of registering separate
+    converters for each class in each extension module</dd>
 
-      <dt>19 November 2002</dt>
+    <dt>19 November 2002</dt>
 
-      <dd>Removed the need for users to cast base class member function
-      pointers when used as arguments to <a href=
-      "v2/class.html#class_-spec-modifiers">add_property</a></dd>
+    <dd>Removed the need for users to cast base class member function
+    pointers when used as arguments to <a href=
+    "v2/class.html#class_-spec-modifiers">add_property</a></dd>
 
-      <dt>13 December 2002</dt>
+    <dt>13 December 2002</dt>
 
-      <dd>Allow exporting of <a href=
-      "v2/enum.html#enum_-spec"><code>enum_</code></a> values into enclosing
-      <a href="v2/scope.html#scope-spec"><code>scope</code></a>.<br>
-       Fixed unsigned integer conversions to deal correctly with numbers that
-      are out-of-range of <code>signed long</code>.</dd>
+    <dd>Allow exporting of <a href=
+    "v2/enum.html#enum_-spec"><code>enum_</code></a> values into enclosing
+    <a href="v2/scope.html#scope-spec"><code>scope</code></a>.<br>
+    Fixed unsigned integer conversions to deal correctly with numbers that
+    are out-of-range of <code>signed long</code>.</dd>
 
-      <dt>14 November 2002</dt>
+    <dt>14 November 2002</dt>
 
-      <dd>Auto-detection of class data members wrapped with <a href=
-      "v2/data_members.html#make_getter-spec"><code>make_getter</code></a></dd>
+    <dd>Auto-detection of class data members wrapped with <a href=
+    "v2/data_members.html#make_getter-spec"><code>make_getter</code></a></dd>
 
-      <dt>13 November 2002</dt>
+    <dt>13 November 2002</dt>
 
-      <dd>Full Support for <code>std::auto_ptr&lt;&gt;</code> added.</dd>
+    <dd>Full Support for <code>std::auto_ptr&lt;&gt;</code> added.</dd>
 
-      <dt>October 2002</dt>
+    <dt>October 2002</dt>
 
-      <dd>Ongoing updates and improvements to tutorial documentation</dd>
+    <dd>Ongoing updates and improvements to tutorial documentation</dd>
 
-      <dt>10 October 2002</dt>
+    <dt>10 October 2002</dt>
 
-      <dd>Boost.Python V2 is released!</dd>
-    </dl>
-    <hr>
+    <dd>Boost.Python V2 is released!</dd>
+  </dl>
+  <hr>
 
-    <p>Revised 
-    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     11 September 2003 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-    </p>
+  <p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+   19 November 2004 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
 
-    <p><i>&copy; Copyright <a href="../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002-2003. All Rights Reserved.</i></p>
-  </body>
+  <p><i>&copy; Copyright <a href="../../../people/dave_abrahams.htm">Dave
+  Abrahams</a> 2002-2003.</i></p>
+</body>
 </html>
-

doc/projects.html

@@ -4,7 +4,7 @@
   <head>
     <meta name="generator" content=
     "HTML Tidy for Cygwin (vers 1st April 2002), see www.w3.org">
-    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <meta http-equiv="Content-Type" content="text/html; charset="utf-8">
     <link rel="stylesheet" type="text/css" href="boost.css">
 
     <title>Boost.Python - Projects using Boost.Python</title>
@@ -42,7 +42,7 @@
 
     <dl class="page-index">
       <dt><b><a href=
-      "http://www.neuralynx.com/neuralab/index.htm">NeuraLab</a></b></dt>
+      "http://www.neuralynx.com">NeuraLab</a></b></dt>
 
       <dd>Neuralab is a data analysis environment specifically tailored for
       neural data from <a href="http://www.neuralynx.com">Neuralynx</a>
@@ -141,6 +141,34 @@
 
     <h3>Games</h3>
 
+    <dl>
+      <dt><b><a href="http://www.firaxis.com">Civilization IV</a></b></dt>
+    </dl>
+
+    <blockquote>
+      “The fourth game in the PC strategy series that has
+      sold over five million copies, Sid Meier's Civilization IV is a bold
+      step forward for the franchise, with spectacular new 3D graphics and
+      all-new single and multiplayer content. Civilization IV will also set a
+      new standard for user-modification, allowing gamers to create their own
+      add-ons using Python and XML. 
+
+      <p>Sid Meier's Civilization IV will be released for PC in late 2005.
+      For more information please visit <a href=
+      "http://www.firaxis.com">http://www.firaxis.com</a> or write <a href=
+      "mailto:kgilmore@firaxis.com">kgilmore@firaxis.com</a>”</p>
+    </blockquote>
+
+    <p>Boost.Python is used as the interface layer between the C++ game code
+    and Python. Python is used for many purposes in the game, including map
+    generation, interface screens, game events, tools, tutorials, etc. Most
+    high-level game operations have been exposed to Python in order to give
+    modders the power they need to customize the game.</p>
+
+    <blockquote>
+      -Mustafa Thamer, Civ4 Lead Programmer
+    </blockquote>
+
     <dl class="page-index">
       <dt><b><a href="http://vegastrike.sourceforge.net">Vega
       Strike</a></b></dt>
@@ -203,8 +231,8 @@
       <dt><a href="http://www.iplt.org"><b>IPLT</b></a></dt>
 
       <dd>
-        <a href="mailto:ansgar.philippsen-at-unibas.ch">Ansgar
-        Philippsen</a> writes: 
+        <a href="mailto:ansgar.philippsen-at-unibas.ch">Ansgar Philippsen</a>
+        writes: 
 
         <blockquote>
           IPLT is an image processing library and toolbox for the structural
@@ -323,13 +351,13 @@
 
         <p>Two projects have been developed so far with this technology:</p>
 
-        <p><b><a href="http://www.esss.com.br/dev_simba.phtml">Simba</a></b>
+        <p><b><a href="http://www.esss.com.br/index.php?pg=dev_projetos">Simba</a></b>
         provides 3D visualization of geological formations gattered from the
         simulation of the evolution of oil systems, allowing the user to
         analyse various aspects of the simulation, like deformation, pressure
         and fluids, along the time of the simulation.</p>
 
-        <p><b><a href="http://www.esss.com.br/dev_aero.phtml">Aero</a></b>
+        <p><b><a href="http://www.esss.com.br/index.php?pg=dev_projetos">Aero</a></b>
         aims to construct a CFD with brazilian technology, which involves
         various companies and universities. ESSS is responsible for various
         of the application modules, including GUI and post-processing of
@@ -360,6 +388,24 @@
       </dd>
     </dl>
 
+    <h3>Systems Libraries</h3>
+
+    <dl>
+      <dt><a href="http://itamarst.org/software"><b>Fusion</b></a></dt>
+
+      <dd>
+        <p>Fusion is a library that supports implementing protocols in C++
+        for use with Twisted, allowing control over memory allocation
+        strategies, fast method calls internally, etc.. Fusion supports TCP,
+        UDP and multicast, and is implemented using the Boost.Python python
+        bindings.</p>
+
+        <p>Fusion is licensed under the MIT license, and available for
+        download from <a href=
+        "http://itamarst.org/software">http://itamarst.org/software</a>.</p>
+      </dd>
+    </dl>
+
     <h3>Tools</h3>
 
     <dl>
@@ -384,7 +430,7 @@
      15 July, 2003</p>
 
     <p><i>&copy; Copyright <a href="../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002-2003. All Rights Reserved.</i></p>
+    Abrahams</a> 2002-2003.</i></p>
   </body>
 </html>
 

doc/tutorial/doc/Jamfile.v2

@@ -1,5 +1,12 @@
 project boost/libs/python/doc/tutorial/doc ;
-import boostbook : boostbook ;
 
-boostbook tutorial : tutorial.xml
+import boostbook : boostbook ;
+using quickbook ;
+
+boostbook tutorial
+    :
+        tutorial.qbk
+    :
+        <xsl:param>boost.root=../../../../../..
+        <xsl:param>boost.libraries=../../../../../../libs/libraries.htm
     ;

doc/tutorial/doc/catalog.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0"?>  
-<!DOCTYPE catalog  
-  PUBLIC "-//OASIS/DTD Entity Resolution XML Catalog V1.0//EN" 
-  "http://www.oasis-open.org/committees/entity/release/1.0/catalog.dtd"> 
-<catalog xmlns="urn:oasis:names:tc:entity:xmlns:xml:catalog"> 
-  <rewriteURI uriStartString="http://www.boost.org/tools/boostbook/dtd/" rewritePrefix="file:///C:/dev/boost/tools/boostbook/dtd//"/> 
-  <rewriteURI uriStartString="http://docbook.sourceforge.net/release/xsl/current/" rewritePrefix="file:///C:/dev/tools/boostbook/docbook-xsl-1.65.1/"/> 
-  <rewriteURI uriStartString="http://www.oasis-open.org/docbook/xml/4.2/" rewritePrefix="file:///C:/dev/tools/boostbook/docbook-xml-4.2/"/> 
-</catalog> 

doc/tutorial/doc/html/HTML.manifest

@@ -1,9 +0,0 @@
-index.html
-python/hello.html
-python/exposing.html
-python/functions.html
-python/object.html
-python/embedding.html
-python/iterators.html
-python/exception.html
-python/techniques.html

doc/tutorial/doc/html/boostbook.css

@@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2002 2004 Joel de Guzman
+    Copyright (c) 2004 Joel de Guzman
     http://spirit.sourceforge.net/
 
     Use, modification and distribution is subject to the Boost Software
@@ -7,289 +7,424 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 
-/* CSS based on w3c documentation which I like a lot, and the classic Spirit
-documentation. */
+/*=============================================================================
+    Body defaults
+=============================================================================*/
 
-/* Body defaults */
-body 
-{
-    padding: 2em 1em 2em 1em;
-    margin: 1em 1em 1em 1em;
-    font-family: sans-serif;
-}
-
-/* Paragraphs */
-p 
-{
-    text-align: justify;
-}
-
-pre.synopsis
-{
-    margin: 1pc 4% 0pc 4%;
-    padding: 0.5pc 0.5pc 0.5pc 0.5pc;
-}
-
-/* Headings */
-h1, h2, h3, h4, h5, h6 { text-align: left; margin-top: 2pc; }
-h1 { font: 170% sans-serif }
-h2 { font: bold 140% sans-serif }
-h3 { font: 120% sans-serif }
-h4 { font: bold 100% sans-serif }
-h5 { font: italic 100% sans-serif }
-h6 { font: italic 100% sans-serif }
-
-/* Unordered lists */
-ul 
-{
-    text-align: justify;
-}
-
-/* Links */
-a
-{
-    text-decoration: none; /* no underline */
-}
-
-a:hover
-{
-    text-decoration: underline;
-}
-
-/* Top page title */
-title, h1.title, h2.title, h3.title,
-       h4.title, h5.title, h6.title,
-       .refentrytitle
-{
-    font-weight:   bold;
-    font-size:     2pc;
-    margin-bottom: 1pc;
-}
-
-/* Spirit style navigation */
-.spirit-nav
-{
-    text-align: right;
-}
-
-.spirit-nav a
-{
-    color: white;
-    padding-left: 0.5em;
-}
-
-.spirit-nav img
-{
-    border-width: 0px;
-}
-
-/* Program listing box */
-.programlisting, .screen
-{
-    display: block;
-    margin-left:  4%;
-    margin-right: 4%;
-    padding: 0.5pc 0.5pc 0.5pc 0.5pc;
-}
-
-/* Table of contents */
-.toc
-{
-   margin: 1pc 4% 0pc 4%;
-   padding: 0.5pc 0.5pc 0.5pc 0.5pc;
-}
-
-.boost-toc
-{
-   float:   right;
-   padding: 0.5pc;
-}
-
-/* Tables */
-.table-title, div.table p.title
-{
-    margin-left: 4%;
-    padding-right: 0.5em; 
-    padding-left: 0.5em;
-    font-size: 120%;
-}
-
-.informaltable table, .table table
-{
-    width: 92%;
-    margin-left: 4%;
-    margin-right: 4%;
-}
-
-div.informaltable table, div.table table
-{
-    padding: 4px 4px 4px 4px;
-}
-
-div.informaltable table tr td, div.table table tr td
-{
-    padding: 0.5em 0.5em 0.5em 0.5em;
-    text-align: justify;
-}
-
-div.informaltable table tr th, div.table table tr th
-{
-    padding: 0.5em 0.5em 0.5em 0.5em;
-    border: 1pt solid white;
-}
-
-/* inlined images */
-.inlinemediaobject
-{
-    padding: 0.5em 0.5em 0.5em 0.5em;
-}
-
-/* tone down the title of Parameter lists */
-div.variablelist p.title
-{
-    font-weight: bold;
-    font-size: 100%;
-    text-align: left;
-}
-
-/* tabularize parameter lists */
-div.variablelist dl dt
-{
-    float: left;
-    clear: left;
-    display: block;
-    font-style: italic;
-}
-
-div.variablelist dl dd
-{
-    display: block;
-    clear:   right;
-    padding-left: 8pc;
-}
-
-/* title of books and articles in bibliographies */
-span.title
-{
-    font-style: italic;
-}
-
-
-@media screen
-{
-    a
+    body 
     {
-        color: #005a9c;
+        margin: 1em;
+        font-family: sans-serif;
     }
 
-    a:visited
+/*=============================================================================
+    Paragraphs
+=============================================================================*/
+
+    p 
     {
-        color: #9c5a9c;
+        text-align: justify;
+        font-size: 11pt; 
+        line-height: 1.2;
     }
 
-    /* Syntax Highlighting */
-    .keyword        { color: #0000AA; font-weight: bold; }
-    .identifier     {}
-    .special        { color: #707070; }
-    .preprocessor   { color: #402080; font-weight: bold; }
-    .char           { color: teal; }
-    .comment        { color: #800000; }
-    .string         { color: teal; }
-    .number         { color: teal; }
-    .copyright      { color: #666666; font-size: small; }
-    .white_bkd      { background-color: #FFFFFF; }
-    .dk_grey_bkd    { background-color: #999999; }
+/*=============================================================================
+    Program listings
+=============================================================================*/
+
+    tt.computeroutput
+    {
+        font-size: 10pt;
+    }
 
     pre.synopsis
     {
-        background-color: #f3f3f3;
+        font-size: 10pt;
+        margin: 1pc 4% 0pc 4%;
+        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
     }
 
-    .programlisting, .screen
+    .programlisting, 
+    .screen
     {
-        background-color: #f3f3f3;
+        font-size: 10pt;
+        display: block;
+        margin: 1pc 4% 0pc 4%;
+        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
     }
 
-    /* Table of contents */
-    .toc
+/*=============================================================================
+    Headings
+=============================================================================*/
+
+    h1, 
+    h2, 
+    h3, 
+    h4, 
+    h5, 
+    h6 
+    { 
+        text-align: left; 
+        margin-top: 2pc; 
+    }
+
+    h1 { font: 170% }
+    h2 { font: bold 140% }
+    h3 { font: bold 120% }
+    h4 { font: bold 100% }
+    h5 { font: italic 100% }
+    h6 { font: italic 100% }
+
+    /* Top page titles */
+    title, 
+    h1.title, 
+    h2.title
+    h3.title, 
+    h4.title, 
+    h5.title, 
+    h6.title, 
+    .refentrytitle
     {
-        background-color: #f3f3f3;
+        font-weight: bold;
+        margin-bottom: 1pc;
     }
 
-    div.informaltable table tr td, div.table table tr td
+    h1.title { font-size: 220% }
+    h2.title { font-size: 220% }
+    h3.title { font-size: 170% }
+    h4.title { font-size: 140% }
+    h5.title { font-size: 120% }
+    h6.title { font-size: 120% }
+
+/*=============================================================================
+    Lists
+=============================================================================*/
+
+    li
     {
-        background-color: #F3F3F3;
-        border: 1pt solid white;
+        font-size: 11pt;
+        line-height: 1.3;
     }
-
-    div.informaltable table tr th, div.table table tr th
+    
+    /* Unordered lists */
+    ul 
     {
-        background-color: #e4e4e4;
+        text-align: justify;
     }
-
-    span.highlight
+    
+    /* Ordered lists */
+    ol 
     {
-        color: #00A000;
+        text-align: justify;
     }
-}
 
-@media print
-{
+/*=============================================================================
+    Links
+=============================================================================*/
+
     a
     {
-        color: black;
+        text-decoration: none; /* no underline */
+    }
+    
+    a:hover
+    {
+        text-decoration: underline;
     }
 
-    a:visited
-    {
-        color: black;
-    }
+/*=============================================================================
+    Spirit style navigation
+=============================================================================*/
 
     .spirit-nav
     {
-        display: none;
+        text-align: right;
     }
-
-    /* Syntax Highlighting */
-    .keyword
+    
+    .spirit-nav a
     {
-        font-weight: bold;
+        color: white;
+        padding-left: 0.5em;
     }
-
-    pre.synopsis
+    
+    .spirit-nav img
     {
-        border: 1px solid gray;
+        border-width: 0px;
     }
 
-    .programlisting, .screen
-    {
-        border: 1px solid gray;
-    }
+/*=============================================================================
+    Table of contents
+=============================================================================*/
 
-    /* Table of contents */
     .toc
     {
-        border: 1px solid gray;
+       margin: 1pc 4% 0pc 4%;
+       padding: 0.5pc;
+       font-size: 11pt; 
+       line-height: 1.3;
     }
-
-    .informaltable table, .table table
+    
+    .boost-toc
     {
-        border: 1px solid gray;
-        border-collapse: collapse;
+       float: right;
+       padding: 0.5pc;
     }
 
-    div.informaltable table tr td, div.table table tr td
+/*=============================================================================
+    Tables
+=============================================================================*/
+
+    .table-title, 
+    div.table p.title
     {
-        border: 1px solid gray;
+        margin-left: 4%;
+        padding-right: 0.5em; 
+        padding-left: 0.5em;
+        font-size: 120%;
     }
-
-    div.informaltable table tr th, div.table table tr th
+    
+    .informaltable table, 
+    .table table
     {
-        border: 1px solid gray;
+        width: 92%;
+        margin-left: 4%;
+        margin-right: 4%;
+    }
+    
+    div.informaltable table, 
+    div.table table
+    {
+        padding: 4px;
+    }
+    
+    /* Table Cells */
+    div.informaltable table tr td, 
+    div.table table tr td
+    {
+        padding: 0.5em;
+        text-align: justify;
+        font-size: 11pt;
     }
 
-    span.highlight
+    div.informaltable table tr th, 
+    div.table table tr th
+    {
+        padding: 0.5em 0.5em 0.5em 0.5em;
+        border: 1pt solid white;
+    }
+
+/*=============================================================================
+    Blurbs
+=============================================================================*/
+
+    div.informaltable table tr td.blurb
+    {
+        font-size: 10pt; /* A little bit smaller than the main text */
+        line-height: 1.2;
+    }
+    
+    td.blurb img
+    {
+        padding: 1pt;
+    }
+
+/*=============================================================================
+    Misc
+=============================================================================*/
+
+    /* Tone down the title of Parameter lists */
+    div.variablelist p.title
     {
         font-weight: bold;
+        font-size: 100%;
+        text-align: left;
+    }
+    
+    /* Tabularize parameter lists */
+    div.variablelist dl dt
+    {
+        float: left;
+        clear: left;
+        display: block;
+        font-style: italic;
+    }
+    
+    div.variablelist dl dd
+    {
+        display: block;
+        clear:   right;
+        padding-left: 8pc;
+    }
+
+    /* Title of books and articles in bibliographies */
+    span.title
+    {
+        font-style: italic;
+    }
+
+    span.underline
+    {
+        text-decoration: underline;
+    }
+
+    span.strikethrough
+    {
+        text-decoration: line-through;
+    }
+
+    /* Copyright, Legal Notice */
+    div div.legalnotice p
+    {
+        text-align: left
+    }
+
+/*=============================================================================
+    Colors
+=============================================================================*/
+
+    @media screen
+    {
+    /* Links */
+        a
+        {
+            color: #005a9c;
+        }
+    
+        a:visited
+        {
+            color: #9c5a9c;
+        }
+    
+    /* Syntax Highlighting */
+        .keyword        { color: #0000AA; }
+        .identifier     { color: #000000; }
+        .special        { color: #707070; }
+        .preprocessor   { color: #402080; }
+        .char           { color: teal; }
+        .comment        { color: #800000; }
+        .string         { color: teal; }
+        .number         { color: teal; }
+        .white_bkd      { background-color: #FFFFFF; }
+        .dk_grey_bkd    { background-color: #999999; }
+    
+    /* Copyright, Legal Notice */
+        .copyright      
+        { 
+            color: #666666; 
+            font-size: small; 
+        }
+    
+        div div.legalnotice p
+        {
+            color: #666666;
+        }
+    
+    /* Program listing */
+        pre.synopsis
+        {
+            background-color: #F3F3F3;
+            border: 1pt solid #C0C0C0;
+        }
+    
+        .programlisting, 
+        .screen
+        {
+            background-color: #F3F3F3;
+            border: 1pt solid #C0C0C0;
+        }
+    
+    /* Blurbs */
+        div.informaltable table tr td.blurb
+        {
+            background-color: #FFFFF0;
+            border: 1pt solid #707070;
+        }
+    
+    /* Table of contents */
+        .toc
+        {
+            background-color: #F3F3F3;
+        }
+    
+    /* Tables */
+        div.informaltable table tr td, 
+        div.table table tr td
+        {
+            background-color: #F0F0F0;
+        }
+    
+        div.informaltable table tr th, 
+        div.table table tr th
+        {
+            background-color: #E4E4E4;
+        }
+    
+    /* Misc */
+        span.highlight
+        {
+            color: #00A000;
+        }
+    }
+    
+    @media print
+    {
+    /* Links */
+        a
+        {
+            color: black;
+        }
+    
+        a:visited
+        {
+            color: black;
+        }
+    
+        .spirit-nav
+        {
+            display: none;
+        }
+    
+    /* Program listing */
+        pre.synopsis
+        {
+            border: 1px solid gray;
+        }
+    
+        .programlisting, 
+        .screen
+        {
+            border: 1px solid gray;
+        }
+    
+    /* Table of contents */
+        .toc
+        {
+            border: 1px solid gray;
+        }
+    
+        .informaltable table, 
+        .table table
+        {
+            border: 1px solid gray;
+            border-collapse: collapse;
+        }
+    
+    /* Tables */
+        div.informaltable table tr td, 
+        div.table table tr td
+        {
+            border: 1px solid gray;
+        }
+    
+        div.informaltable table tr th, 
+        div.table table tr th
+        {
+            border: 1px solid gray;
+        }
+    
+    /* Misc */
+        span.highlight
+        {
+            font-weight: bold;
+        }
     }
-}

doc/tutorial/doc/html/index.html

@@ -3,24 +3,23 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Chapter 1. python 1.0</title>
 <link rel="stylesheet" href="boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
-<link rel="home" href="index.html" title="Chapter 1. python 1.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<link rel="start" href="index.html" title="Chapter 1. python 1.0">
 <link rel="next" href="python/hello.html" title=" Building Hello World">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%">
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../boost.png"></td>
-<td align="center"><a href="../../index.htm">Home</a></td>
-<td align="center"><a href="libraries.html">Libraries</a></td>
-<td align="center"><a href="../../people/people.htm">People</a></td>
-<td align="center"><a href="../../more/faq.htm">FAQ</a></td>
-<td align="center"><a href="../../more/index.htm">More</a></td>
+<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
 </table>
 <hr>
 <div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="images/next.png" alt="Next"></a></div>
 <div class="chapter" lang="en">
-<div class="titlepage">
-<div>
+<div class="titlepage"><div>
 <div><h2 class="title">
 <a name="python"></a>Chapter 1. python 1.0</h2></div>
 <div><div class="author"><h3 class="author">
@@ -29,18 +28,18 @@
 <div><div class="author"><h3 class="author">
 <span class="firstname">David</span> <span class="surname">Abrahams</span>
 </h3></div></div>
-<div><p class="copyright">Copyright © 2002-2004 Joel de Guzman, David Abrahams</p></div>
-<div><div class="legalnotice"><p>
+<div><p class="copyright">Copyright © 2002-2005 Joel de Guzman, David Abrahams</p></div>
+<div><div class="legalnotice">
+<a name="id442427"></a><p>
         Distributed under the Boost Software License, Version 1.0.
         (See accompanying file LICENSE_1_0.txt or copy at
         <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
             http://www.boost.org/LICENSE_1_0.txt
         </a>)
     
-      </p></div></div>
-</div>
-<div></div>
-</div>
+      </p>
+</div></div>
+</div></div>
 <div class="toc">
 <p><b>Table of Contents</b></p>
 <dl>
@@ -53,7 +52,6 @@
 <dt><span class="section"><a href="python/exposing.html#python.class_properties">Class Properties</a></span></dt>
 <dt><span class="section"><a href="python/exposing.html#python.inheritance">Inheritance</a></span></dt>
 <dt><span class="section"><a href="python/exposing.html#python.class_virtual_functions">Class Virtual Functions</a></span></dt>
-<dt><span class="section"><a href="python/exposing.html#python.deriving_a_python_class">Deriving a Python Class</a></span></dt>
 <dt><span class="section"><a href="python/exposing.html#python.virtual_functions_with_default_implementations">Virtual Functions with Default Implementations</a></span></dt>
 <dt><span class="section"><a href="python/exposing.html#python.class_operators_special_functions">Class Operators/Special Functions</a></span></dt>
 </dl></dd>
@@ -84,11 +82,8 @@
 </dl>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h2 class="title" style="clear: both">
-<a name="python.quickstart"></a>QuickStart</h2></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="python.quickstart"></a>QuickStart</h2></div></div></div>
 <p>
 The Boost Python Library is a framework for interfacing Python and
 C++. It allows you to quickly and seamlessly expose C++ classes
@@ -101,7 +96,7 @@ metaprogramming techniques simplifies its syntax for users, so that
 wrapping code takes on the look of a kind of declarative interface
 definition language (IDL).</p>
 <a name="quickstart.hello_world"></a><h2>
-<a name="id344076"></a>Hello World</h2>
+<a name="id372086"></a>Hello World</h2>
 <p>
 Following C/C++ tradition, let's start with the "hello, world". A C++
 Function:</p>
@@ -121,14 +116,16 @@ BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier"
 <p>
 That's it. We're done. We can now build this as a shared library. The
 resulting DLL is now visible to Python. Here's a sample Python session:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> import</span><span class="identifier"> hello</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> print</span><span class="identifier"> hello</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span><span class="identifier">
+<p></p>
+<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="keyword"> import</span><span class="identifier"> hello</span><span class="special">
+&gt;&gt;&gt;</span><span class="keyword"> print</span><span class="identifier"> hello</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span><span class="identifier">
 hello</span><span class="special">,</span><span class="identifier"> world</span></tt></pre>
+<p></p>
 <div class="blockquote"><blockquote class="blockquote"><p><span class="emphasis"><em><span class="bold"><b>Next stop... Building your Hello World module from start to finish...</b></span></em></span></p></blockquote></div>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><small><p>Last revised: October 12, 2004 at 03:11:11 GMT</p></small></td>
+<td align="left"><small><p>Last revised: July 12, 2005 at 07:50:43 GMT</p></small></td>
 <td align="right"><small></small></td>
 </tr></table>
 <hr>

doc/tutorial/doc/html/python/embedding.html

@@ -3,31 +3,28 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Embedding</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
-<link rel="home" href="../index.html" title="Chapter 1. python 1.0">
+<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="previous" 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%">
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../boost.png"></td>
-<td align="center"><a href="../../../index.htm">Home</a></td>
-<td align="center"><a href="../libraries.html">Libraries</a></td>
-<td align="center"><a href="../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../more/faq.htm">FAQ</a></td>
-<td align="center"><a href="../../../more/index.htm">More</a></td>
+<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="object.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../images/next.png" alt="Next"></a>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h2 class="title" style="clear: both">
-<a name="python.embedding"></a>Embedding</h2></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="python.embedding"></a>Embedding</h2></div></div></div>
 <div class="toc"><dl><dt><span class="section"><a href="embedding.html#python.using_the_interpreter">Using the interpreter</a></span></dt></dl></div>
 <p>
 By now you should know how to use Boost.Python to call your C++ code from
@@ -42,7 +39,7 @@ the gaps. However, Boost.Python already makes embedding a lot easier and,
 in a future version, it may become unnecessary to touch the Python/C API at
 all. So stay tuned... <span class="inlinemediaobject"><img src="../images/smiley.png"></span></p>
 <a name="embedding.building_embedded_programs"></a><h2>
-<a name="id428755"></a>Building embedded programs</h2>
+<a name="id456196"></a>Building embedded programs</h2>
 <p>
 To be able to use embedding in your programs, they have to be linked to
 both Boost.Python's and Python's static link library.</p>
@@ -51,7 +48,8 @@ Boost.Python's static link library comes in two variants. Both are located
 in Boost's <tt class="literal">/libs/python/build/bin-stage</tt> subdirectory. On Windows, the
 variants are called <tt class="literal">boost_python.lib</tt> (for release builds) and
 <tt class="literal">boost_python_debug.lib</tt> (for debugging). If you can't find the libraries,
-you probably haven't built Boost.Python yet. See <a href="../../../../building.html%20Building" target="_top">and Testing</a> on how to do this.</p>
+you probably haven't built Boost.Python yet. See
+<a href="../../../../building.html" target="_top">Building and Testing</a> on how to do this.</p>
 <p>
 Python's static link 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
@@ -61,39 +59,36 @@ Additionally, Python's <tt class="literal">/include</tt> subdirectory has to be
 include path.</p>
 <p>
 In a Jamfile, all the above boils down to:</p>
-<pre class="programlisting"><tt class="literal">    projectroot c:\projects\embedded_program ; # location of the program
+<pre class="programlisting"><tt class="literal">projectroot c:\projects\embedded_program ; # location of the program
 
-    # bring in the rules for python
-    SEARCH on python.jam = $(BOOST_BUILD_PATH) ;
-    include python.jam ;
+# bring in the rules for python
+SEARCH on python.jam = $(BOOST_BUILD_PATH) ;
+include python.jam ;
 
-    exe embedded_program # name of the executable
-      : #sources
-         embedded_program.cpp
-      : # requirements
-         &lt;find-library&gt;boost_python &lt;library-path&gt;c:\boost\libs\python
-      $(PYTHON_PROPERTIES)
-        &lt;library-path&gt;$(PYTHON_LIB_PATH)
-        &lt;find-library&gt;$(PYTHON_EMBEDDED_LIBRARY) ;
+exe embedded_program # name of the executable
+  : #sources
+     embedded_program.cpp
+  : # requirements
+     &lt;find-library&gt;boost_python &lt;library-path&gt;c:\boost\libs\python
+  $(PYTHON_PROPERTIES)
+    &lt;library-path&gt;$(PYTHON_LIB_PATH)
+    &lt;find-library&gt;$(PYTHON_EMBEDDED_LIBRARY) ;
 </tt></pre>
 <a name="embedding.getting_started"></a><h2>
-<a name="id428846"></a>Getting started</h2>
+<a name="id456277"></a>Getting started</h2>
 <p>
 Being able to build is nice, but there is nothing to build yet. Embedding
 the Python interpreter into one of your C++ programs requires these 4
 steps:</p>
 <div class="orderedlist"><ol type="1">
 <li>
-#include <tt class="literal">&lt;boost/python.hpp&gt;</tt><p></p>
-<p></p>
+#include <tt class="literal">&lt;boost/python.hpp&gt;</tt><br><br>
 </li>
 <li>
-Call <a href="http://www.python.org/doc/current/api/initialization.html#l2h-652" target="_top">Py_Initialize</a>() to start the interpreter and create the <tt class="literal"><span class="underline">_main</span>_</tt> module.<p></p>
-<p></p>
+Call <a href="http://www.python.org/doc/current/api/initialization.html#l2h-652" target="_top">Py_Initialize</a>() to start the interpreter and create the <tt class="literal"><span class="underline">_main</span>_</tt> module.<br><br>
 </li>
 <li>
-Call other Python C API routines to use the interpreter.<p></p>
-<p></p>
+Call other Python C API routines to use the interpreter.<br><br>
 </li>
 <li>
 Call <a href="http://www.python.org/doc/current/api/initialization.html#l2h-656" target="_top">Py_Finalize</a>() to stop the interpreter and release its resources.
@@ -103,11 +98,8 @@ Call <a href="http://www.python.org/doc/current/api/initialization.html#l2h-656"
 (Of course, there can be other C++ code between all of these steps.)</p>
 <div class="blockquote"><blockquote class="blockquote"><p><span class="emphasis"><em><span class="bold"><b>Now that we can embed the interpreter in our programs, lets see how to put it to use...</b></span></em></span></p></blockquote></div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.using_the_interpreter"></a>Using the interpreter</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.using_the_interpreter"></a>Using the interpreter</h3></div></div></div>
 <p>
 As you probably already know, objects in Python are reference-counted.
 Naturally, the <tt class="literal">PyObject</tt>s of the Python/C API are also reference-counted.
@@ -115,10 +107,10 @@ There is a difference however. While the reference-counting is fully
 automatic in Python, the Python/C API requires you to do it
 <a href="http://www.python.org/doc/current/api/refcounts.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 <a href="../../v2/handle.html" target="_top">handle</a> and
+Fortunately Boost.Python provides the <a href="../../../../v2/handle.html" target="_top">handle</a> and
 <a href="../../../../v2/object.html" target="_top">object</a> class templates to automate the process.</p>
 <a name="using_the_interpreter.reference_counting_handles_and_objects"></a><h2>
-<a name="id428977"></a>Reference-counting handles and objects</h2>
+<a name="id456409"></a>Reference-counting handles and objects</h2>
 <p>
 There are two ways in which a function in the Python/C API can return a
 <tt class="literal">PyObject*</tt>: as a <span class="emphasis"><em>borrowed reference</em></span> or as a <span class="emphasis"><em>new reference</em></span>. Which of
@@ -144,14 +136,12 @@ such function that returns a new reference is <a href="http://www.python.org/doc
 discuss in the next section.</p>
 <div class="informaltable"><table class="table">
 <colgroup><col></colgroup>
-<tbody><tr><td>
-<span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>Handle is a class <span class="emphasis"><em>template</em></span>, so why haven't we been using any template parameters?</b></span><p></p>
-<p></p>
-<tt class="literal">handle</tt> has a single template parameter specifying the type of the managed object. This type is <tt class="literal">PyObject</tt> 99% of the time, so the parameter was defaulted to <tt class="literal">PyObject</tt> for convenience. Therefore we can use the shorthand <tt class="literal">handle&lt;&gt;</tt> instead of the longer, but equivalent, <tt class="literal">handle&lt;PyObject&gt;</tt>.
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>Handle is a class <span class="emphasis"><em>template</em></span>, so why haven't we been using any template parameters?</b></span><br><br><tt class="literal">handle</tt> has a single template parameter specifying the type of the managed object. This type is <tt class="literal">PyObject</tt> 99% of the time, so the parameter was defaulted to <tt class="literal">PyObject</tt> for convenience. Therefore we can use the shorthand <tt class="literal">handle&lt;&gt;</tt> instead of the longer, but equivalent, <tt class="literal">handle&lt;PyObject&gt;</tt>.
 </td></tr></tbody>
 </table></div>
 <a name="using_the_interpreter.running_python_code"></a><h2>
-<a name="id429281"></a>Running Python code</h2>
+<a name="id456714"></a>Running Python code</h2>
 <p>
 To run Python code from C++ there is a family of functions in the API
 starting with the PyRun prefix. You can find the full list of these
@@ -166,7 +156,7 @@ The <tt class="literal">start</tt> parameter is the start symbol from the Python
 for interpreting the code. The possible values are:</p>
 <div class="informaltable">
 <h4>
-<a name="id429442"></a><span class="table-title">Start symbols</span>
+<a name="id456876"></a><span class="table-title">Start symbols</span>
 </h4>
 <table class="table">
 <colgroup>
@@ -224,12 +214,17 @@ the object's <tt class="literal">ptr</tt> member function to retrieve the <tt cl
 <p>
 This should create a file called 'hello.txt' in the current directory
 containing a phrase that is well-known in programming circles.</p>
-<p><span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>Note</b></span> that we wrap the return value of <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a> in a
-(nameless) <tt class="literal">handle</tt> even though we are not interested in it. If we didn't
-do this, the the returned object would be kept alive unnecessarily. Unless
-you want to be a Dr. Frankenstein, always wrap <tt class="literal">PyObject*</tt>s in <tt class="literal">handle</tt>s.</p>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>Note</b></span> that we wrap the return value of <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a> in a
+    (nameless) <tt class="literal">handle</tt> even though we are not interested in it. If we didn't
+    do this, the the returned object would be kept alive unnecessarily. Unless
+    you want to be a Dr. Frankenstein, always wrap <tt class="literal">PyObject*</tt>s in <tt class="literal">handle</tt>s.
+</td></tr></tbody>
+</table></div>
 <a name="using_the_interpreter.beyond_handles"></a><h2>
-<a name="id429881"></a>Beyond handles</h2>
+<a name="id457324"></a>Beyond handles</h2>
 <p>
 It's nice that <tt class="literal">handle</tt> manages the reference counting details for us, but
 other than that it doesn't do much. Often we'd like to have a more useful
@@ -266,17 +261,22 @@ the dictionary. Another way to achieve the same result is to let
 ));</span><span class="keyword">
 
 int</span><span class="identifier"> five_squared</span><span class="special"> =</span><span class="identifier"> extract</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">result</span><span class="special">);</span></tt></pre>
-<p><span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>Note</b></span> that <tt class="literal">object</tt>'s member function to return the wrapped
-<tt class="literal">PyObject*</tt> is called <tt class="literal">ptr</tt> instead of <tt class="literal">get</tt>. This makes sense if you
-take into account the different functions that <tt class="literal">object</tt> and <tt class="literal">handle</tt>
-perform.</p>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>Note</b></span> that <tt class="literal">object</tt>'s member function to return the wrapped
+    <tt class="literal">PyObject*</tt> is called <tt class="literal">ptr</tt> instead of <tt class="literal">get</tt>. This makes sense if you
+    take into account the different functions that <tt class="literal">object</tt> and <tt class="literal">handle</tt>
+    perform.
+</td></tr></tbody>
+</table></div>
 <a name="using_the_interpreter.exception_handling"></a><h2>
-<a name="id430451"></a>Exception handling</h2>
+<a name="id457906"></a>Exception handling</h2>
 <p>
-If an exception occurs in the execution of some Python code, the <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a> 
-function returns a null pointer. Constructing a <tt class="literal">handle</tt> out of this null 
-pointer throws <a href="../../../../v2/errors.html#error_already_set-spec" target="_top">error_already_set</a>, 
-so basically, the Python exception is automatically translated into a 
+If an exception occurs in the execution of some Python code, the <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a>
+function returns a null pointer. Constructing a <tt class="literal">handle</tt> out of this null
+pointer throws <a href="../../../../v2/errors.html#error_already_set-spec" target="_top">error_already_set</a>,
+so basically, the Python exception is automatically translated into a
 C++ exception when using <tt class="literal">handle</tt>:</p>
 <pre class="programlisting"><tt class="literal"><span class="keyword">try</span><span class="special">
 {</span><span class="identifier">
@@ -295,14 +295,13 @@ catch</span><span class="special">(</span><span class="identifier">error_already
     // handle the exception in some way
 </span><span class="special">}</span></tt></pre>
 <p>
-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 Python/C API in your catch-statement. This can be as simple as calling 
-<a href="http://www.python.org/doc/api/exceptionHandling.html#l2h-70" target="_top">PyErr_Print()</a> 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>:</p>
+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 Python/C API in your catch-statement. This can be as simple as calling
+<a href="http://www.python.org/doc/api/exceptionHandling.html#l2h-70" target="_top">PyErr_Print()</a> 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>:</p>
 <pre class="programlisting"><tt class="literal"><span class="keyword">catch</span><span class="special">(</span><span class="identifier">error_already_set</span><span class="special">)</span><span class="special">
 {</span><span class="keyword">
     if</span><span class="special"> (</span><span class="identifier">PyErr_ExceptionMatches</span><span class="special">(</span><span class="identifier">PyExc_ZeroDivisionError</span><span class="special">))</span><span class="special">
@@ -316,11 +315,11 @@ standard exceptions</a>:</p>
     }</span><span class="special">
 }</span></tt></pre>
 <p>
-(To retrieve even more information from the exception you can use some of the other 
+(To retrieve even more information from the exception you can use some of the other
 exception handling functions listed <a href="http://www.python.org/doc/api/exceptionHandling.html" target="_top">here</a>.)</p>
 <p>
-If you'd rather not have <tt class="literal">handle</tt> throw a C++ exception when it is constructed, you 
-can use the <a href="../../v2/handle.html#allow_null-spec" target="_top">allow_null</a> function in the same 
+If you'd rather not have <tt class="literal">handle</tt> throw a C++ exception when it is constructed, you
+can use the <a href="../../../../v2/handle.html#allow_null-spec" target="_top">allow_null</a> function in the same
 way you'd use borrowed:</p>
 <pre class="programlisting"><tt class="literal"><span class="identifier">handle</span><span class="special">&lt;&gt;</span><span class="identifier"> result</span><span class="special">((</span><span class="identifier">allow_null</span><span class="special">(</span><a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a><span class="special">(</span><span class="string">
     "5/0"</span><span class="special">
@@ -337,7 +336,7 @@ if</span><span class="special"> (!</span><span class="identifier">result</span><
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2004 Joel de Guzman, David Abrahams</small></td>
+<td align="right"><small>Copyright © 2002-2005 Joel de Guzman, David Abrahams</small></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">

doc/tutorial/doc/html/python/exception.html

@@ -3,31 +3,28 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title> Exception Translation</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
-<link rel="home" href="../index.html" title="Chapter 1. python 1.0">
+<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="previous" href="iterators.html" title="Iterators">
+<link rel="prev" href="iterators.html" title="Iterators">
 <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%">
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../boost.png"></td>
-<td align="center"><a href="../../../index.htm">Home</a></td>
-<td align="center"><a href="../libraries.html">Libraries</a></td>
-<td align="center"><a href="../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../more/faq.htm">FAQ</a></td>
-<td align="center"><a href="../../../more/index.htm">More</a></td>
+<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="iterators.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="techniques.html"><img src="../images/next.png" alt="Next"></a>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h2 class="title" style="clear: both">
-<a name="python.exception"></a> Exception Translation</h2></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="python.exception"></a> Exception Translation</h2></div></div></div>
 <p>
 All C++ exceptions must be caught at the boundary with Python code. This
 boundary is the point where C++ meets Python. Boost.Python provides a
@@ -47,7 +44,7 @@ BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier"
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2004 Joel de Guzman, David Abrahams</small></td>
+<td align="right"><small>Copyright © 2002-2005 Joel de Guzman, David Abrahams</small></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">

doc/tutorial/doc/html/python/exposing.html

@@ -3,38 +3,34 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title> Exposing Classes</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
-<link rel="home" href="../index.html" title="Chapter 1. python 1.0">
+<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="previous" 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%">
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../boost.png"></td>
-<td align="center"><a href="../../../index.htm">Home</a></td>
-<td align="center"><a href="../libraries.html">Libraries</a></td>
-<td align="center"><a href="../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../more/faq.htm">FAQ</a></td>
-<td align="center"><a href="../../../more/index.htm">More</a></td>
+<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="hello.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../images/next.png" alt="Next"></a>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h2 class="title" style="clear: both">
-<a name="python.exposing"></a> Exposing Classes</h2></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="python.exposing"></a> Exposing Classes</h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="exposing.html#python.constructors">Constructors</a></span></dt>
 <dt><span class="section"><a href="exposing.html#python.class_data_members">Class Data Members</a></span></dt>
 <dt><span class="section"><a href="exposing.html#python.class_properties">Class Properties</a></span></dt>
 <dt><span class="section"><a href="exposing.html#python.inheritance">Inheritance</a></span></dt>
 <dt><span class="section"><a href="exposing.html#python.class_virtual_functions">Class Virtual Functions</a></span></dt>
-<dt><span class="section"><a href="exposing.html#python.deriving_a_python_class">Deriving a Python Class</a></span></dt>
 <dt><span class="section"><a href="exposing.html#python.virtual_functions_with_default_implementations">Virtual Functions with Default Implementations</a></span></dt>
 <dt><span class="section"><a href="exposing.html#python.class_operators_special_functions">Class Operators/Special Functions</a></span></dt>
 </dl></div>
@@ -65,17 +61,15 @@ BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier"
 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:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> import</span><span class="identifier"> hello</span><span class="special">
+<p></p>
+<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="keyword"> import</span><span class="identifier"> hello</span><span class="special">
 &gt;&gt;&gt;</span><span class="identifier"> planet</span><span class="special"> =</span><span class="identifier"> hello</span><span class="special">.</span><span class="identifier">World</span><span class="special">()</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> planet</span><span class="special">.</span><span class="identifier">set</span><span class="special">(</span><span class="char">'howdy'</span><span class="special">)</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> planet</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span><span class="char">
+&gt;&gt;&gt;</span><span class="identifier"> planet</span><span class="special">.</span><span class="identifier">set</span><span class="special">(</span><span class="string">'howdy'</span><span class="special">)</span><span class="special">
+&gt;&gt;&gt;</span><span class="identifier"> planet</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span><span class="string">
 'howdy'</span></tt></pre>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.constructors"></a>Constructors</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.constructors"></a>Constructors</h3></div></div></div>
 <p>
 Our previous example didn't have any explicit constructors.
 Since <tt class="literal">World</tt> is declared as a plain struct, it has an implicit default
@@ -85,6 +79,7 @@ which is why we were able to write</p>
 <p>
 We may wish to wrap a class with a non-default constructor. Let us
 build on our previous example:</p>
+<p></p>
 <pre class="programlisting"><tt class="literal"><span class="keyword">struct</span><span class="identifier"> World</span><span class="special">
 {</span><span class="identifier">
     World</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="identifier"> msg</span><span class="special">):</span><span class="identifier"> msg</span><span class="special">(</span><span class="identifier">msg</span><span class="special">)</span><span class="special"> {}</span><span class="comment"> // added constructor
@@ -128,11 +123,8 @@ This actually adds an <tt class="literal"><span class="underline">_init</span>_<
 Python RuntimeError exception.</p>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.class_data_members"></a>Class Data Members</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.class_data_members"></a>Class Data Members</h3></div></div></div>
 <p>
 Data members may also be exposed to Python so that they can be
 accessed as attributes of the corresponding Python class. Each data
@@ -152,31 +144,29 @@ Our C++ <tt class="literal">Var</tt> class and its data members can be exposed t
 <p>
 Then, in Python, assuming we have placed our Var class inside the namespace
 hello as we did before:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> x</span><span class="special"> =</span><span class="identifier"> hello</span><span class="special">.</span><span class="identifier">Var</span><span class="special">(</span><span class="char">'pi'</span><span class="special">)</span><span class="special">
+<p></p>
+<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> x</span><span class="special"> =</span><span class="identifier"> hello</span><span class="special">.</span><span class="identifier">Var</span><span class="special">(</span><span class="string">'pi'</span><span class="special">)</span><span class="special">
 &gt;&gt;&gt;</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">value</span><span class="special"> =</span><span class="number"> 3.14</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> print</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">name</span><span class="special">,</span><span class="char"> 'is around'</span><span class="special">,</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">value</span><span class="identifier">
-pi</span><span class="identifier"> is</span><span class="identifier"> around</span><span class="number"> 3.14</span></tt></pre>
+&gt;&gt;&gt;</span><span class="keyword"> print</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">name</span><span class="special">,</span><span class="string"> 'is around'</span><span class="special">,</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">value</span><span class="identifier">
+pi</span><span class="keyword"> is</span><span class="identifier"> around</span><span class="number"> 3.14</span></tt></pre>
 <p>
 Note that <tt class="literal">name</tt> is exposed as <span class="bold"><b>read-only</b></span> while <tt class="literal">value</tt> is exposed
 as <span class="bold"><b>read-write</b></span>.</p>
-<pre class="programlisting"><tt class="literal">    &gt;&gt;&gt; x.name = 'e' # can't change name
-    Traceback (most recent call last):
-      File "&lt;stdin&gt;", line 1, in ?
-    AttributeError: can't set attribute
-</tt></pre>
+<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">name</span><span class="special"> =</span><span class="string"> 'e'</span><span class="comment"> # can't change name
+</span><span class="identifier">Traceback</span><span class="special"> (</span><span class="identifier">most</span><span class="identifier"> recent</span><span class="identifier"> call</span><span class="identifier"> last</span><span class="special">):</span><span class="identifier">
+  File</span><span class="string"> "&lt;stdin&gt;"</span><span class="special">,</span><span class="identifier"> line</span><span class="number"> 1</span><span class="special">,</span><span class="keyword"> in</span>#<span class="identifier">
+AttributeError</span><span class="special">:</span><span class="identifier"> can</span>#<span class="identifier">t</span><span class="identifier"> set</span><span class="identifier"> attribute</span></tt></pre>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.class_properties"></a>Class Properties</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.class_properties"></a>Class Properties</h3></div></div></div>
 <p>
 In C++, classes with public data members are usually frowned
 upon. Well designed classes that take advantage of encapsulation hide
 the class' data members. The only way to access the class' data is
 through access (getter/setter) functions. Access functions expose class
 properties. Here's an example:</p>
+<p></p>
 <pre class="programlisting"><tt class="literal"><span class="keyword">struct</span><span class="identifier"> Num</span><span class="special">
 {</span><span class="identifier">
     Num</span><span class="special">();</span><span class="keyword">
@@ -194,22 +184,22 @@ attributes can just be a different syntax for a method call. Wrapping our
     .</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"value"</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">set</span><span class="special">);</span></tt></pre>
 <p>
 And at last, in Python:</p>
+<p></p>
 <pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> x</span><span class="special"> =</span><span class="identifier"> Num</span><span class="special">()</span><span class="special">
 &gt;&gt;&gt;</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">value</span><span class="special"> =</span><span class="number"> 3.14</span><span class="special">
 &gt;&gt;&gt;</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">value</span><span class="special">,</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">rovalue</span><span class="special">
 (</span><span class="number">3.14</span><span class="special">,</span><span class="number"> 3.14</span><span class="special">)</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">rovalue</span><span class="special"> =</span><span class="number"> 2.17</span> #<span class="identifier"> error</span><span class="special">!</span></tt></pre>
+&gt;&gt;&gt;</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">rovalue</span><span class="special"> =</span><span class="number"> 2.17</span><span class="comment"> # error!
+</span></tt></pre>
 <p>
 Take note that the class property <tt class="literal">rovalue</tt> is exposed as <span class="bold"><b>read-only</b></span>
 since the <tt class="literal">rovalue</tt> setter member function is not passed in:</p>
+<p></p>
 <pre class="programlisting"><tt class="literal"><span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"rovalue"</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">)</span></tt></pre>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.inheritance"></a>Inheritance</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.inheritance"></a>Inheritance</h3></div></div></div>
 <p>
 In the previous examples, we dealt with classes that are not polymorphic.
 This is not often the case. Much of the time, we will be wrapping
@@ -241,10 +231,13 @@ Now we can inform Boost.Python of the inheritance relationship between
 Doing so, we get some things for free:</p>
 <div class="orderedlist"><ol type="1">
 <li>
-Derived automatically inherits all of Base's Python methods (wrapped C++ member functions)
+Derived automatically inherits all of Base's Python methods
+  (wrapped C++ member functions)
 </li>
 <li>
-<span class="bold"><b>If</b></span> Base is polymorphic, <tt class="literal">Derived</tt> objects which have been passed to Python via a pointer or reference to <tt class="literal">Base</tt> can be passed where a pointer or reference to <tt class="literal">Derived</tt> is expected.
+<span class="bold"><b>If</b></span> Base is polymorphic, <tt class="literal">Derived</tt> objects which have been passed to
+  Python via a pointer or reference to <tt class="literal">Base</tt> can be passed where a pointer
+  or reference to <tt class="literal">Derived</tt> is expected.
 </li>
 </ol></div>
 <p>
@@ -258,183 +251,83 @@ instances of class <tt class="literal">Derived</tt>. In such cases, we use
 <tt class="literal">return_value_policy&lt;manage_new_object&gt;</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 shall see more of
-Boost.Python <a href="functions.html#python.call_policies" target="_top">call policies</a> later.</p>
+Boost.Python <a href="functions.html#python.call_policies" title="Call Policies">call policies</a> later.</p>
 <pre class="programlisting"><tt class="literal"><span class="comment">// Tell Python to take ownership of factory's result
 </span><span class="identifier">def</span><span class="special">(</span><span class="string">"factory"</span><span class="special">,</span><span class="identifier"> factory</span><span class="special">,</span><span class="identifier">
     return_value_policy</span><span class="special">&lt;</span><span class="identifier">manage_new_object</span><span class="special">&gt;());</span></tt></pre>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.class_virtual_functions"></a>Class Virtual Functions</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.class_virtual_functions"></a>Class Virtual Functions</h3></div></div></div>
 <p>
-In this section, we shall learn how to make functions behave
-polymorphically through virtual functions. Continuing our example, let us
-add a virtual function to our <tt class="literal">Base</tt> class:</p>
+In this section, we shall learn how to make functions behave polymorphically
+through virtual functions. Continuing our example, let us add a virtual function
+to our <tt class="literal">Base</tt> class:</p>
 <pre class="programlisting"><tt class="literal"><span class="keyword">struct</span><span class="identifier"> Base</span><span class="special">
 {</span><span class="keyword">
+    virtual</span><span class="special"> ~</span><span class="identifier">Base</span><span class="special">()</span><span class="special"> {}</span><span class="keyword">
     virtual</span><span class="keyword"> int</span><span class="identifier"> f</span><span class="special">()</span><span class="special"> =</span><span class="number"> 0</span><span class="special">;</span><span class="special">
 };</span></tt></pre>
 <p>
-Since <tt class="literal">f</tt> is a pure virtual function, <tt class="literal">Base</tt> is now an abstract
-class. Given an instance of our class, the free function <tt class="literal">call_f</tt>
-calls some implementation of this virtual function in a concrete
-derived class:</p>
-<pre class="programlisting"><tt class="literal"><span class="keyword">int</span><span class="identifier"> call_f</span><span class="special">(</span><span class="identifier">Base</span><span class="special">&amp;</span><span class="identifier"> b</span><span class="special">)</span><span class="special"> {</span><span class="keyword"> return</span><span class="identifier"> b</span><span class="special">.</span><span class="identifier">f</span><span class="special">();</span><span class="special"> }</span></tt></pre>
-<p>
-To allow this function to be implemented in a Python derived class, we
-need to create a class wrapper:</p>
-<pre class="programlisting"><tt class="literal"><span class="keyword">struct</span><span class="identifier"> BaseWrap</span><span class="special"> :</span><span class="identifier"> Base</span><span class="special">
-{</span><span class="identifier">
-    BaseWrap</span><span class="special">(</span><span class="identifier">PyObject</span><span class="special">*</span><span class="identifier"> self_</span><span class="special">)</span><span class="special">
-        :</span><span class="identifier"> self</span><span class="special">(</span><span class="identifier">self_</span><span class="special">)</span><span class="special"> {}</span><span class="keyword">
-    int</span><span class="identifier"> f</span><span class="special">()</span><span class="special"> {</span><span class="keyword"> return</span><span class="identifier"> call_method</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">self</span><span class="special">,</span><span class="string"> "f"</span><span class="special">);</span><span class="special"> }</span><span class="identifier">
-    PyObject</span><span class="special">*</span><span class="identifier"> self</span><span class="special">;</span><span class="special">
-};</span><span class="keyword">
-
-
-struct</span><span class="identifier"> BaseWrap</span><span class="special"> :</span><span class="identifier"> Base</span><span class="special">
-{</span><span class="identifier">
-    BaseWrap</span><span class="special">(</span><span class="identifier">PyObject</span><span class="special">*</span><span class="identifier"> self_</span><span class="special">)</span><span class="special">
-        :</span><span class="identifier"> self</span><span class="special">(</span><span class="identifier">self_</span><span class="special">)</span><span class="special"> {}</span><span class="identifier">
-    BaseWrap</span><span class="special">(</span><span class="identifier">PyObject</span><span class="special">*</span><span class="identifier"> self_</span><span class="special">,</span><span class="identifier"> Base</span><span class="keyword"> const</span><span class="special">&amp;</span><span class="identifier"> copy</span><span class="special">)</span><span class="special">
-        :</span><span class="identifier"> Base</span><span class="special">(</span><span class="identifier">copy</span><span class="special">),</span><span class="identifier"> self</span><span class="special">(</span><span class="identifier">self_</span><span class="special">)</span><span class="special"> {}</span><span class="keyword">
-    int</span><span class="identifier"> f</span><span class="special">()</span><span class="special"> {</span><span class="keyword"> return</span><span class="identifier"> call_method</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">self</span><span class="special">,</span><span class="string"> "f"</span><span class="special">);</span><span class="special"> }</span><span class="keyword">
-    int</span><span class="identifier"> default_f</span><span class="special">()</span><span class="special"> {</span><span class="keyword"> return</span><span class="identifier"> Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">();</span><span class="special"> }</span><span class="comment"> // &lt;&lt;=== ***ADDED***
-</span><span class="identifier">    PyObject</span><span class="special">*</span><span class="identifier"> self</span><span class="special">;</span><span class="special">
+One of the goals of Boost.Python is to be minimally intrusive on an existing C++ 
+design. In principle, it should be possible to expose the interface for a 3rd 
+party library without changing it. It is not ideal to add anything to our class 
+<tt class="computeroutput"><span class="identifier">Base</span></tt>. Yet, when you have a virtual function that's going to be overridden in 
+Python and called polymorphically <span class="bold"><b>from C++</b></span>, we'll need to add some 
+scaffoldings to make things work properly. What we'll do is write a class 
+wrapper that derives from <tt class="computeroutput"><span class="identifier">Base</span></tt> that will unintrusively hook into the virtual 
+functions so that a Python override may be called:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">struct</span><span class="identifier"> BaseWrap</span><span class="special"> :</span><span class="identifier"> Base</span><span class="special">,</span><span class="identifier"> wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span><span class="special">
+{</span><span class="keyword">
+    int</span><span class="identifier"> f</span><span class="special">()</span><span class="special">
+    {</span><span class="keyword">
+        return</span><span class="keyword"> this</span><span class="special">-&gt;</span><span class="identifier">get_override</span><span class="special">(</span><span class="string">"f"</span><span class="special">)();</span><span class="special">
+    }</span><span class="special">
 };</span></tt></pre>
+<p>
+Notice too that in addition to inheriting from <tt class="computeroutput"><span class="identifier">Base</span></tt>, we also multiply-
+inherited <tt class="computeroutput"><span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span></tt> (See <a href="../../../../v2/wrapper.html" target="_top">Wrapper</a>). The
+<tt class="computeroutput"><span class="identifier">wrapper</span></tt> template makes the job of wrapping classes that are meant to
+overridden in Python, easier.</p>
 <div class="informaltable"><table class="table">
 <colgroup><col></colgroup>
-<tbody><tr><td>
-<span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>member function and methods</b></span><p></p>
-<p></p>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/alert.png"></span><span class="bold"><b>MSVC6/7 Workaround</b></span><br><br>
+ 
+If you are using Microsoft Visual C++ 6 or 7, you have to write <tt class="computeroutput"><span class="identifier">f</span></tt> as:<br><br><tt class="computeroutput"><span class="keyword">return</span><span class="identifier"> call</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get_override</span><span class="special">(</span><span class="string">"f"</span><span class="special">).</span><span class="identifier">ptr</span><span class="special">());</span></tt>.</td></tr></tbody>
+</table></div>
+<p>
+BaseWrap's overridden virtual member function <tt class="computeroutput"><span class="identifier">f</span></tt> in effect calls the
+corresponding method of the Python object through <tt class="computeroutput"><span class="identifier">get_override</span></tt>.</p>
+<p>
+Finally, exposing <tt class="computeroutput"><span class="identifier">Base</span></tt>:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span><span class="identifier"> boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span><span class="special">
+    .</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span><span class="identifier"> pure_virtual</span><span class="special">(&amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">))</span><span class="special">
+    ;</span></tt></pre>
+<p><tt class="computeroutput"><span class="identifier">pure_virtual</span></tt> signals Boost.Python that the function <tt class="computeroutput"><span class="identifier">f</span></tt> is a pure virtual 
+function.</p>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>member function and methods</b></span><br><br>
  Python, like
 many object oriented languages uses the term <span class="bold"><b>methods</b></span>.  Methods
 correspond roughly to C++'s <span class="bold"><b>member functions</b></span>
 </td></tr></tbody>
 </table></div>
-<p>
-Our class wrapper <tt class="literal">BaseWrap</tt> is derived from <tt class="literal">Base</tt>. Its overridden
-virtual member function <tt class="literal">f</tt> in effect calls the corresponding method
-of the Python object <tt class="literal">self</tt>, which is a pointer back to the Python
-<tt class="literal">Base</tt> object holding our <tt class="literal">BaseWrap</tt> instance.</p>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td>
-<span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>Why do we need BaseWrap?</b></span><p></p>
-<p></p>
-</td></tr></tbody>
-</table></div>
-<p><span class="emphasis"><em>You may ask</em></span>, "Why do we need the <tt class="literal">BaseWrap</tt> derived class? This could
-have been designed so that everything gets done right inside of
-Base."</p>
-<p></p>
-<p></p>
-<p>
-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. To unintrusively
-hook into the virtual functions so that a Python override may be called, we
-must use a derived class.</p>
-<p></p>
-<p></p>
-<p>
-Note however that you don't need to do this to get methods overridden
-in Python to behave virtually when called <span class="emphasis"><em>from</em></span><span class="bold"><b>Python</b></span>. The only
-time you need to do the <tt class="literal">BaseWrap</tt> dance is when you have a virtual
-function that's going to be overridden in Python and called
-polymorphically <span class="emphasis"><em>from</em></span><span class="bold"><b>C++</b></span>.]</p>
-<p>
-Wrapping <tt class="literal">Base</tt> and the free function <tt class="literal">call_f</tt>:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span><span class="identifier"> BaseWrap</span><span class="special">,</span><span class="identifier"> boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">,</span><span class="identifier"> no_init</span><span class="special">)</span><span class="special">
-    ;</span><span class="identifier">
-def</span><span class="special">(</span><span class="string">"call_f"</span><span class="special">,</span><span class="identifier"> call_f</span><span class="special">);</span></tt></pre>
-<p>
-Notice that we parameterized the <tt class="literal">class_</tt> template with <tt class="literal">BaseWrap</tt> as the
-second parameter. What is <tt class="literal">noncopyable</tt>? Without it, the library will try
-to create code for converting Base return values of wrapped functions to
-Python. To do that, it needs Base's copy constructor... which isn't
-available, since Base is an abstract class.</p>
-<p>
-In Python, let us try to instantiate our <tt class="literal">Base</tt> class:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> base</span><span class="special"> =</span><span class="identifier"> Base</span><span class="special">()</span><span class="identifier">
-RuntimeError</span><span class="special">:</span><span class="identifier"> This</span><span class="keyword"> class</span><span class="identifier"> cannot</span><span class="identifier"> be</span><span class="identifier"> instantiated</span><span class="identifier"> from</span><span class="identifier"> Python</span></tt></pre>
-<p>
-Why is it an error? <tt class="literal">Base</tt> is an abstract class. As such it is advisable
-to define the Python wrapper with <tt class="literal">no_init</tt> as we have done above. Doing
-so will disallow abstract base classes such as <tt class="literal">Base</tt> to be instantiated.</p>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.deriving_a_python_class"></a>Deriving a Python Class</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.virtual_functions_with_default_implementations"></a>Virtual Functions with Default Implementations</h3></div></div></div>
 <p>
-Continuing, we can derive from our base class Base in Python and override
-the virtual function in Python. Before we can do that, we have to set up
-our <tt class="literal">class_</tt> wrapper as:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span><span class="identifier"> BaseWrap</span><span class="special">,</span><span class="identifier"> boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span><span class="special">
-    ;</span></tt></pre>
+We've seen in the previous section how classes with pure virtual functions are 
+wrapped using Boost.Python's <a href="../../../../v2/wrapper.html" target="_top">class wrapper</a>
+facilities. If we wish to wrap <span class="bold"><b>non</b></span>-pure-virtual functions instead, the 
+mechanism is a bit different.</p>
 <p>
-Otherwise, we have to suppress the Base class' <tt class="literal">no_init</tt> by adding an
-<tt class="literal"><span class="underline">_init</span>_()</tt> method to all our derived classes. <tt class="literal">no_init</tt> actually adds
-an <tt class="literal"><span class="underline">_init</span>_</tt> method that raises a Python RuntimeError exception.</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="keyword"> class</span><span class="identifier"> Derived</span><span class="special">(</span><span class="identifier">Base</span><span class="special">):</span><span class="special">
-...</span><span class="identifier">     def</span><span class="identifier"> f</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span><span class="special">
-...</span><span class="keyword">         return</span><span class="number"> 42</span><span class="special">
-...</span></tt></pre>
-<p>
-Cool eh? A Python class deriving from a C++ class!</p>
-<p>
-Let's now make an instance of our Python class <tt class="literal">Derived</tt>:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> derived</span><span class="special"> =</span><span class="identifier"> Derived</span><span class="special">()</span></tt></pre>
-<p>
-Calling <tt class="literal">derived.f()</tt>:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> derived</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span><span class="number">
-42</span></tt></pre>
-<p>
-Will yield the expected result. Finally, calling calling the free function
-<tt class="literal">call_f</tt> with <tt class="literal">derived</tt> as argument:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> call_f</span><span class="special">(</span><span class="identifier">derived</span><span class="special">)</span><span class="number">
-42</span></tt></pre>
-<p>
-Will also yield the expected result.</p>
-<p>
-Here's what's happening:</p>
-<div class="orderedlist"><ol type="1">
-<li>
-<tt class="literal">call_f(derived)</tt> is called in Python
-</li>
-<li>
-This corresponds to <tt class="literal">def("call_f", call_f);</tt>. Boost.Python dispatches this call.
-</li>
-<li>
-<tt class="literal">int call_f(Base&amp; b) { return b.f(); }</tt> accepts the call.
-</li>
-<li>
-The overridden virtual function <tt class="literal">f</tt> of <tt class="literal">BaseWrap</tt> is called.
-</li>
-<li>
-<tt class="literal">call_method&lt;int&gt;(self, "f");</tt> dispatches the call back to Python.
-</li>
-<li>
-<tt class="literal">def f(self): return 42</tt> is finally called.
-</li>
-</ol></div>
-</div>
-<div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.virtual_functions_with_default_implementations"></a>Virtual Functions with Default Implementations</h3></div></div>
-<div></div>
-</div>
-<p>
-Recall that in the <a href="exposing.html#class_virtual_functions" target="_top">previous section</a>, we
-wrapped a class with a pure virtual function that we then implemented in
-C++ or Python classes derived from it. Our base class:</p>
+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:</p>
 <pre class="programlisting"><tt class="literal"><span class="keyword">struct</span><span class="identifier"> Base</span><span class="special">
 {</span><span class="keyword">
     virtual</span><span class="keyword"> int</span><span class="identifier"> f</span><span class="special">()</span><span class="special"> =</span><span class="number"> 0</span><span class="special">;</span><span class="special">
@@ -444,36 +337,49 @@ had a pure virtual function <tt class="literal">f</tt>. If, however, its member
 not declared as pure virtual:</p>
 <pre class="programlisting"><tt class="literal"><span class="keyword">struct</span><span class="identifier"> Base</span><span class="special">
 {</span><span class="keyword">
+    virtual</span><span class="special"> ~</span><span class="identifier">Base</span><span class="special">()</span><span class="special"> {}</span><span class="keyword">
     virtual</span><span class="keyword"> int</span><span class="identifier"> f</span><span class="special">()</span><span class="special"> {</span><span class="keyword"> return</span><span class="number"> 0</span><span class="special">;</span><span class="special"> }</span><span class="special">
 };</span></tt></pre>
 <p>
-and instead had a default implementation that returns <tt class="literal">0</tt>, as shown above,
-we need to add a forwarding function that calls the <tt class="literal">Base</tt> default virtual
-function <tt class="literal">f</tt> implementation:</p>
-<pre class="programlisting"><tt class="literal"><span class="keyword">struct</span><span class="identifier"> BaseWrap</span><span class="special"> :</span><span class="identifier"> Base</span><span class="special">
-{</span><span class="identifier">
-    BaseWrap</span><span class="special">(</span><span class="identifier">PyObject</span><span class="special">*</span><span class="identifier"> self_</span><span class="special">)</span><span class="special">
-        :</span><span class="identifier"> self</span><span class="special">(</span><span class="identifier">self_</span><span class="special">)</span><span class="special"> {}</span><span class="keyword">
-    int</span><span class="identifier"> f</span><span class="special">()</span><span class="special"> {</span><span class="keyword"> return</span><span class="identifier"> call_method</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">self</span><span class="special">,</span><span class="string"> "f"</span><span class="special">);</span><span class="special"> }</span><span class="keyword">
-    int</span><span class="identifier"> default_f</span><span class="special">()</span><span class="special"> {</span><span class="keyword"> return</span><span class="identifier"> Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">();</span><span class="special"> }</span><span class="comment"> // &lt;&lt;=== ***ADDED***
-</span><span class="identifier">    PyObject</span><span class="special">*</span><span class="identifier"> self</span><span class="special">;</span><span class="special">
+We wrap it this way:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">struct</span><span class="identifier"> BaseWrap</span><span class="special"> :</span><span class="identifier"> Base</span><span class="special">,</span><span class="identifier"> wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span><span class="special">
+{</span><span class="keyword">
+    int</span><span class="identifier"> f</span><span class="special">()</span><span class="special">
+    {</span><span class="keyword">
+        if</span><span class="special"> (</span><span class="identifier">override</span><span class="identifier"> f</span><span class="special"> =</span><span class="keyword"> this</span><span class="special">-&gt;</span><span class="identifier">get_override</span><span class="special">(</span><span class="string">"f"</span><span class="special">))</span><span class="keyword">
+            return</span><span class="identifier"> f</span><span class="special">();</span><span class="comment"> // *note*
+</span><span class="keyword">        return</span><span class="identifier"> Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">();</span><span class="special">
+    }</span><span class="keyword">
+
+    int</span><span class="identifier"> default_f</span><span class="special">()</span><span class="special"> {</span><span class="keyword"> return</span><span class="keyword"> this</span><span class="special">-&gt;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">();</span><span class="special"> }</span><span class="special">
 };</span></tt></pre>
 <p>
-Then, 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. Here's how it is
-applied to our example above:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">,</span><span class="identifier"> BaseWrap</span><span class="special">,</span><span class="identifier"> BaseWrap</span><span class="special">,</span><span class="identifier"> boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span><span class="special">
-    .</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">default_f</span><span class="special">)</span></tt></pre>
+Notice how we implemented <tt class="computeroutput"><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">f</span></tt>. Now, we have to check if there is an 
+override for <tt class="computeroutput"><span class="identifier">f</span></tt>. If none, then we call <tt class="computeroutput"><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">()</span></tt>.</p>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/alert.png"></span><span class="bold"><b>MSVC6/7 Workaround</b></span><br><br>
+ 
+If you are using Microsoft Visual C++ 6 or 7, you have to rewrite the line
+with the <tt class="computeroutput"><span class="special">*</span><span class="identifier">note</span><span class="special">*</span></tt> as:<br><br><tt class="computeroutput"><span class="keyword">return</span><span class="identifier"> call</span><span class="special">&lt;</span><span class="keyword">char</span><span class="keyword"> const</span><span class="special">*&gt;(</span><span class="identifier">f</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">());</span></tt>.</td></tr></tbody>
+</table></div>
 <p>
-Note that we are allowing <tt class="literal">Base</tt> objects to be instantiated this time,
-unlike before where we specifically defined the <tt class="literal">class_&lt;Base&gt;</tt> with
-<tt class="literal">no_init</tt>.</p>
+Finally, exposing:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span><span class="identifier"> boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span><span class="special">
+    .</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">default_f</span><span class="special">)</span><span class="special">
+    ;</span></tt></pre>
+<p>
+Take note that we expose both <tt class="computeroutput"><span class="special">&amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span></tt> and <tt class="computeroutput"><span class="special">&amp;</span><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">default_f</span></tt>. 
+Boost.Python needs to keep track of 1) the dispatch function <tt class="literal">f</tt> and 2) the 
+forwarding function to its default implementation <tt class="literal">default_f</tt>. There's a 
+special <tt class="literal">def</tt> function for this purpose.</p>
 <p>
 In Python, the results would be as expected:</p>
+<p></p>
 <pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> base</span><span class="special"> =</span><span class="identifier"> Base</span><span class="special">()</span><span class="special">
 &gt;&gt;&gt;</span><span class="keyword"> class</span><span class="identifier"> Derived</span><span class="special">(</span><span class="identifier">Base</span><span class="special">):</span><span class="special">
-...</span><span class="identifier">     def</span><span class="identifier"> f</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span><span class="special">
+...</span><span class="keyword">     def</span><span class="identifier"> f</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span><span class="special">
 ...</span><span class="keyword">         return</span><span class="number"> 42</span><span class="special">
 ...</span><span class="special">
 &gt;&gt;&gt;</span><span class="identifier"> derived</span><span class="special"> =</span><span class="identifier"> Derived</span><span class="special">()</span></tt></pre>
@@ -485,23 +391,12 @@ Calling <tt class="literal">base.f()</tt>:</p>
 Calling <tt class="literal">derived.f()</tt>:</p>
 <pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> derived</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span><span class="number">
 42</span></tt></pre>
-<p>
-Calling <tt class="literal">call_f</tt>, passing in a <tt class="literal">base</tt> object:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> call_f</span><span class="special">(</span><span class="identifier">base</span><span class="special">)</span><span class="number">
-0</span></tt></pre>
-<p>
-Calling <tt class="literal">call_f</tt>, passing in a <tt class="literal">derived</tt> object:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> call_f</span><span class="special">(</span><span class="identifier">derived</span><span class="special">)</span><span class="number">
-42</span></tt></pre>
 </div>
 <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></div>
-</div>
+<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="id420103"></a>Python Operators</h2>
+<a name="id447543"></a>Python Operators</h2>
 <p>
 C is well known for the abundance of operators. C++ extends this to the
 extremes by allowing operator overloading. Boost.Python takes advantage of
@@ -509,6 +404,7 @@ this and makes it easy to wrap C++ operator-powered classes.</p>
 <p>
 Consider a file position class <tt class="literal">FilePos</tt> and a set of operators that take
 on FilePos instances:</p>
+<p></p>
 <pre class="programlisting"><tt class="literal"><span class="keyword">class</span><span class="identifier"> FilePos</span><span class="special"> {</span><span class="comment"> /*...*/</span><span class="special"> };</span><span class="identifier">
 
 FilePos</span><span class="keyword">     operator</span><span class="special">+(</span><span class="identifier">FilePos</span><span class="special">,</span><span class="keyword"> int</span><span class="special">);</span><span class="identifier">
@@ -538,20 +434,20 @@ you might need to interact with in an operator expression is (cheaply)
 default-constructible. You can use <tt class="literal">other&lt;T&gt;()</tt> in place of an actual
 <tt class="literal">T</tt> instance when writing "self expressions".</p>
 <a name="class_operators_special_functions.special_methods"></a><h2>
-<a name="id420789"></a>Special Methods</h2>
+<a name="id448230"></a>Special Methods</h2>
 <p>
 Python has a few more <span class="emphasis"><em>Special Methods</em></span>. Boost.Python supports all of the
 standard special method names supported by real Python class instances. A
 similar set of intuitive interfaces can also be used to wrap C++ functions
 that correspond to these Python <span class="emphasis"><em>special functions</em></span>. Example:</p>
 <pre class="programlisting"><tt class="literal"><span class="keyword">class</span><span class="identifier"> Rational</span><span class="special">
-{</span><span class="keyword"> operator</span><span class="keyword"> double</span><span class="special">()</span><span class="keyword"> const</span><span class="special">;</span><span class="special"> };</span><span class="identifier">
+{</span><span class="keyword"> public</span><span class="special">:</span><span class="keyword"> operator</span><span class="keyword"> double</span><span class="special">()</span><span class="keyword"> const</span><span class="special">;</span><span class="special"> };</span><span class="identifier">
 
 Rational</span><span class="identifier"> pow</span><span class="special">(</span><span class="identifier">Rational</span><span class="special">,</span><span class="identifier"> Rational</span><span class="special">);</span><span class="identifier">
 Rational</span><span class="identifier"> abs</span><span class="special">(</span><span class="identifier">Rational</span><span class="special">);</span><span class="identifier">
 ostream</span><span class="special">&amp;</span><span class="keyword"> operator</span><span class="special">&lt;&lt;(</span><span class="identifier">ostream</span><span class="special">&amp;,</span><span class="identifier">Rational</span><span class="special">);</span><span class="identifier">
 
-class_</span><span class="special">&lt;</span><span class="identifier">Rational</span><span class="special">&gt;()</span><span class="special">
+class_</span><span class="special">&lt;</span><span class="identifier">Rational</span><span class="special">&gt;(</span><span class="string">"Rational"</span><span class="special">)</span><span class="special">
     .</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">float_</span><span class="special">(</span><span class="identifier">self</span><span class="special">))</span><span class="comment">                  // __float__
 </span><span class="special">    .</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">pow</span><span class="special">(</span><span class="identifier">self</span><span class="special">,</span><span class="identifier"> other</span><span class="special">&lt;</span><span class="identifier">Rational</span><span class="special">&gt;))</span><span class="comment">    // __pow__
 </span><span class="special">    .</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">abs</span><span class="special">(</span><span class="identifier">self</span><span class="special">))</span><span class="comment">                     // __abs__
@@ -561,16 +457,16 @@ class_</span><span class="special">&lt;</span><span class="identifier">Rational<
 Need we say more?</p>
 <div class="informaltable"><table class="table">
 <colgroup><col></colgroup>
-<tbody><tr><td>
-<span class="inlinemediaobject"><img src="../images/note.png"></span> What is the business of <tt class="literal">operator&lt;&lt;</tt><tt class="literal">.def(str(self))</tt>?
-Well, the method <tt class="literal">str</tt> requires the <tt class="literal">operator&lt;&lt;</tt> to do its work (i.e.
-<tt class="literal">operator&lt;&lt;</tt> is used by the method defined by def(str(self)).</td></tr></tbody>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/note.png"></span> What is the business of <tt class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></tt>?
+Well, the method <tt class="computeroutput"><span class="identifier">str</span></tt> requires the <tt class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></tt> to do its work (i.e.
+<tt class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></tt> is used by the method defined by <tt class="computeroutput"><span class="identifier">def</span><span class="special">(</span><span class="identifier">str</span><span class="special">(</span><span class="identifier">self</span><span class="special">))</span></tt>.</td></tr></tbody>
 </table></div>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2004 Joel de Guzman, David Abrahams</small></td>
+<td align="right"><small>Copyright © 2002-2005 Joel de Guzman, David Abrahams</small></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">

doc/tutorial/doc/html/python/functions.html

@@ -3,31 +3,28 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Functions</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
-<link rel="home" href="../index.html" title="Chapter 1. python 1.0">
+<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="previous" href="exposing.html" title=" Exposing Classes">
+<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%">
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../boost.png"></td>
-<td align="center"><a href="../../../index.htm">Home</a></td>
-<td align="center"><a href="../libraries.html">Libraries</a></td>
-<td align="center"><a href="../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../more/faq.htm">FAQ</a></td>
-<td align="center"><a href="../../../more/index.htm">More</a></td>
+<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="exposing.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="object.html"><img src="../images/next.png" alt="Next"></a>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h2 class="title" style="clear: both">
-<a name="python.functions"></a>Functions</h2></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="python.functions"></a>Functions</h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="functions.html#python.call_policies">Call Policies</a></span></dt>
 <dt><span class="section"><a href="functions.html#python.overloading">Overloading</a></span></dt>
@@ -45,34 +42,31 @@ overloading and default arguments.</p>
 <p>
 But before you do, you might want to fire up Python 2.2 or later and type
 <tt class="literal">&gt;&gt;&gt; import this</tt>.</p>
-<pre class="programlisting"><tt class="literal">    &gt;&gt;&gt; import this
-    The Zen of Python, by Tim Peters
-    Beautiful is better than ugly.
-    Explicit is better than implicit.
-    Simple is better than complex.
-    Complex is better than complicated.
-    Flat is better than nested.
-    Sparse is better than dense.
-    Readability counts.
-    Special cases aren't special enough to break the rules.
-    Although practicality beats purity.
-    Errors should never pass silently.
-    Unless explicitly silenced.
-    In the face of ambiguity, refuse the temptation to guess.
-    There should be one-- and preferably only one --obvious way to do it
-    Although that way may not be obvious at first unless you're Dutch.
-    Now is better than never.
-    Although never is often better than <span class="bold"><b>right</b></span> now.
-    If the implementation is hard to explain, it's a bad idea.
-    If the implementation is easy to explain, it may be a good idea.
-    Namespaces are one honking great idea -- let's do more of those!
+<pre class="programlisting"><tt class="literal">&gt;&gt;&gt; import this
+The Zen of Python, by Tim Peters
+Beautiful is better than ugly.
+Explicit is better than implicit.
+Simple is better than complex.
+Complex is better than complicated.
+Flat is better than nested.
+Sparse is better than dense.
+Readability counts.
+Special cases aren't special enough to break the rules.
+Although practicality beats purity.
+Errors should never pass silently.
+Unless explicitly silenced.
+In the face of ambiguity, refuse the temptation to guess.
+There should be one-- and preferably only one --obvious way to do it
+Although that way may not be obvious at first unless you're Dutch.
+Now is better than never.
+Although never is often better than <span class="bold"><b>right</b></span> now.
+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!
 </tt></pre>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.call_policies"></a>Call Policies</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.call_policies"></a>Call Policies</h3></div></div></div>
 <p>
 In C++, we often deal with arguments and return types such as pointers
 and references. Such primitive types are rather, ummmm, low level and
@@ -127,15 +121,17 @@ A reference to <tt class="literal">y.x</tt> is returned
 </ol></div>
 <p>
 We could copy result into a new object:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span><span class="identifier"> z</span><span class="special">).</span><span class="identifier">set</span><span class="special">(</span><span class="number">42</span><span class="special">)</span> #<span class="identifier"> Result</span><span class="identifier"> disappears</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> y</span><span class="special">.</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span>       #<span class="identifier"> No</span><span class="identifier"> crash</span><span class="special">,</span><span class="identifier"> but</span><span class="identifier"> still</span><span class="identifier"> bad</span><span class="number">
-3.14</span></tt></pre>
+<p></p>
+<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span><span class="identifier"> z</span><span class="special">).</span><span class="identifier">set</span><span class="special">(</span><span class="number">42</span><span class="special">)</span><span class="comment"> # Result disappears
+</span><span class="special">&gt;&gt;&gt;</span><span class="identifier"> y</span><span class="special">.</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span><span class="comment">       # No crash, but still bad
+</span><span class="number">3.14</span></tt></pre>
 <p>
 This is not really our intent of our C++ interface. We've broken our
 promise that the Python interface should reflect the C++ interface as
 closely as possible.</p>
 <p>
 Our problems do not end there. Suppose Y is implemented as follows:</p>
+<p></p>
 <pre class="programlisting"><tt class="literal"><span class="keyword">struct</span><span class="identifier"> Y</span><span class="special">
 {</span><span class="identifier">
     X</span><span class="identifier"> x</span><span class="special">;</span><span class="identifier"> Z</span><span class="special">*</span><span class="identifier"> z</span><span class="special">;</span><span class="keyword">
@@ -178,7 +174,7 @@ A reference to <tt class="literal">y.x</tt> is returned
 <li><span class="bold"><b>BOOM!</b></span></li>
 </ol></div>
 <a name="call_policies.call_policies"></a><h2>
-<a name="id422411"></a>Call Policies</h2>
+<a name="id449896"></a>Call Policies</h2>
 <p>
 Call Policies may be used in situations such as the example detailed above.
 In our example, <tt class="literal">return_internal_reference</tt> and <tt class="literal">with_custodian_and_ward</tt>
@@ -210,54 +206,50 @@ Here is the list of predefined call policies. A complete reference detailing
 these can be found <a href="../../../../v2/reference.html#models_of_call_policies" target="_top">here</a>.</p>
 <div class="itemizedlist"><ul type="disc">
 <li>
-<span class="bold"><b>with_custodian_and_ward</b></span><p></p>
+<span class="bold"><b>with_custodian_and_ward</b></span><br>
  Ties lifetimes of the arguments
 </li>
 <li>
-<span class="bold"><b>with_custodian_and_ward_postcall</b></span><p></p>
+<span class="bold"><b>with_custodian_and_ward_postcall</b></span><br>
  Ties lifetimes of the arguments and results
 </li>
 <li>
-<span class="bold"><b>return_internal_reference</b></span><p></p>
+<span class="bold"><b>return_internal_reference</b></span><br>
  Ties lifetime of one argument to that of result
 </li>
 <li>
-<span class="bold"><b>return_value_policy&lt;T&gt; with T one of:</b></span><p></p>
+<span class="bold"><b>return_value_policy&lt;T&gt; with T one of:</b></span><br>
 </li>
 <li>
-<span class="bold"><b>reference_existing_object</b></span><p></p>
+<span class="bold"><b>reference_existing_object</b></span><br>
 naive (dangerous) approach
 </li>
 <li>
-<span class="bold"><b>copy_const_reference</b></span><p></p>
+<span class="bold"><b>copy_const_reference</b></span><br>
 Boost.Python v1 approach
 </li>
 <li>
-<span class="bold"><b>copy_non_const_reference</b></span><p></p>
+<span class="bold"><b>copy_non_const_reference</b></span><br>
 </li>
 <li>
-<span class="bold"><b>manage_new_object</b></span><p></p>
+<span class="bold"><b>manage_new_object</b></span><br>
  Adopt a pointer and hold the instance
 </li>
 </ul></div>
 <div class="informaltable"><table class="table">
 <colgroup><col></colgroup>
-<tbody><tr><td>
-<span class="inlinemediaobject"><img src="../images/smiley.png"></span><span class="bold"><b>Remember the Zen, Luke:</b></span><p></p>
-<p></p>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/smiley.png"></span><span class="bold"><b>Remember the Zen, Luke:</b></span><br><br>
 
-"Explicit is better than implicit"<p></p>
+"Explicit is better than implicit"<br>
 
-"In the face of ambiguity, refuse the temptation to guess"<p></p>
+"In the face of ambiguity, refuse the temptation to guess"<br>
 </td></tr></tbody>
 </table></div>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.overloading"></a>Overloading</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.overloading"></a>Overloading</h3></div></div></div>
 <p>
 The following illustrates a scheme for manually wrapping an overloaded
 member functions. Of course, the same technique can be applied to wrapping
@@ -301,11 +293,8 @@ With these in hand, we can proceed to define and wrap this for Python:</p>
 .</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span><span class="identifier"> fx4</span><span class="special">)</span></tt></pre>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.default_arguments"></a>Default Arguments</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.default_arguments"></a>Default Arguments</h3></div></div></div>
 <p>
 Boost.Python wraps (member) function pointers. Unfortunately, C++ function
 pointers carry no default argument info. Take a function <tt class="literal">f</tt> with default
@@ -323,7 +312,7 @@ to retrieve the default arguments:</p>
 </span></tt></pre>
 <p>
 Because of this, when wrapping C++ code, we had to resort to manual
-wrapping as outlined in the <a href="functions.html#overloading" target="_top">previous section</a>, or
+wrapping as outlined in the <a href="functions.html#python.overloading" title="Overloading">previous section</a>, or
 writing thin wrappers:</p>
 <pre class="programlisting"><tt class="literal"><span class="comment">// write "thin wrappers"
 </span><span class="keyword">int</span><span class="identifier"> f1</span><span class="special">(</span><span class="keyword">int</span><span class="identifier"> x</span><span class="special">)</span><span class="special"> {</span><span class="identifier"> f</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span><span class="special"> }</span><span class="keyword">
@@ -347,7 +336,7 @@ are overloaded with a common sequence of initial arguments
 </li>
 </ul></div>
 <a name="default_arguments.boost_python_function_overloads"></a><h2>
-<a name="id424225"></a>BOOST_PYTHON_FUNCTION_OVERLOADS</h2>
+<a name="id451716"></a>BOOST_PYTHON_FUNCTION_OVERLOADS</h2>
 <p>
 Boost.Python now has a way to make it easier. For instance, given a function:</p>
 <pre class="programlisting"><tt class="literal"><span class="keyword">int</span><span class="identifier"> foo</span><span class="special">(</span><span class="keyword">int</span><span class="identifier"> a</span><span class="special">,</span><span class="keyword"> char</span><span class="identifier"> b</span><span class="special"> =</span><span class="number"> 1</span><span class="special">,</span><span class="keyword"> unsigned</span><span class="identifier"> c</span><span class="special"> =</span><span class="number"> 2</span><span class="special">,</span><span class="keyword"> double</span><span class="identifier"> d</span><span class="special"> =</span><span class="number"> 3</span><span class="special">)</span><span class="special">
@@ -366,7 +355,7 @@ and the maximum number of arguments is 4. The <tt class="literal">def(...)</tt>
 automatically add all the foo variants for us:</p>
 <pre class="programlisting"><tt class="literal"><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span><span class="identifier"> foo</span><span class="special">,</span><span class="identifier"> foo_overloads</span><span class="special">());</span></tt></pre>
 <a name="default_arguments.boost_python_member_function_overloads"></a><h2>
-<a name="id424504"></a>BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</h2>
+<a name="id451995"></a>BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</h2>
 <p>
 Objects here, objects there, objects here there everywhere. More frequently
 than anything else, we need to expose member functions of our classes to
@@ -398,7 +387,7 @@ fourth macro argument). The thin wrappers are all enclosed in a class named
 See the <a href="../../../../v2/overloads.html#BOOST_PYTHON_FUNCTION_OVERLOADS-spec" target="_top">overloads reference</a>
 for details.</p>
 <a name="default_arguments.init_and_optional"></a><h2>
-<a name="id424831"></a>init and optional</h2>
+<a name="id452323"></a>init and optional</h2>
 <p>
 A similar facility is provided for class constructors, again, with
 default arguments or a sequence of overloads. Remember <tt class="literal">init&lt;...&gt;</tt>? For example,
@@ -416,11 +405,8 @@ Notice the use of <tt class="literal">init&lt;...&gt;</tt> and <tt class="litera
 (optional arguments).</p>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.auto_overloading"></a>Auto-Overloading</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.auto_overloading"></a>Auto-Overloading</h3></div></div></div>
 <p>
 It was mentioned in passing in the previous section that
 <tt class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</tt> and <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt>
@@ -456,17 +442,17 @@ Then...</p>
 Notice though that we have a situation now where we have a minimum of zero
 (0) arguments and a maximum of 3 arguments.</p>
 <a name="auto_overloading.manual_wrapping"></a><h2>
-<a name="id425478"></a>Manual Wrapping</h2>
+<a name="id452969"></a>Manual Wrapping</h2>
 <p>
 It is important to emphasize however that <span class="bold"><b>the overloaded functions must
 have a common sequence of initial arguments</b></span>. Otherwise, our scheme above
 will not work. If this is not the case, we have to wrap our functions
-<a href="functions.html#overloading" target="_top">manually</a>.</p>
+<a href="functions.html#python.overloading" title="Overloading">manually</a>.</p>
 <p>
 Actually, we can mix and match manual wrapping of overloaded functions and
 automatic wrapping through <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt> and
 its sister, <tt class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</tt>. Following up on our example
-presented in the section <a href="functions.html#overloading" target="_top">on overloading</a>, since the
+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 <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
@@ -484,7 +470,7 @@ Then...</p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2004 Joel de Guzman, David Abrahams</small></td>
+<td align="right"><small>Copyright © 2002-2005 Joel de Guzman, David Abrahams</small></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">

doc/tutorial/doc/html/python/hello.html

@@ -3,33 +3,30 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title> Building Hello World</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
-<link rel="home" href="../index.html" title="Chapter 1. python 1.0">
+<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="previous" 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">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%">
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../boost.png"></td>
-<td align="center"><a href="../../../index.htm">Home</a></td>
-<td align="center"><a href="../libraries.html">Libraries</a></td>
-<td align="center"><a href="../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../more/faq.htm">FAQ</a></td>
-<td align="center"><a href="../../../more/index.htm">More</a></td>
+<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="../index.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../images/next.png" alt="Next"></a>
 </div>
 <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></div>
-</div>
+<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="id343708"></a>From Start To Finish</h2>
+<a name="id374047"></a>From Start To Finish</h2>
 <p>
 Now the first thing you'd want to do is to build the Hello World module and
 try it for yourself in Python. In this section, we shall outline the steps
@@ -37,14 +34,12 @@ necessary to achieve that. We shall use the build tool that comes bundled
 with every boost distribution: <span class="bold"><b>bjam</b></span>.</p>
 <div class="informaltable"><table class="table">
 <colgroup><col></colgroup>
-<tbody><tr><td>
-<span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>Building without bjam</b></span><p></p>
-<p></p>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>Building without bjam</b></span><br><br>
 
     Besides bjam, there are of course other ways to get your module built.
     What's written here should not be taken as "the one and only way".
-    There are of course other build tools apart from <tt class="literal">bjam</tt>.<p></p>
-<p></p>
+    There are of course other build tools apart from <tt class="literal">bjam</tt>.<br><br>
 
     Take note however that the preferred build tool for Boost.Python is bjam.
     There are so many ways to set up the build incorrectly. Experience shows
@@ -95,96 +90,111 @@ minimalist <span class="emphasis"><em>bjam</em></span> script that builds the DL
 Before anything else, you should have the bjam executable in your boost
 directory or somewhere in your path such that <tt class="literal">bjam</tt> can be executed in
 the command line. Pre-built Boost.Jam executables are available for most
-platforms. The complete list of Bjam executables can be found 
+platforms. The complete list of Bjam executables can be found
 <a href="http://sourceforge.net/project/showfiles.php?group_id=7586" target="_top">here</a>.</p>
 <a name="hello.let_s_jam_"></a><h2>
-<a name="id343869"></a>Let's Jam!</h2>
+<a name="id372653"></a>Let's Jam!</h2>
 <p><span class="inlinemediaobject"><img src="../images/jam.png"></span></p>
 <p>
 Here is our minimalist Jamfile:</p>
-<pre class="programlisting"><tt class="literal">    subproject libs/python/example/tutorial ;
+<pre class="programlisting"><tt class="literal"># This is the top of our own project tree
+project-root ;
 
-    SEARCH on python.jam = $(BOOST_BUILD_PATH) ;
-    include python.jam ;
+import python ;
 
-    extension hello                     # Declare a Python extension called hello
-    :   hello.cpp                       # source
-        &lt;dll&gt;../../build/boost_python   # dependencies
-        ;
+extension hello                     # Declare a Python extension called hello
+:   hello.cpp                       # source
+    # requirements and dependencies for Boost.Python extensions
+    &lt;template&gt;@boost/libs/python/build/extension
+    ;
 </tt></pre>
 <p>
-First, we need to specify our location in the boost project hierarchy.
-It so happens that the tutorial example is located in <tt class="literal">/libs/python/example/tutorial</tt>.
-Thus:</p>
-<pre class="programlisting"><tt class="literal">    subproject libs/python/example/tutorial ;
+First, we need to specify our location. You may place your project anywhere.
+<tt class="literal">project-root</tt> allows you to do that.</p>
+<pre class="programlisting"><tt class="literal">project-root ;
 </tt></pre>
 <p>
-Then we will include the definitions needed by Python modules:</p>
-<pre class="programlisting"><tt class="literal">    SEARCH on python.jam = $(BOOST_BUILD_PATH) ;
-    include python.jam ;
+By doing so, you'll need a Jamrules file. Simply copy the one in the 
+<a href="../../../../../example/tutorial/Jamrules" target="_top">example/tutorial directory</a> and tweak 
+the <tt class="literal">path-global BOOST_ROOT</tt> to where your boost root directory is. The file
+has <a href="../../../../../example/tutorial/Jamrules" target="_top">detailed instructions</a> you can follow.</p>
+<p>
+Then we will import the definitions needed by Python modules:</p>
+<pre class="programlisting"><tt class="literal">import python ;
 </tt></pre>
 <p>
 Finally we declare our <tt class="literal">hello</tt> extension:</p>
-<pre class="programlisting"><tt class="literal">    extension hello                     # Declare a Python extension called hello
-    :   hello.cpp                       # source
-        &lt;dll&gt;../../build/boost_python   # dependencies
-        ;
+<pre class="programlisting"><tt class="literal">extension hello                     # Declare a Python extension called hello
+:   hello.cpp                       # source
+
+    # requirements and dependencies for Boost.Python extensions
+    &lt;template&gt;@boost/libs/python/build/extension
+    ;
 </tt></pre>
+<p>
+The last part tells BJam that we are depending on the Boost Python Library.</p>
 <a name="hello.running_bjam"></a><h2>
-<a name="id343964"></a>Running bjam</h2>
+<a name="id372775"></a>Running bjam</h2>
 <p><span class="emphasis"><em>bjam</em></span> is run using your operating system's command line interpreter.</p>
 <div class="blockquote"><blockquote class="blockquote"><p>Start it up.</p></blockquote></div>
 <p>
 Make sure that the environment is set so that we can invoke the C++
 compiler. With MSVC, that would mean running the <tt class="literal">Vcvars32.bat</tt> batch
 file. For instance:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">C</span><span class="special">:\</span><span class="identifier">Program</span><span class="identifier"> Files</span><span class="special">\</span><span class="identifier">Microsoft</span><span class="identifier"> Visual</span><span class="identifier"> Studio</span><span class="special">\</span><span class="identifier">VC98</span><span class="special">\</span><span class="identifier">bin</span><span class="special">\</span><span class="identifier">Vcvars32</span><span class="special">.</span><span class="identifier">bat</span></tt></pre>
+<pre class="programlisting"><tt class="literal">C:\Program Files\Microsoft Visual Studio .NET 2003\Common7\Tools\vsvars32.bat
+</tt></pre>
 <p>
 Some environment variables will have to be setup for proper building of our
 Python modules. Example:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">set</span><span class="identifier"> PYTHON_ROOT</span><span class="special">=</span><span class="identifier">c</span><span class="special">:/</span><span class="identifier">dev</span><span class="special">/</span><span class="identifier">tools</span><span class="special">/</span><span class="identifier">python</span><span class="identifier">
-set</span><span class="identifier"> PYTHON_VERSION</span><span class="special">=</span><span class="number">2.2</span></tt></pre>
+<pre class="programlisting"><tt class="literal">set PYTHON_ROOT=c:/dev/tools/python
+set PYTHON_VERSION=2.2
+</tt></pre>
 <p>
 The above assumes that the Python installation is in <tt class="literal">c:/dev/tools/python</tt>
-and that we are using Python version 2.2. You'll have to tweak this path
+and that we are using Python version 2.2. You'll have to tweak these
 appropriately.</p>
 <div class="informaltable"><table class="table">
 <colgroup><col></colgroup>
-<tbody><tr><td>
+<tbody><tr><td class="blurb">
 <span class="inlinemediaobject"><img src="../images/tip.png"></span> Be sure not to include a third number, e.g. <span class="bold"><b>not</b></span>  "2.2.1",
 even if that's the version you have.</td></tr></tbody>
 </table></div>
 <p>
+Take note that you may also do that through the Jamrules file we put in
+our project as detailed above. The file
+has <a href="../../../../../example/tutorial/Jamrules" target="_top">detailed instructions</a> you 
+can follow.</p>
+<p>
 Now we are ready... Be sure to <tt class="literal">cd</tt> to <tt class="literal">libs/python/example/tutorial</tt>
 where the tutorial <tt class="literal">"hello.cpp"</tt> and the <tt class="literal">"Jamfile"</tt> is situated.</p>
 <p>
 Finally:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">bjam</span><span class="special"> -</span><span class="identifier">sTOOLS</span><span class="special">=</span><span class="identifier">msvc</span></tt></pre>
+<pre class="programlisting"><tt class="literal"><span class="identifier">bjam</span><span class="special"> -</span><span class="identifier">sTOOLS</span><span class="special">=</span><span class="identifier">vc</span><span class="special">-</span><span class="number">7</span><span class="identifier">_1</span></tt></pre>
 <p>
-We are again assuming that we are using Microsoft Visual C++ version 6. If
+We are again assuming that we are using Microsoft Visual C++ version 7.1. If
 not, then you will have to specify the appropriate tool. See
 <a href="../../../../../../../tools/build/index.html" target="_top">Building Boost Libraries</a> for
 further details.</p>
 <p>
 It should be building now:</p>
-<pre class="programlisting"><tt class="literal">    cd C:\dev\boost\libs\python\example\tutorial
-    bjam -sTOOLS=msvc
-    ...patience...
-    ...found 1703 targets...
-    ...updating 40 targets...
+<pre class="programlisting"><tt class="literal">cd C:\dev\boost\libs\python\example\tutorial
+bjam -sTOOLS=msvc
+...patience...
+...found 1703 targets...
+...updating 40 targets...
 </tt></pre>
 <p>
 And so on... Finally:</p>
-<pre class="programlisting"><tt class="literal">    vc-C++ ........\libs\python\example\tutorial\bin\hello.pyd\msvc\debug\
-    runtime-link-dynamic\hello.obj
-    hello.cpp
-    vc-Link ........\libs\python\example\tutorial\bin\hello.pyd\msvc\debug\
-    runtime-link-dynamic\hello.pyd ........\libs\python\example\tutorial\bin\
-    hello.pyd\msvc\debug\runtime-link-dynamic\hello.lib
-       Creating library ........\libs\python\example\tutorial\bin\hello.pyd\
-       msvc\debug\runtime-link-dynamic\hello.lib and object ........\libs\python\
-       example\tutorial\bin\hello.pyd\msvc\debug\runtime-link-dynamic\hello.exp
-    ...updated 40 targets...
+<pre class="programlisting"><tt class="literal">Creating library bin\boost\libs\python\build\boost_python.dll\vc-7_1\debug\th
+reading-multi\boost_python.lib and object bin\boost\libs\python\build\boost_pyth
+on.dll\vc-7_1\debug\threading-multi\boost_python.exp
+vc-C++ bin\tutorial\hello.pyd\vc-7_1\debug\threading-multi\hello.obj
+hello.cpp
+vc-Link bin\tutorial\hello.pyd\vc-7_1\debug\threading-multi\hello.pyd bin\tutori
+al\hello.pyd\vc-7_1\debug\threading-multi\hello.lib
+   Creating library bin\tutorial\hello.pyd\vc-7_1\debug\threading-multi\hello.li
+b and object bin\tutorial\hello.pyd\vc-7_1\debug\threading-multi\hello.exp
+...updated 31 targets...
 </tt></pre>
 <p>
 If all is well, you should now have:</p>
@@ -208,22 +218,22 @@ hello.so
 </ul></div>
 <p>
 if you are on Unix.</p>
-<p><tt class="literal">boost_python.dll</tt> can be found somewhere in <tt class="literal">libs\python\build\bin</tt>
-while <tt class="literal">hello.pyd</tt> can be found somewhere in
-<tt class="literal">libs\python\example\tutorial\bin</tt>. After a successful build, you can just
-link in these DLLs with the Python interpreter. In Windows for example, you
-can simply put these libraries inside the directory where the Python
-executable is.</p>
+<p><tt class="literal">boost_python.dll</tt> and <tt class="literal">hello.pyd</tt> can be found somewhere in your project's
+<tt class="literal">bin</tt> directory. After a successful build, you can just link in these DLLs with 
+the Python interpreter. In Windows for example, you can simply put these libraries 
+inside the directory where the Python executable is.</p>
 <p>
 You may now fire up Python and run our hello module:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> import</span><span class="identifier"> hello</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> print</span><span class="identifier"> hello</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span><span class="identifier">
+<p></p>
+<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="keyword"> import</span><span class="identifier"> hello</span><span class="special">
+&gt;&gt;&gt;</span><span class="keyword"> print</span><span class="identifier"> hello</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span><span class="identifier">
 hello</span><span class="special">,</span><span class="identifier"> world</span></tt></pre>
+<p></p>
 <div class="blockquote"><blockquote class="blockquote"><p><span class="bold"><b>There you go... Have fun!</b></span></p></blockquote></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2004 Joel de Guzman, David Abrahams</small></td>
+<td align="right"><small>Copyright © 2002-2005 Joel de Guzman, David Abrahams</small></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">

doc/tutorial/doc/html/python/iterators.html

@@ -3,31 +3,28 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Iterators</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
-<link rel="home" href="../index.html" title="Chapter 1. python 1.0">
+<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="previous" href="embedding.html" title="Embedding">
+<link rel="prev" href="embedding.html" title="Embedding">
 <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%">
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../boost.png"></td>
-<td align="center"><a href="../../../index.htm">Home</a></td>
-<td align="center"><a href="../libraries.html">Libraries</a></td>
-<td align="center"><a href="../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../more/faq.htm">FAQ</a></td>
-<td align="center"><a href="../../../more/index.htm">More</a></td>
+<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="embedding.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="exception.html"><img src="../images/next.png" alt="Next"></a>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h2 class="title" style="clear: both">
-<a name="python.iterators"></a>Iterators</h2></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="python.iterators"></a>Iterators</h2></div></div></div>
 <p>
 In C++, and STL in particular, we see iterators everywhere. Python also has
 iterators, but these are two very different beasts.</p>
@@ -57,17 +54,20 @@ Raises StopIteration exception at end
 </ul></div>
 <p>
 The typical Python iteration protocol: <tt class="literal"><span class="bold"><b>for y in x...</b></span></tt> is as follows:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">iter</span><span class="special"> =</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">__iter__</span><span class="special">()</span>         #<span class="identifier"> get</span><span class="identifier"> iterator</span><span class="keyword">
-try</span><span class="special">:</span><span class="keyword">
+<p></p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">iter</span><span class="special"> =</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">__iter__</span><span class="special">()</span><span class="comment">         # get iterator
+</span><span class="keyword">try</span><span class="special">:</span><span class="keyword">
     while</span><span class="number"> 1</span><span class="special">:</span><span class="identifier">
-    y</span><span class="special"> =</span><span class="identifier"> iter</span><span class="special">.</span><span class="identifier">next</span><span class="special">()</span>         #<span class="identifier"> get</span><span class="identifier"> each</span><span class="identifier"> item</span><span class="special">
-    ...</span>                     #<span class="identifier"> process</span><span class="identifier"> y</span><span class="identifier">
-except</span><span class="identifier"> StopIteration</span><span class="special">:</span><span class="identifier"> pass</span>  #<span class="identifier"> iterator</span><span class="identifier"> exhausted</span></tt></pre>
+    y</span><span class="special"> =</span><span class="identifier"> iter</span><span class="special">.</span><span class="identifier">next</span><span class="special">()</span><span class="comment">         # get each item
+</span><span class="special">    ...</span><span class="comment">                     # process y
+</span><span class="keyword">except</span><span class="identifier"> StopIteration</span><span class="special">:</span><span class="keyword"> pass</span><span class="comment">  # iterator exhausted
+</span></tt></pre>
 <p>
 Boost.Python provides some mechanisms to make C++ iterators play along
 nicely as Python iterators. What we need to do is to produce
-appropriate <span class="underline">_iter</span>_ function from C++ iterators that is compatible
+appropriate <tt class="computeroutput"><span class="identifier">__iter__</span></tt> function from C++ iterators that is compatible
 with the Python iteration protocol. For example:</p>
+<p></p>
 <pre class="programlisting"><tt class="literal"><span class="identifier">object</span><span class="identifier"> get_iterator</span><span class="special"> =</span><span class="identifier"> iterator</span><span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span><span class="special"> &gt;();</span><span class="identifier">
 object</span><span class="identifier"> iter</span><span class="special"> =</span><span class="identifier"> get_iterator</span><span class="special">(</span><span class="identifier">v</span><span class="special">);</span><span class="identifier">
 object</span><span class="identifier"> first</span><span class="special"> =</span><span class="identifier"> iter</span><span class="special">.</span><span class="identifier">next</span><span class="special">();</span></tt></pre>
@@ -108,20 +108,22 @@ with &amp;T::begin, &amp;T::end.</p>
 <p>
 Let's put this into action... Here's an example from some hypothetical
 bogon Particle accelerator code:</p>
+<p></p>
 <pre class="programlisting"><tt class="literal"><span class="identifier">f</span><span class="special"> =</span><span class="identifier"> Field</span><span class="special">()</span><span class="keyword">
-for</span><span class="identifier"> x</span><span class="identifier"> in</span><span class="identifier"> f</span><span class="special">.</span><span class="identifier">pions</span><span class="special">:</span><span class="identifier">
+for</span><span class="identifier"> x</span><span class="keyword"> in</span><span class="identifier"> f</span><span class="special">.</span><span class="identifier">pions</span><span class="special">:</span><span class="identifier">
     smash</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span><span class="keyword">
-for</span><span class="identifier"> y</span><span class="identifier"> in</span><span class="identifier"> f</span><span class="special">.</span><span class="identifier">bogons</span><span class="special">:</span><span class="identifier">
+for</span><span class="identifier"> y</span><span class="keyword"> in</span><span class="identifier"> f</span><span class="special">.</span><span class="identifier">bogons</span><span class="special">:</span><span class="identifier">
     count</span><span class="special">(</span><span class="identifier">y</span><span class="special">)</span></tt></pre>
 <p>
 Now, our C++ Wrapper:</p>
+<p></p>
 <pre class="programlisting"><tt class="literal"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">&gt;(</span><span class="string">"Field"</span><span class="special">)</span><span class="special">
     .</span><span class="identifier">property</span><span class="special">(</span><span class="string">"pions"</span><span class="special">,</span><span class="identifier"> range</span><span class="special">(&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">p_begin</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">p_end</span><span class="special">))</span><span class="special">
     .</span><span class="identifier">property</span><span class="special">(</span><span class="string">"bogons"</span><span class="special">,</span><span class="identifier"> range</span><span class="special">(&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">b_begin</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">b_end</span><span class="special">));</span></tt></pre>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2004 Joel de Guzman, David Abrahams</small></td>
+<td align="right"><small>Copyright © 2002-2005 Joel de Guzman, David Abrahams</small></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">

doc/tutorial/doc/html/python/object.html

@@ -3,31 +3,28 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title> Object Interface</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
-<link rel="home" href="../index.html" title="Chapter 1. python 1.0">
+<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="previous" href="functions.html" title="Functions">
+<link rel="prev" href="functions.html" title="Functions">
 <link rel="next" href="embedding.html" title="Embedding">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%">
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../boost.png"></td>
-<td align="center"><a href="../../../index.htm">Home</a></td>
-<td align="center"><a href="../libraries.html">Libraries</a></td>
-<td align="center"><a href="../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../more/faq.htm">FAQ</a></td>
-<td align="center"><a href="../../../more/index.htm">More</a></td>
+<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="functions.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../images/next.png" alt="Next"></a>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h2 class="title" style="clear: both">
-<a name="python.object"></a> Object Interface</h2></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="python.object"></a> Object Interface</h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="object.html#python.basic_interface">Basic Interface</a></span></dt>
 <dt><span class="section"><a href="object.html#python.derived_object_types">Derived Object types</a></span></dt>
@@ -47,11 +44,8 @@ feel. Boost.Python C++ <tt class="literal">object</tt>s are as close as possible
 should minimize the learning curve significantly.</p>
 <p><span class="inlinemediaobject"><img src="../images/python.png"></span></p>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.basic_interface"></a>Basic Interface</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.basic_interface"></a>Basic Interface</h3></div></div></div>
 <p>
 Class <tt class="literal">object</tt> wraps <tt class="literal">PyObject*</tt>. All the intricacies of dealing with
 <tt class="literal">PyObject</tt>s such as managing reference counting are handled by the
@@ -59,17 +53,19 @@ Class <tt class="literal">object</tt> wraps <tt class="literal">PyObject*</tt>.
 <tt class="literal">object</tt>s can in fact be explicitly constructed from any C++ object.</p>
 <p>
 To illustrate, this Python code snippet:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">def</span><span class="identifier"> f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span><span class="identifier"> y</span><span class="special">):</span><span class="keyword">
-     if</span><span class="special"> (</span><span class="identifier">y</span><span class="special"> ==</span><span class="char"> 'foo'</span><span class="special">):</span><span class="identifier">
-         x</span><span class="special">[</span><span class="number">3</span><span class="special">:</span><span class="number">7</span><span class="special">]</span><span class="special"> =</span><span class="char"> 'bar'</span><span class="keyword">
+<p></p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">def</span><span class="identifier"> f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span><span class="identifier"> y</span><span class="special">):</span><span class="keyword">
+     if</span><span class="special"> (</span><span class="identifier">y</span><span class="special"> ==</span><span class="string"> 'foo'</span><span class="special">):</span><span class="identifier">
+         x</span><span class="special">[</span><span class="number">3</span><span class="special">:</span><span class="number">7</span><span class="special">]</span><span class="special"> =</span><span class="string"> 'bar'</span><span class="keyword">
      else</span><span class="special">:</span><span class="identifier">
          x</span><span class="special">.</span><span class="identifier">items</span><span class="special"> +=</span><span class="identifier"> y</span><span class="special">(</span><span class="number">3</span><span class="special">,</span><span class="identifier"> x</span><span class="special">)</span><span class="keyword">
-     return</span><span class="identifier"> x</span><span class="identifier">
+     return</span><span class="identifier"> x</span><span class="keyword">
 
 def</span><span class="identifier"> getfunc</span><span class="special">():</span><span class="keyword">
    return</span><span class="identifier"> f</span><span class="special">;</span></tt></pre>
 <p>
 Can be rewritten in C++ using Boost.Python facilities this way:</p>
+<p></p>
 <pre class="programlisting"><tt class="literal"><span class="identifier">object</span><span class="identifier"> f</span><span class="special">(</span><span class="identifier">object</span><span class="identifier"> x</span><span class="special">,</span><span class="identifier"> object</span><span class="identifier"> y</span><span class="special">)</span><span class="special"> {</span><span class="keyword">
      if</span><span class="special"> (</span><span class="identifier">y</span><span class="special"> ==</span><span class="string"> "foo"</span><span class="special">)</span><span class="identifier">
          x</span><span class="special">.</span><span class="identifier">slice</span><span class="special">(</span><span class="number">3</span><span class="special">,</span><span class="number">7</span><span class="special">)</span><span class="special"> =</span><span class="string"> "bar"</span><span class="special">;</span><span class="keyword">
@@ -86,11 +82,8 @@ code in C++, the look and feel should be immediately apparent to the Python
 coder.</p>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.derived_object_types"></a>Derived Object types</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.derived_object_types"></a>Derived Object types</h3></div></div></div>
 <p>
 Boost.Python comes with a set of derived <tt class="literal">object</tt> types corresponding to
 that of Python's:</p>
@@ -144,18 +137,27 @@ member functions.</p>
 <p>
 Demonstrates that you can write the C++ equivalent of <tt class="literal">"format" % x,y,z</tt>
 in Python, which is useful since there's no easy way to do that in std C++.</p>
-<p><span class="inlinemediaobject"><img src="../images/alert.png"></span><span class="bold"><b>Beware</b></span> the common pitfall of forgetting that the constructors
-of most of Python's mutable types make copies, just as in Python.</p>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/alert.png"></span><span class="bold"><b>Beware</b></span> the common pitfall of forgetting that the constructors
+    of most of Python's mutable types make copies, just as in Python.
+</td></tr></tbody>
+</table></div>
 <p>
-Python:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> d</span><span class="special"> =</span><span class="identifier"> dict</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">__dict__</span><span class="special">)</span>     #<span class="identifier"> copies</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">__dict__</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> d</span><span class="special">[</span><span class="char">'whatever'</span><span class="special">]</span>            #<span class="identifier"> modifies</span><span class="identifier"> the</span><span class="identifier"> copy</span></tt></pre>
+Python:
+</p>
+<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> d</span><span class="special"> =</span><span class="identifier"> dict</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">__dict__</span><span class="special">)</span><span class="comment">     # copies x.__dict__
+</span><span class="special">&gt;&gt;&gt;</span><span class="identifier"> d</span><span class="special">[</span><span class="string">'whatever'</span><span class="special">]</span><span class="comment">            # modifies the copy
+</span></tt></pre>
 <p>
-C++:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">dict</span><span class="identifier"> d</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>  #<span class="identifier"> copies</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">__dict__</span><span class="identifier">
-d</span><span class="special">[</span><span class="char">'whatever'</span><span class="special">]</span><span class="special"> =</span><span class="number"> 3</span><span class="special">;</span>           #<span class="identifier"> modifies</span><span class="identifier"> the</span><span class="identifier"> copy</span></tt></pre>
+C++:
+</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">dict</span><span class="identifier"> d</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span><span class="comment">  // copies x.__dict__
+</span><span class="identifier">d</span><span class="special">[</span><span class="char">'whatever'</span><span class="special">]</span><span class="special"> =</span><span class="number"> 3</span><span class="special">;</span><span class="comment">           // modifies the copy
+</span></tt></pre>
 <a name="derived_object_types.class__lt_t_gt__as_objects"></a><h2>
-<a name="id427284"></a>class_&lt;T&gt; as objects</h2>
+<a name="id454735"></a>class_&lt;T&gt; as objects</h2>
 <p>
 Due to the dynamic nature of Boost.Python objects, any <tt class="literal">class_&lt;T&gt;</tt> may
 also be one of these types! The following code snippet wraps the class
@@ -171,11 +173,8 @@ We can use this to create wrapped instances. Example:</p>
 assert</span><span class="special">(</span><span class="identifier">vec345</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">)</span><span class="special"> ==</span><span class="number"> 5.0</span><span class="special">);</span></tt></pre>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.extracting_c___objects"></a>Extracting C++ objects</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.extracting_c___objects"></a>Extracting C++ objects</h3></div></div></div>
 <p>
 At some point, we will need to get C++ values out of object instances. This
 can be achieved with the <tt class="literal">extract&lt;T&gt;</tt> function. Consider the following:</p>
@@ -189,16 +188,15 @@ we wanted to do above can be achieved by writing:</p>
 Vec2</span><span class="special">&amp;</span><span class="identifier"> v</span><span class="special"> =</span><span class="identifier"> extract</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&amp;&gt;(</span><span class="identifier">o</span><span class="special">);</span><span class="identifier">
 assert</span><span class="special">(</span><span class="identifier">l</span><span class="special"> ==</span><span class="identifier"> v</span><span class="special">.</span><span class="identifier">length</span><span class="special">());</span></tt></pre>
 <p>
-The first line attempts to extract the "length" attribute of the
-Boost.Python <tt class="literal">object</tt><tt class="literal">o</tt>. The second line attempts to <span class="emphasis"><em>extract</em></span> the
-<tt class="literal">Vec2</tt> object from held by the Boost.Python <tt class="literal">object</tt><tt class="literal">o</tt>.</p>
+The first line attempts to extract the "length" attribute of the Boost.Python 
+<tt class="literal">object</tt>. The second line attempts to <span class="emphasis"><em>extract</em></span> the <tt class="literal">Vec2</tt> object from held 
+by the Boost.Python <tt class="literal">object</tt>.</p>
 <p>
-Take note that we said "attempt to" above. What if the Boost.Python
-<tt class="literal">object</tt><tt class="literal">o</tt> does not really hold a <tt class="literal">Vec2</tt> type? This is certainly
-a possibility considering the dynamic nature of Python <tt class="literal">object</tt>s. To
-be on the safe side, if the C++ type can't be extracted, an
-appropriate exception is thrown. To avoid an exception, we need to
-test for extractibility:</p>
+Take note that we said "attempt to" above. What if the Boost.Python <tt class="literal">object</tt> 
+does not really hold a <tt class="literal">Vec2</tt> type? This is certainly a possibility considering 
+the dynamic nature of Python <tt class="literal">object</tt>s. To be on the safe side, if the C++ type 
+can't be extracted, an appropriate exception is thrown. To avoid an exception, 
+we need to test for extractibility:</p>
 <pre class="programlisting"><tt class="literal"><span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&amp;&gt;</span><span class="identifier"> x</span><span class="special">(</span><span class="identifier">o</span><span class="special">);</span><span class="keyword">
 if</span><span class="special"> (</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">check</span><span class="special">())</span><span class="special"> {</span><span class="identifier">
     Vec2</span><span class="special">&amp;</span><span class="identifier"> v</span><span class="special"> =</span><span class="identifier"> x</span><span class="special">();</span><span class="special"> ...</span></tt></pre>
@@ -208,11 +206,8 @@ facility in fact solves the mutable copying problem:</p>
 d</span><span class="special">[</span><span class="char">'whatever'</span><span class="special">]</span><span class="special"> =</span><span class="number"> 3</span><span class="special">;</span>          #<span class="identifier"> modifies</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">__dict__</span><span class="special"> !</span></tt></pre>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.enums"></a>Enums</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.enums"></a>Enums</h3></div></div></div>
 <p>
 Boost.Python has a nifty facility to capture and wrap C++ enums. While
 Python has no <tt class="literal">enum</tt> type, we'll often want to expose our C++ enums to
@@ -234,9 +229,8 @@ creates a Python class derived from Python's <tt class="literal">int</tt> type w
 associated with the C++ type passed as its first parameter.</p>
 <div class="informaltable"><table class="table">
 <colgroup><col></colgroup>
-<tbody><tr><td>
-<span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>what is a scope?</b></span><p></p>
-<p></p>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>what is a scope?</b></span><br><br>
  The scope is a class that has an
 associated global Python object which controls the Python namespace in
 which new extension classes and wrapped functions will be defined as
@@ -244,11 +238,13 @@ attributes. Details can be found <a href="../../../../v2/scope.html" target="_to
 </table></div>
 <p>
 You can access those values in Python as</p>
+<p></p>
 <pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> my_module</span><span class="special">.</span><span class="identifier">choice</span><span class="special">.</span><span class="identifier">red</span><span class="identifier">
 my_module</span><span class="special">.</span><span class="identifier">choice</span><span class="special">.</span><span class="identifier">red</span></tt></pre>
 <p>
 where my_module is the module where the enum is declared. You can also
 create a new scope around a class:</p>
+<p></p>
 <pre class="programlisting"><tt class="literal"><span class="identifier">scope</span><span class="identifier"> in_X</span><span class="special"> =</span><span class="identifier"> class_</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;(</span><span class="string">"X"</span><span class="special">)</span><span class="special">
                 .</span><span class="identifier">def</span><span class="special">(</span><span class="special"> ...</span><span class="special"> )</span><span class="special">
                 .</span><span class="identifier">def</span><span class="special">(</span><span class="special"> ...</span><span class="special"> )</span><span class="special">
@@ -263,7 +259,7 @@ create a new scope around a class:</p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2004 Joel de Guzman, David Abrahams</small></td>
+<td align="right"><small>Copyright © 2002-2005 Joel de Guzman, David Abrahams</small></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">

doc/tutorial/doc/html/python/techniques.html

@@ -3,30 +3,27 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title> General Techniques</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
-<link rel="home" href="../index.html" title="Chapter 1. python 1.0">
+<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="previous" 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%">
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../boost.png"></td>
-<td align="center"><a href="../../../index.htm">Home</a></td>
-<td align="center"><a href="../libraries.html">Libraries</a></td>
-<td align="center"><a href="../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../more/faq.htm">FAQ</a></td>
-<td align="center"><a href="../../../more/index.htm">More</a></td>
+<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="exception.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h2 class="title" style="clear: both">
-<a name="python.techniques"></a> General Techniques</h2></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="python.techniques"></a> General Techniques</h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="techniques.html#python.creating_packages">Creating Packages</a></span></dt>
 <dt><span class="section"><a href="techniques.html#python.extending_wrapped_objects_in_python">Extending Wrapped Objects in Python</a></span></dt>
@@ -35,11 +32,8 @@
 <p>
 Here are presented some useful techniques that you can use while wrapping code with Boost.Python.</p>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.creating_packages"></a>Creating Packages</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.creating_packages"></a>Creating Packages</h3></div></div></div>
 <p>
 A Python package is a collection of modules that provide to the user a certain
 functionality. If you're not familiar on how to create packages, a good
@@ -89,30 +83,31 @@ 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>.</p>
 <div class="informaltable"><table class="table">
 <colgroup><col></colgroup>
-<tbody><tr><td>
+<tbody><tr><td class="blurb">
 <span class="inlinemediaobject"><img src="../images/note.png"></span> 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 <tt class="literal">.so</tt> for
 Unix and <tt class="literal">.dll</tt> for Windows, works just as well.</td></tr></tbody>
 </table></div>
 <p>
 Now, we create this directory structure for our Python package:</p>
-<pre class="programlisting"><tt class="literal">    sounds/
-        <span class="underline">_init</span>_.py
-        core.pyd
-        filters.pyd
-        io.pyd
+<pre class="programlisting"><tt class="literal">sounds/
+    __init__.py
+    core.pyd
+    filters.pyd
+    io.pyd
 </tt></pre>
 <p>
-The file <tt class="literal"><span class="underline">_init</span>_.py</tt> is what tells Python that the directory <tt class="literal">sounds/</tt> is
+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.</p>
 <p>
 Now our package is ready. All the user has to do is put <tt class="literal">sounds</tt> into his
-<a href="http://www.python.org/doc/current/tut/node8.html#SECTION008110000000000000000" target="_top">PYTHONPATH</a> 
+<a href="http://www.python.org/doc/current/tut/node8.html#SECTION008110000000000000000" target="_top">PYTHONPATH</a>
 and fire up the interpreter:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> import</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">io</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> import</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> sound</span><span class="special"> =</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">io</span><span class="special">.</span><span class="identifier">open</span><span class="special">(</span><span class="char">'file.mp3'</span><span class="special">)</span><span class="special">
+<p></p>
+<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="keyword"> import</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">io</span><span class="special">
+&gt;&gt;&gt;</span><span class="keyword"> import</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">
+&gt;&gt;&gt;</span><span class="identifier"> sound</span><span class="special"> =</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">io</span><span class="special">.</span><span class="identifier">open</span><span class="special">(</span><span class="string">'file.mp3'</span><span class="special">)</span><span class="special">
 &gt;&gt;&gt;</span><span class="identifier"> new_sound</span><span class="special"> =</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(</span><span class="identifier">sound</span><span class="special">,</span><span class="number"> 1.0</span><span class="special">)</span></tt></pre>
 <p>
 Nice heh?</p>
@@ -126,6 +121,7 @@ it.</p>
 <p>
 If we want this flexibility, we will have to complicate our package hierarchy a
 little. First, we will have to change the name of the extension modules:</p>
+<p></p>
 <pre class="programlisting"><tt class="literal"><span class="comment">/* file core.cpp */</span><span class="identifier">
 BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_core</span><span class="special">)</span><span class="special">
 {</span><span class="special">
@@ -136,34 +132,35 @@ BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier"
 Note that we added an underscore to the module name. The filename will have to
 be changed to <tt class="literal">_core.pyd</tt> as well, and we do the same to the other extension modules.
 Now, we change our package hierarchy like so:</p>
-<pre class="programlisting"><tt class="literal">    sounds/
-        <span class="underline">_init</span>_.py
-        core/
-            <span class="underline">_init</span>_.py
-            _core.pyd
-        filters/
-            <span class="underline">_init</span>_.py
-            _filters.pyd
-        io/
-            <span class="underline">_init</span>_.py
-            _io.pyd
+<pre class="programlisting"><tt class="literal">sounds/
+    __init__.py
+    core/
+        __init__.py
+        _core.pyd
+    filters/
+        __init__.py
+        _filters.pyd
+    io/
+        __init__.py
+        _io.pyd
 </tt></pre>
 <p>
 Note that we created a directory for each extension module, and added a
-<span class="underline">_init</span>_.py to each one. But if we leave it that way, the user will have to
+__init__.py to each one. But if we leave it that way, the user will have to
 access the functions in the core module with this syntax:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> import</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span><span class="special">
+<p></p>
+<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="keyword"> import</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span><span class="special">
 &gt;&gt;&gt;</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span><span class="special">.</span><span class="identifier">foo</span><span class="special">(...)</span></tt></pre>
 <p>
-which is not what we want. But here enters the <tt class="literal"><span class="underline">_init</span>_.py</tt> magic: everything
-that is brought to the <tt class="literal"><span class="underline">_init</span>_.py</tt> namespace can be accessed directly by the
+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 <tt class="literal">_core.pyd</tt>
-to <tt class="literal">core/<span class="underline">_init</span><span class="underline">.py]. So add this line of code to [^sounds/core/</span><span class="underline">init</span>_.py</tt>:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">from</span><span class="identifier"> _core</span><span class="identifier"> import</span><span class="special"> *</span></tt></pre>
+to <tt class="literal">core/__init__.py</tt>. So add this line of code to <tt class="literal">sounds<span class="emphasis"><em>core</em></span>__init__.py</tt>:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">from</span><span class="identifier"> _core</span><span class="keyword"> import</span><span class="special"> *</span></tt></pre>
 <p>
 We do the same for the other packages. Now the user accesses the functions and
 classes in the extension modules like before:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> import</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">
+<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="keyword"> import</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">
 &gt;&gt;&gt;</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(...)</span></tt></pre>
 <p>
 with the additional benefit that we can easily add pure Python functions to
@@ -172,39 +169,36 @@ function and a Python function. Let's add a <span class="emphasis"><em>pure</em>
 <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:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">import</span><span class="identifier"> _filters</span><span class="identifier">
+<pre class="programlisting"><tt class="literal"><span class="keyword">import</span><span class="identifier"> _filters</span><span class="keyword">
 def</span><span class="identifier"> echo_noise</span><span class="special">(</span><span class="identifier">sound</span><span class="special">):</span><span class="identifier">
     s</span><span class="special"> =</span><span class="identifier"> _filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(</span><span class="identifier">sound</span><span class="special">)</span><span class="identifier">
     s</span><span class="special"> =</span><span class="identifier"> _filters</span><span class="special">.</span><span class="identifier">noise</span><span class="special">(</span><span class="identifier">sound</span><span class="special">)</span><span class="keyword">
     return</span><span class="identifier"> s</span></tt></pre>
 <p>
-Next, we add this line to <tt class="literal">sounds<span class="emphasis"><em>filters</em></span><span class="underline">_init</span>_.py</tt>:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">from</span><span class="identifier"> echo_noise</span><span class="identifier"> import</span><span class="identifier"> echo_noise</span></tt></pre>
+Next, we add this line to <tt class="literal">sounds<span class="emphasis"><em>filters</em></span>__init__.py</tt>:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">from</span><span class="identifier"> echo_noise</span><span class="keyword"> import</span><span class="identifier"> echo_noise</span></tt></pre>
 <p>
 And that's it. The user now accesses this function like any other function
 from the <tt class="literal">filters</tt> package:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> import</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">
+<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="keyword"> import</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">
 &gt;&gt;&gt;</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo_noise</span><span class="special">(...)</span></tt></pre>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.extending_wrapped_objects_in_python"></a>Extending Wrapped Objects in Python</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.extending_wrapped_objects_in_python"></a>Extending Wrapped Objects in Python</h3></div></div></div>
 <p>
 Thanks to Python's flexibility, you can easily add new methods to a class,
 even after it was already created:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="keyword"> class</span><span class="identifier"> C</span><span class="special">(</span><span class="identifier">object</span><span class="special">):</span><span class="identifier"> pass</span><span class="special">
+<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="keyword"> class</span><span class="identifier"> C</span><span class="special">(</span><span class="identifier">object</span><span class="special">):</span><span class="keyword"> pass</span><span class="special">
 &gt;&gt;&gt;</span><span class="special">
-&gt;&gt;&gt;</span> #<span class="identifier"> a</span><span class="identifier"> regular</span><span class="identifier"> function</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> def</span><span class="identifier"> C_str</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span><span class="keyword"> return</span><span class="char"> 'A C instance!'</span><span class="special">
+&gt;&gt;&gt;</span><span class="comment"> # a regular function
+</span><span class="special">&gt;&gt;&gt;</span><span class="keyword"> def</span><span class="identifier"> C_str</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span><span class="keyword"> return</span><span class="string"> 'A C instance!'</span><span class="special">
 &gt;&gt;&gt;</span><span class="special">
-&gt;&gt;&gt;</span> #<span class="identifier"> now</span><span class="identifier"> we</span><span class="identifier"> turn</span><span class="identifier"> it</span><span class="identifier"> in</span><span class="identifier"> a</span><span class="identifier"> member</span><span class="identifier"> function</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> C</span><span class="special">.</span><span class="identifier">__str__</span><span class="special"> =</span><span class="identifier"> C_str</span><span class="special">
+&gt;&gt;&gt;</span><span class="comment"> # now we turn it in a member function
+</span><span class="special">&gt;&gt;&gt;</span><span class="identifier"> C</span><span class="special">.</span><span class="identifier">__str__</span><span class="special"> =</span><span class="identifier"> C_str</span><span class="special">
 &gt;&gt;&gt;</span><span class="special">
 &gt;&gt;&gt;</span><span class="identifier"> c</span><span class="special"> =</span><span class="identifier"> C</span><span class="special">()</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> print</span><span class="identifier"> c</span><span class="identifier">
+&gt;&gt;&gt;</span><span class="keyword"> print</span><span class="identifier"> c</span><span class="identifier">
 A</span><span class="identifier"> C</span><span class="identifier"> instance</span><span class="special">!</span><span class="special">
 &gt;&gt;&gt;</span><span class="identifier"> C_str</span><span class="special">(</span><span class="identifier">c</span><span class="special">)</span><span class="identifier">
 A</span><span class="identifier"> C</span><span class="identifier"> instance</span><span class="special">!</span></tt></pre>
@@ -213,6 +207,7 @@ Yes, Python rox. <span class="inlinemediaobject"><img src="../images/smiley.png"
 <p>
 We can do the same with classes that were wrapped with Boost.Python. Suppose
 we have a class <tt class="literal">point</tt> in C++:</p>
+<p></p>
 <pre class="programlisting"><tt class="literal"><span class="keyword">class</span><span class="identifier"> point</span><span class="special"> {...};</span><span class="identifier">
 
 BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_geom</span><span class="special">)</span><span class="special">
@@ -221,16 +216,17 @@ BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier"
 }</span></tt></pre>
 <p>
 If we are using the technique from the previous session,
-<a href="techniques.html#creating_packages" target="_top">Creating Packages</a>, we can code directly 
-into <tt class="literal">geom/<span class="underline">_init</span>_.py</tt>:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">from</span><span class="identifier"> _geom</span><span class="identifier"> import</span><span class="special"> *</span>
+<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>:</p>
+<p></p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">from</span><span class="identifier"> _geom</span><span class="keyword"> import</span><span class="special"> *</span><span class="comment">
 
-#<span class="identifier"> a</span><span class="identifier"> regular</span><span class="identifier"> function</span><span class="identifier">
-def</span><span class="identifier"> point_str</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span><span class="keyword">
-    return</span><span class="identifier"> str</span><span class="special">((</span><span class="identifier">self</span><span class="special">.</span><span class="identifier">x</span><span class="special">,</span><span class="identifier"> self</span><span class="special">.</span><span class="identifier">y</span><span class="special">))</span>
+# a regular function
+</span><span class="keyword">def</span><span class="identifier"> point_str</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span><span class="keyword">
+    return</span><span class="identifier"> str</span><span class="special">((</span><span class="identifier">self</span><span class="special">.</span><span class="identifier">x</span><span class="special">,</span><span class="identifier"> self</span><span class="special">.</span><span class="identifier">y</span><span class="special">))</span><span class="comment">
 
-#<span class="identifier"> now</span><span class="identifier"> we</span><span class="identifier"> turn</span><span class="identifier"> it</span><span class="identifier"> into</span><span class="identifier"> a</span><span class="identifier"> member</span><span class="identifier"> function</span><span class="identifier">
-point</span><span class="special">.</span><span class="identifier">__str__</span><span class="special"> =</span><span class="identifier"> point_str</span></tt></pre>
+# now we turn it into a member function
+</span><span class="identifier">point</span><span class="special">.</span><span class="identifier">__str__</span><span class="special"> =</span><span class="identifier"> point_str</span></tt></pre>
 <p><span class="bold"><b>All</b></span> point instances created from C++ will also have this member function!
 This technique has several advantages:</p>
 <div class="itemizedlist"><ul type="disc">
@@ -250,35 +246,34 @@ Rapid prototyping (you can move the code to C++ if required without changing the
 <p>
 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.</p>
-<pre class="programlisting"><tt class="literal">
-#<span class="identifier"> The</span><span class="identifier"> one</span><span class="identifier"> Boost</span><span class="special">.</span><span class="identifier">Python</span><span class="identifier"> uses</span><span class="keyword"> for</span><span class="identifier"> all</span><span class="identifier"> wrapped</span><span class="identifier"> classes</span><span class="special">.</span>
-#<span class="identifier"> You</span><span class="identifier"> can</span><span class="identifier"> use</span><span class="identifier"> here</span><span class="identifier"> any</span><span class="keyword"> class</span><span class="identifier"> exported</span><span class="identifier"> by</span><span class="identifier"> Boost</span><span class="identifier"> instead</span><span class="identifier"> of</span><span class="string"> "point"</span><span class="identifier">
-BoostPythonMetaclass</span><span class="special"> =</span><span class="identifier"> point</span><span class="special">.</span><span class="identifier">__class__</span><span class="keyword">
+<pre class="programlisting"><tt class="literal"><span class="comment"># The one Boost.Python uses for all wrapped classes.
+# You can use here any class exported by Boost instead of "point"
+</span><span class="identifier">BoostPythonMetaclass</span><span class="special"> =</span><span class="identifier"> point</span><span class="special">.</span><span class="identifier">__class__</span><span class="keyword">
 
 class</span><span class="identifier"> injector</span><span class="special">(</span><span class="identifier">object</span><span class="special">):</span><span class="keyword">
-    class</span><span class="identifier"> __metaclass__</span><span class="special">(</span><span class="identifier">BoostPythonMetaclass</span><span class="special">):</span><span class="identifier">
+    class</span><span class="identifier"> __metaclass__</span><span class="special">(</span><span class="identifier">BoostPythonMetaclass</span><span class="special">):</span><span class="keyword">
         def</span><span class="identifier"> __init__</span><span class="special">(</span><span class="identifier">self</span><span class="special">,</span><span class="identifier"> name</span><span class="special">,</span><span class="identifier"> bases</span><span class="special">,</span><span class="identifier"> dict</span><span class="special">):</span><span class="keyword">
-            for</span><span class="identifier"> b</span><span class="identifier"> in</span><span class="identifier"> bases</span><span class="special">:</span><span class="keyword">
-                if</span><span class="identifier"> type</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span><span class="keyword"> not</span><span class="identifier"> in</span><span class="special"> (</span><span class="identifier">self</span><span class="special">,</span><span class="identifier"> type</span><span class="special">):</span><span class="keyword">
-                    for</span><span class="identifier"> k</span><span class="special">,</span><span class="identifier">v</span><span class="identifier"> in</span><span class="identifier"> dict</span><span class="special">.</span><span class="identifier">items</span><span class="special">():</span><span class="identifier">
+            for</span><span class="identifier"> b</span><span class="keyword"> in</span><span class="identifier"> bases</span><span class="special">:</span><span class="keyword">
+                if</span><span class="identifier"> type</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span><span class="keyword"> not</span><span class="keyword"> in</span><span class="special"> (</span><span class="identifier">self</span><span class="special">,</span><span class="identifier"> type</span><span class="special">):</span><span class="keyword">
+                    for</span><span class="identifier"> k</span><span class="special">,</span><span class="identifier">v</span><span class="keyword"> in</span><span class="identifier"> dict</span><span class="special">.</span><span class="identifier">items</span><span class="special">():</span><span class="identifier">
                         setattr</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">k</span><span class="special">,</span><span class="identifier">v</span><span class="special">)</span><span class="keyword">
-            return</span><span class="identifier"> type</span><span class="special">.</span><span class="identifier">__init__</span><span class="special">(</span><span class="identifier">self</span><span class="special">,</span><span class="identifier"> name</span><span class="special">,</span><span class="identifier"> bases</span><span class="special">,</span><span class="identifier"> dict</span><span class="special">)</span>
+            return</span><span class="identifier"> type</span><span class="special">.</span><span class="identifier">__init__</span><span class="special">(</span><span class="identifier">self</span><span class="special">,</span><span class="identifier"> name</span><span class="special">,</span><span class="identifier"> bases</span><span class="special">,</span><span class="identifier"> dict</span><span class="special">)</span><span class="comment">
 
-#<span class="identifier"> inject</span><span class="identifier"> some</span><span class="identifier"> methods</span><span class="identifier"> in</span><span class="identifier"> the</span><span class="identifier"> point</span><span class="identifier"> foo</span><span class="keyword">
-class</span><span class="identifier"> more_point</span><span class="special">(</span><span class="identifier">injector</span><span class="special">,</span><span class="identifier"> point</span><span class="special">):</span><span class="identifier">
+# inject some methods in the point foo
+</span><span class="keyword">class</span><span class="identifier"> more_point</span><span class="special">(</span><span class="identifier">injector</span><span class="special">,</span><span class="identifier"> point</span><span class="special">):</span><span class="keyword">
     def</span><span class="identifier"> __repr__</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span><span class="keyword">
-        return</span><span class="char"> 'Point(x=%s, y=%s)'</span><span class="special"> %</span><span class="special"> (</span><span class="identifier">self</span><span class="special">.</span><span class="identifier">x</span><span class="special">,</span><span class="identifier"> self</span><span class="special">.</span><span class="identifier">y</span><span class="special">)</span><span class="identifier">
-    def</span><span class="identifier"> foo</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span><span class="identifier">
-        print</span><span class="char"> 'foo!'</span></tt></pre>
+        return</span><span class="string"> 'Point(x=%s, y=%s)'</span><span class="special"> %</span><span class="special"> (</span><span class="identifier">self</span><span class="special">.</span><span class="identifier">x</span><span class="special">,</span><span class="identifier"> self</span><span class="special">.</span><span class="identifier">y</span><span class="special">)</span><span class="keyword">
+    def</span><span class="identifier"> foo</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span><span class="keyword">
+        print</span><span class="string"> 'foo!'</span></tt></pre>
 <p>
 Now let's see how it got:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> print</span><span class="identifier"> point</span><span class="special">()</span><span class="identifier">
+<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="keyword"> print</span><span class="identifier"> point</span><span class="special">()</span><span class="identifier">
 Point</span><span class="special">(</span><span class="identifier">x</span><span class="special">=</span><span class="number">10</span><span class="special">,</span><span class="identifier"> y</span><span class="special">=</span><span class="number">10</span><span class="special">)</span><span class="special">
 &gt;&gt;&gt;</span><span class="identifier"> point</span><span class="special">().</span><span class="identifier">foo</span><span class="special">()</span><span class="identifier">
 foo</span><span class="special">!</span></tt></pre>
 <p>
 Another useful idea is to replace constructors with factory functions:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">_point</span><span class="special"> =</span><span class="identifier"> point</span><span class="identifier">
+<pre class="programlisting"><tt class="literal"><span class="identifier">_point</span><span class="special"> =</span><span class="identifier"> point</span><span class="keyword">
 
 def</span><span class="identifier"> point</span><span class="special">(</span><span class="identifier">x</span><span class="special">=</span><span class="number">0</span><span class="special">,</span><span class="identifier"> y</span><span class="special">=</span><span class="number">0</span><span class="special">):</span><span class="keyword">
     return</span><span class="identifier"> _point</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span><span class="identifier"> y</span><span class="special">)</span></tt></pre>
@@ -289,16 +284,14 @@ with virtually zero memory footprint and zero compile-time overhead for
 the keyword support.</p>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.reducing_compiling_time"></a>Reducing Compiling Time</h3></div></div>
-<div></div>
-</div>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.reducing_compiling_time"></a>Reducing Compiling Time</h3></div></div></div>
 <p>
 If you have ever exported a lot of classes, you know that it takes quite a good
 time to compile the Boost.Python wrappers. Plus the memory consumption can
 easily become too high. If this is causing you problems, you can split the
 class_ definitions in multiple files:</p>
+<p></p>
 <pre class="programlisting"><tt class="literal"><span class="comment">/* file point.cpp */</span><span class="preprocessor">
 #include</span><span class="special"> &lt;</span><span class="identifier">point</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span><span class="preprocessor">
 #include</span><span class="special"> &lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span><span class="keyword">
@@ -347,14 +340,14 @@ exporting it to Python at the same time: changes in a class will only demand
 the compilation of a single cpp, instead of the entire wrapper code.</p>
 <div class="informaltable"><table class="table">
 <colgroup><col></colgroup>
-<tbody><tr><td>
+<tbody><tr><td class="blurb">
 <span class="inlinemediaobject"><img src="../images/note.png"></span> If you're exporting your classes with <a href="../../../../../pyste/index.html" target="_top">Pyste</a>,
 take a look at the <tt class="literal">--multiple</tt> option, that generates the wrappers in
 various files as demonstrated here.</td></tr></tbody>
 </table></div>
 <div class="informaltable"><table class="table">
 <colgroup><col></colgroup>
-<tbody><tr><td>
+<tbody><tr><td class="blurb">
 <span class="inlinemediaobject"><img src="../images/note.png"></span> This method is useful too if you are getting the error message
 <span class="emphasis"><em>"fatal error C1204:Compiler limit:internal structure overflow"</em></span> when compiling
 a large source file, as explained in the <a href="../../../../v2/faq.html#c1204" target="_top">FAQ</a>.</td></tr></tbody>
@@ -363,7 +356,7 @@ a large source file, as explained in the <a href="../../../../v2/faq.html#c1204"
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2004 Joel de Guzman, David Abrahams</small></td>
+<td align="right"><small>Copyright © 2002-2005 Joel de Guzman, David Abrahams</small></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">

doc/v2/Apr2002.html

@@ -158,6 +158,6 @@ documentation).
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
+  2002. </i></p>
 </body>
 </html>

doc/v2/CallPolicies.html

@@ -113,7 +113,7 @@
         "ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a>.</td>
 
         <td>An MPL unary <a href=
-        "../../../mpl/doc/paper/html/usage.html#metafunctions.classes">Metafunction
+        "../../../mpl/doc/refmanual/metafunction-class.html">Metafunction
         Class</a> used produce the "preliminary" result object.</td>
       </tr>
 
@@ -141,8 +141,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
 
     <p>Permission to copy, use, modify, sell and distribute this software is
     granted provided this copyright notice appears in all copies. This

doc/v2/Dereferenceable.html

@@ -61,7 +61,7 @@ type <code>T</code>.  In addition, all pointers are Dereferenceable.
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002-2003. All Rights Reserved.</i>
+    Abrahams</a> 2002-2003. </i>
 
 <p>Permission to copy, use, modify, sell
  and distribute this software is granted provided this copyright notice appears

doc/v2/Extractor.html

@@ -83,7 +83,7 @@ are layout-compatible with PyObject.
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. All Rights Reserved.</i>
+    Abrahams</a> 2002. </i>
 
 <p>Permission to copy, use, modify, sell
  and distribute this software is granted provided this copyright notice appears

doc/v2/HolderGenerator.html

@@ -61,7 +61,7 @@ type.
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. All Rights Reserved.</i>
+    Abrahams</a> 2002. </i>
 
 <p>Permission to copy, use, modify, sell
  and distribute this software is granted provided this copyright notice appears

doc/v2/Jun2002.html

@@ -221,6 +221,6 @@ you'll just have to wait till next month (hopefully the beginning).
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
+  2002. </i></p>
 </body>
 </html>

doc/v2/Mar2002.html

@@ -229,6 +229,6 @@ worth doing anything about it.
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
+  2002. </i></p>
 </body>
 </html>

doc/v2/May2002.html

@@ -303,6 +303,6 @@ to these issues will probably have to be formalized before long.
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
+  2002. </i></p>
 </body>
 </html>

doc/v2/ObjectWrapper.html

@@ -144,13 +144,7 @@ instances of the associated Python type will be considered a match.
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
-
-    <p>Permission to copy, use, modify, sell and distribute this software is
-    granted provided this copyright notice appears in all copies. This
-    software is provided "as is" without express or implied warranty, and
-    with no claim as to its suitability for any purpose.</p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/ResultConverter.html

@@ -100,7 +100,7 @@ C++ function return type.
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. All Rights Reserved.</i>
+    Abrahams</a> 2002. </i>
 
 <p>Permission to copy, use, modify, sell
  and distribute this software is granted provided this copyright notice appears

doc/v2/acknowledgments.html

@@ -126,8 +126,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/args.html

@@ -190,8 +190,7 @@ BOOST_PYTHON_MODULE(xxx)
     <p>Revised 01 August, 2003</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002-2003. All
-    Rights Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002-2003.</i></p>
   </body>
 </html>
 

doc/v2/bibliography.html

@@ -1,32 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../boost.css">
-<title>Boost.Python - Bibliography</title>
-</head>
-<body link="#0000ff" vlink="#800080">
-<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
-    "header">
-  <tr> 
-    <td valign="top" width="300"> 
-          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
-          "C++ Boost" src="../../../../boost.png" border="0"></a></h3>
-    </td>
-    <td valign="top"> 
-      <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
-      <h2 align="center">Bibliography</h2>
-    </td>
-  </tr>
-</table>
-<hr>
-{{bibliographical information}}
-<hr>
-<p>Revised 
-  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  13 November, 2002
-  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-</p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
-</body>
-</html>

doc/v2/call.html

@@ -77,6 +77,6 @@ double apply2(PyObject* func, double x, double y)
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
+  2002. </i></p>
 </body>
 </html>

doc/v2/call_method.html

@@ -152,8 +152,7 @@ BOOST_PYTHON_MODULE(my_module)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/callbacks.html

@@ -79,7 +79,7 @@ call_method&lt;ResultType&gt;(self_object, "<i>method-name</i>", a1, a2... a<i>N
     the arguments <code>a1</code>...<code>a<i>N</i></code> are copied into
     new Python objects, but this behavior can be overridden by the use of
     <code><a href="ptr.html#ptr-spec">ptr()</a></code> and <a href=
-    "../../../bind/ref.html#reference_wrapper">ref()</a>:</p>
+    "../../../bind/ref.html">ref()</a>:</p>
 <pre>
 class X : boost::noncopyable
 {
@@ -128,7 +128,7 @@ void apply(PyObject* callable, X&amp; x)
 
       <tr>
         <td><code><a href=
-        "../../../bind/ref.html#reference_wrapper">boost::reference_wrapper</a>&lt;T&gt;</code></td>
+        "../../../bind/ref.html">boost::reference_wrapper</a>&lt;T&gt;</code></td>
 
         <td>The Python argument contains a pointer to, rather than a copy of,
         <code>x.get()</code>. Note: failure to ensure that no Python code
@@ -245,8 +245,7 @@ void apply(PyObject* callable, X&amp; x)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/configuration.html

@@ -146,8 +146,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/copy_const_reference.html

@@ -140,8 +140,7 @@ BOOST_PYTHON_MODULE(my_module)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/copy_non_const_reference.html

@@ -140,8 +140,7 @@ BOOST_PYTHON_MODULE(my_module)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/data_members.html

@@ -220,8 +220,7 @@ BOOST_PYTHON_MODULE_INIT(data_members_example)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/def.html

@@ -182,8 +182,7 @@ BOOST_PYTHON_MODULE(def_test)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/def_visitor.html

@@ -132,4 +132,4 @@ BOOST_PYTHON_MODULE(my_ext)
   </p>
 
 
-    <p><i>&copy; Copyright Joel de Guzman 2003. All Rights Reserved.</i>
+    <p><i>&copy; Copyright Joel de Guzman 2003. </i>

doc/v2/default_call_policies.html

@@ -166,5 +166,5 @@ struct return_value_policy : Base
 
 
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. All Rights Reserved.</i>
+    Abrahams</a> 2002. </i>
 

doc/v2/definitions.html

@@ -93,8 +93,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/dict.html

@@ -143,8 +143,7 @@ dict swap_object_dict(object target, dict d)
     <p>Revised 30 September, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/enum.html

@@ -225,8 +225,7 @@ TypeError: bad argument type for built-in operation
      
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/errors.html

@@ -107,7 +107,7 @@ void handle_exception() throw();
     <dl class="handle_exception-semantics">
       <dt><b>Requires:</b> The first form requires that the expression
       <code><a href=
-      "../../../function/doc/reference.html#functionN">function0</a>&lt;void&gt;(f)</code>
+      "../../../../doc/html/functionN.html">function0</a>&lt;void&gt;(f)</code>
       is valid. The second form requires that a C++ exception is currently
       being handled (see section 15.1 in the C++ standard).</dt>
 
@@ -126,7 +126,7 @@ void handle_exception() throw();
 
       <dt><b>Rationale:</b> At inter-language boundaries it is important to
       ensure that no C++ exceptions escape, since the calling language
-      usually doesn't have the equipment neccessary to properly unwind the
+      usually doesn't have the equipment necessary to properly unwind the
       stack. Use <code>handle_exception</code> to manage exception
       translation whenever your C++ code is called directly from the Python
       API. This is done for you automatically by the usual function wrapping
@@ -134,7 +134,7 @@ void handle_exception() throw();
       "make_function.html#make_function-spec">make_function</a>()</code>,
       <code><a href=
       "make_function.html#make_constructor-spec">make_constructor</a>()</code>,
-      <code><a href="def.html#def-spec">def</a>()</code> and <code><a href=
+      <code><a href="def.html#class_-spec-modifiers">def</a>()</code> and <code><a href=
       "class.html#def-spec">class_::def</a>()</code>. The second form can be
       more convenient to use (see the <a href="#examples">example</a> below),
       but various compilers have problems when exceptions are rethrown from
@@ -280,8 +280,7 @@ same_name2(PyObject* args, PyObject* keywords)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/exception_translator.html

@@ -141,8 +141,7 @@ BOOST_PYTHON_MODULE(exception_translator_ext)
     <p>Revised 03 October, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/extract.html

@@ -223,8 +223,7 @@ BOOST_PYTHON_MODULE(extract_ext)
     <p>Revised 15 November, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/faq.html

@@ -649,14 +649,14 @@ void b_insert(B& b, std::auto_ptr<A> a)
     <h2><a name="slow_compilation">Compilation takes too much time and eats too
             much memory!  What can I do to make it faster?</a></h2>
     <p>
-    Please refer to the <a href="../tutorial/doc/reducing_compiling_time.html"
+    Please refer to the <a href="../tutorial/doc/html/python/techniques.html#python.reducing_compiling_time"
     >Reducing Compiling Time</a> section in the tutorial.
     </p>
 
     <hr>
     <h2><a name="packages">How do I create sub-packages using Boost.Python?</a></h2>
     <p>
-    Please refer to the <a href="../tutorial/doc/creating_packages.html"
+    Please refer to the <a href="../tutorial/doc/html/python/techniques.html#python.creating_packages"
     >Creating Packages</a> section in the tutorial.
     </p>
 
@@ -878,7 +878,6 @@ BOOST_PYTHON_MODULE(custom_string)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002-2003. All
-    Rights Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002-2003.</i></p>
   </body>
 </html>

doc/v2/feb2002.html

@@ -362,5 +362,5 @@
 
     <p class="c3">&copy; Copyright <a href= 
     "../../../../people/dave_abrahams.htm">Dave Abrahams</a>
-    2002. All Rights Reserved.
+    2002. 
 

doc/v2/from_python.html

@@ -1,165 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-    <meta name="generator" content="HTML Tidy, see www.w3.org">
-    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-    <link rel="stylesheet" type="text/css" href="../boost.css">
-
-    <title>Boost.Python - &lt;boost/python/from_python.hpp&gt;</title>
-
-    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
-    "header">
-      <tr>
-        <td valign="top" width="300">
-          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
-          "C++ Boost" src="../../../../boost.png" border="0"></a></h3>
-
-        <td valign="top">
-          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
-
-          <h2 align="center">Header &lt;boost/python/from_python.hpp&gt;</h2>
-    </table>
-    <hr>
-
-    <h2>Contents</h2>
-
-    <dl class="page-index">
-      <dt><a href="#introduction">Introduction</a>
-
-      <dt><a href="#classes">Classes</a>
-
-      <dd>
-        <dl class="page-index">
-          <dt><a href="#from_python-spec">Class
-          Template<code>from_python</code></a>
-
-          <dd>
-            <dl class="page-index">
-              <dt><a href="#from_python-spec-synopsis">Class Template
-              <code>from_python</code> synopsis</a>
-
-              <dt><a href="#from_python-spec-ctors">Class Template
-              <code>from_python</code> constructor</a>
-
-              <dt><a href="#from_python-spec-observers">Class Template
-              <code>from_python</code> observer functions</a>
-            </dl>
-        </dl>
-
-      <dt><a href="#examples">Example</a>
-    </dl>
-    <hr>
-
-    <h2><a name="introduction"></a>Introduction</h2>
-
-    <p><code>&lt;boost/python/from_python.hpp&gt;</code> introduces a class
-    template <code>from_python&lt;T&gt;</code> for extracting a C++ object of
-    type <code>T</code> from a Python object.
-
-    <h2><a name="classes"></a>Classes</h2>
-
-    <h3><a name="from_python-spec"></a>Class Template
-    <code>from_python&lt;class T&gt;</code></h3>
-
-    <p><code>from_python&lt;T&gt;</code> is the type used internally by
-    Boost.Python to extract C++ function arguments from a Python argument tuple
-    when calling a wrapped function. It can also be used directly to make
-    similar conversions in other contexts.
-
-    <h4><a name="from_python-spec-synopsis"></a>Class Template
-    <code>from_python</code> synopsis</h4>
-<pre>
-namespace boost { namespace python
-{
-   template &lt;class T&gt;
-   struct from_python : private <a href=
-"../../../utility/utility.htm#Class_noncopyable">boost::noncopyable</a> // Exposition only.
-       // from_python&lt;T&gt; meets the NonCopyable requirements
-   {
-      from_python(PyObject*);
-      bool convertible() const;
-      <i>convertible-to-T</i> operator()(PyObject*) const;
-   };
-}
-</pre>
-
-    <h4><a name="from_python-spec-ctors"></a>Class Template
-    <code>from_python</code> constructor</h4>
-<pre>
-from_python(PyObject* p);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> <code>p != 0</code>
-
-      <dt><b>Effects:</b> Constructs a <code>from_python</code> object suitable
-      for extracting a C++ object of type <code>T</code> from <code>p</code>.
-    </dl>
-
-    <h4><a name="from_python-spec-observers"></a>Class Template
-    <code>from_python</code> observer functions</h4>
-<pre>
-bool convertible() const;
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Returns:</b> <code>false</code> if the conversion cannot succeed.
-      This indicates that either:
-
-      <dd>
-        <ol>
-          <li>No <code>from_python_converter</code> was registered for
-          <code>T</code>, or
-
-          <li>any such converter rejected the constructor argument
-          <code>p</code> by returning <code>0</code> from its
-          <code>convertible()</code> function
-        </ol>
-        Note that conversion may still fail in <code>operator()</code> due to
-        an exception. 
-
-      <dt><b>Throws:</b> nothing
-
-      <dt><b>Rationale:</b> Because <code>from_python&lt;&gt;</code> is used in
-      overload resolution, and throwing an exception can be slow, it is useful
-      to be able to rule out a broad class of unsuccessful conversions without
-      throwing an exception.
-    </dl>
-<pre>
-<i>convertible-to-T</i> operator()(PyObject* p) const;
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> <code>*p</code> refers to the same object which was
-      passed to the constructor, and <code>convertible()</code> returns
-      <code>true</code>.
-
-      <dt><b>Effects:</b> performs the conversion
-
-      <dt><b>Returns:</b> an object convertible to <code>T</code>.
-    </dl>
-
-    <h2><a name="examples"></a>Example</h2>
-<pre>
-#include &lt;string&gt;
-#include &lt;boost/python/from_python.hpp&gt;
-
-// If a std::string can be extracted from p, return its
-// length. Otherwise, return 0.
-std::size_t length_if_string(PyObject* p)
-{
-   from_python&lt;std::string&gt; converter(p);
-   if (!converter.convertible())
-      return 0;
-   else
-      return converter(p).size();
-}
-</pre>
-
-    <p>Revised 
-    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  13 November, 2002
-  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-
-
-    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. All Rights Reserved.</i>
-

doc/v2/handle.html

@@ -326,8 +326,8 @@ null_ok<T>* allow_null(T* p)
     </p>
 
     <p class="c4">&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002
+.</p>
   </body>
 </html>
 

doc/v2/has_back_reference.html

@@ -86,7 +86,7 @@ namespace boost { namespace python
     };
 }}
 </pre>
-    <p>A "<a href="../../../mpl/doc/paper/html/usage.html#metafunctions">
+    <p>A "<a href="../../../mpl/doc/refmanual/metafunction.html">
     metafunction</a>" that is inspected by Boost.Python to determine how 
     wrapped classes can be constructed.</p>
 
@@ -215,8 +215,8 @@ BOOST_PYTHON_MODULE(back_references)
     </p>
 
     <p class="c3">&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002
+.</p>
   </body>
 </html>
 

doc/v2/header.html

@@ -1,288 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-    <meta name="generator" content="HTML Tidy, see www.w3.org">
-    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-    <link rel="stylesheet" type="text/css" href="../boost.css">
-
-    <title>Boost.Python - &lt;{{header}}&gt;</title>
-
-    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
-    "header">
-      <tr>
-        <td valign="top" width="300">
-          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
-          "C++ Boost" src="../../../../boost.png" border="0"></a></h3>
-
-        <td valign="top">
-          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
-
-          <h2 align="center">Header &lt;{{header}}&gt;</h2>
-    </table>
-    <hr>
-
-    <h2>Contents</h2>
-
-    <dl class="page-index">
-      <dt><a href="#introduction">Introduction</a>
-
-      <dt><a href="#macros">Macros</a>
-
-      <dd>
-        <dl class="page-index">
-          <dt><a href="#macro-spec">{{macro name}}</a>
-        </dl>
-
-      <dt><a href="#values">Values</a>
-
-      <dd>
-        <dl class="page-index">
-          <dt><a href="#value-spec">{{value name}}</a>
-        </dl>
-
-      <dt><a href="#types">Types</a>
-
-      <dd>
-        <dl class="page-index">
-          <dt><a href="#type-spec">{{type name}}</a>
-        </dl>
-
-      <dt><a href="#classes">Classes</a>
-
-      <dd>
-        <dl class="page-index">
-          <dt><a href="#class-spec">Class <code>{{name}}</code></a>
-
-          <dd>
-            <dl class="page-index">
-              <dt><a href="#class-spec-synopsis">Class <code>{{name}}</code> synopsis</a>
-
-              <dt><a href="#class-spec-ctors">Class <code>{{name}}</code>
-              constructors and destructor</a>
-
-              <dt><a href="#class-spec-comparisons">Class <code>{{name}}</code> comparison functions</a>
-
-              <dt><a href="#class-spec-modifiers">Class <code>{{name}}</code> modifier functions</a>
-
-              <dt><a href="#class-spec-observers">Class <code>{{name}}</code> observer functions</a>
-
-              <dt><a href="#class-spec-statics">Class <code>{{name}}</code> static functions</a>
-            </dl>
-        </dl>
-
-      <dt><a href="#functions">Functions</a>
-
-      <dd>
-        <dl class="page-index">
-          <dt><a href="#function-spec">{{function name}}</a>
-        </dl>
-
-      <dt><a href="#objects">Objects</a>
-
-      <dd>
-        <dl class="page-index">
-          <dt><a href="#object-spec">{{object name}}</a>
-        </dl>
-
-      <dt><a href="#examples">Example(s)</a>
-    </dl>
-    <hr>
-
-    <h2><a name="introduction"></a>Introduction</h2>
-
-    <p>{{Introductory text}}
-
-    <h2><a name="macros"></a>Macros</h2>
-
-    <p><a name="macro-spec"></a>{{Macro specifications}}
-
-    <h2><a name="values"></a>Values</h2>
-
-    <p><a name="value-spec"></a>{{Value specifications}}
-
-    <h2><a name="types"></a>Types</h2>
-
-    <p><a name="type-spec"></a>{{Type specifications}}
-
-    <h2><a name="classes"></a>Classes</h2>
-
-    <h3><a name="class-spec"></a>Class <code>{{name}}</code></h3>
-
-    <p>{{class overview text}}
-
-    <h4><a name="class-spec-synopsis"></a>Class <code>{{name}}</code> synopsis</h4>
-<pre>
-namespace boost
-{
-    class {{name}}
-  {
-  };
-};
-</pre>
-
-    <h4><a name="class-spec-ctors"></a>Class <code>{{name}}</code> constructors and
-    destructor</h4>
-<pre>
-{{constructor}}
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> {{text}}
-
-      <dt><b>Effects:</b> {{text}}
-
-      <dt><b>Postconditions:</b> {{text}}
-
-      <dt><b>Returns:</b> {{text}}
-
-      <dt><b>Throws:</b> {{text}}
-
-      <dt><b>Complexity:</b> {{text}}
-
-      <dt><b>Rationale:</b> {{text}}
-    </dl>
-<pre>
-{{destructor}}
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> {{text}}
-
-      <dt><b>Effects:</b> {{text}}
-
-      <dt><b>Postconditions:</b> {{text}}
-
-      <dt><b>Returns:</b> {{text}}
-
-      <dt><b>Throws:</b> {{text}}
-
-      <dt><b>Complexity:</b> {{text}}
-
-      <dt><b>Rationale:</b> {{text}}
-    </dl>
-
-    <h4><a name="class-spec-comparisons"></a>Class <code>{{name}}</code> comparison
-    functions</h4>
-<pre>
-{{function}}
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> {{text}}
-
-      <dt><b>Effects:</b> {{text}}
-
-      <dt><b>Postconditions:</b> {{text}}
-
-      <dt><b>Returns:</b> {{text}}
-
-      <dt><b>Throws:</b> {{text}}
-
-      <dt><b>Complexity:</b> {{text}}
-
-      <dt><b>Rationale:</b> {{text}}
-    </dl>
-
-    <h4><a name="class-spec-modifiers"></a>Class <code>{{name}}</code> modifier
-    functions</h4>
-<pre>
-{{function}}
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> {{text}}
-
-      <dt><b>Effects:</b> {{text}}
-
-      <dt><b>Postconditions:</b> {{text}}
-
-      <dt><b>Returns:</b> {{text}}
-
-      <dt><b>Throws:</b> {{text}}
-
-      <dt><b>Complexity:</b> {{text}}
-
-      <dt><b>Rationale:</b> {{text}}
-    </dl>
-
-    <h4><a name="class-spec-observers"></a>Class <code>{{name}}</code> observer
-    functions</h4>
-<pre>
-{{function}}
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> {{text}}
-
-      <dt><b>Effects:</b> {{text}}
-
-      <dt><b>Postconditions:</b> {{text}}
-
-      <dt><b>Returns:</b> {{text}}
-
-      <dt><b>Throws:</b> {{text}}
-
-      <dt><b>Complexity:</b> {{text}}
-
-      <dt><b>Rationale:</b> {{text}}
-    </dl>
-
-    <h4><a name="class-spec-statics"></a>Class <code>{{name}}</code> static functions</h4>
-<pre>
-{{function}}
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> {{text}}
-
-      <dt><b>Effects:</b> {{text}}
-
-      <dt><b>Postconditions:</b> {{text}}
-
-      <dt><b>Returns:</b> {{text}}
-
-      <dt><b>Throws:</b> {{text}}
-
-      <dt><b>Complexity:</b> {{text}}
-
-      <dt><b>Rationale:</b> {{text}}
-    </dl>
-
-    <h2><a name="functions"></a>Functions</h2>
-<pre>
-
-
-<a name="function-spec"></a>{{function}}
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> {{text}}
-
-      <dt><b>Effects:</b> {{text}}
-
-      <dt><b>Postconditions:</b> {{text}}
-
-      <dt><b>Returns:</b> {{text}}
-
-      <dt><b>Throws:</b> {{text}}
-
-      <dt><b>Complexity:</b> {{text}}
-
-      <dt><b>Rationale:</b> {{text}}
-    </dl>
-
-    <h2><a name="objects"></a>Objects</h2>
-
-    <p><a name="object-spec"></a>{{Object specifications}}
-
-    <h2><a name="examples"></a>Example(s)</h2>
-
-    <p>{{Example(s)}}
-
-    <p>Revised 
-    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  13 November, 2002
-  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-
-
-    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. All Rights Reserved.</i>
-

doc/v2/implicit.html

@@ -154,8 +154,7 @@ BOOST_PYTHON_MODULE(implicit_ext)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/init.html

@@ -109,7 +109,7 @@
     <i>unspecified</i><code>,</code>...<code>Tn</code> =
     <i>unspecified</i><code>&gt;</code></h3>
 
-    <p>A <a href="../../../mpl/doc/ref/Sequences.html">MPL sequence</a> which
+    <p>A <a href="../../../mpl/doc/refmanual/forward-sequence.html">MPL sequence</a> which
     can be used to specify a family of one or more <code>__init__</code>
     functions. Only the last <code>T</code><i><small>i</small></i> supplied
     may be an instantiation of <a href=
@@ -195,7 +195,7 @@ template &lt;class Policies&gt;
     <i>unspecified</i><code>,</code>...<code>Tn</code> =
     <i>unspecified</i><code>&gt;</code></h3>
 
-    <p>A <a href="../../../mpl/doc/ref/Sequences.html">MPL sequence</a> which
+    <p>A <a href="../../../mpl/doc/refmanual/forward-sequence.html">MPL sequence</a> which
     can be used to specify the optional arguments to an <code>__init__</code>
     function.</p>
 
@@ -242,8 +242,7 @@ class_&lt;X&gt;("X", "This is X's docstring.",
      
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/instance_holder.html

@@ -1,11 +1,16 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+
+<html>
+  <head>
     <meta name="generator" content="HTML Tidy, see www.w3.org">
     <meta http-equiv="Content-Type" content=
     "text/html; charset=iso-8859-1">
     <link rel="stylesheet" type="text/css" href="../boost.css">
 
     <title>Boost.Python - &lt;boost/python/instance_holder.hpp&gt;</title>
+  </head>
+
 <style type="text/css">
  p.c4 {font-style: italic}
  span.c3 {color: #ff0000}
@@ -13,6 +18,7 @@
  h1.c1 {text-align: center}
 </style>
 
+  <body link="#0000ff" vlink="#800080">
     <table border="0" cellpadding="7" cellspacing="0" width="100%"
     summary="header">
       <tr>
@@ -204,6 +210,7 @@ struct pointer_holder : instance_holder
 
 
     <p class="c4">&copy; Copyright <a href= 
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All
-    Rights Reserved.
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. 
 
+  </body>
+</html>

doc/v2/iterator.html

@@ -45,7 +45,7 @@
               <dt><a href="#iterator-spec-synopsis">Class
               <code>iterator</code> synopsis</a></dt>
 
-              <dt><a href="#iterator-spec-ctors">Class template
+              <dt><a href="#iterator-spec-constructors">Class template
               <code>iterator</code> constructor</a></dt>
             </dl>
           </dd>
@@ -380,7 +380,8 @@ BOOST_PYTHON_MODULE(demo)
       <dt><code><a href=
       "../../test/iterator.py">libs/python/test/input_iterator.py</a></code></dt>
 
-      <dd>
+    </dl>
+<hr>
         <p>Revised 
         <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
   13 November, 2002
@@ -388,10 +389,7 @@ BOOST_PYTHON_MODULE(demo)
         </p>
 
         <p><i>&copy; Copyright <a href=
-        "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All
-        Rights Reserved.</i></p>
-      </dd>
-    </dl>
+        "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/list.html

@@ -133,8 +133,7 @@ long zeroes(list l)
     <p>Revised 1 October, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/long.html

@@ -110,8 +110,7 @@ python::long_ fact(long n)
     <p>Revised 1 October, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/lvalue_from_pytype.html

@@ -292,8 +292,7 @@ BOOST_PYTHON_MODULE(noddy_cache)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/make_function.html

@@ -99,7 +99,7 @@ template <class F, class Policies, class Keywords, class Signature>
       arguments of the resulting function.  
 <li>If <code>Signature</code>
       is supplied, it should be an instance of an <a
-      href="../../../mpl/doc/ref/Sequence.html">MPL front-extensible
+      href="../../../mpl/doc/refmanual/front-extensible-sequence.html">MPL front-extensible
       sequence</a> representing the function's return type followed by
       its argument types.  Pass a <code>Signature</code> when wrapping
       function object types whose signatures can't be deduced, or when
@@ -135,7 +135,7 @@ template &lt;class ArgList, class Generator, class Policies&gt;
       <dt><b>Requires:</b> <code>T</code> is a class type.
       <code>Policies</code> is a model of <a href=
       "CallPolicies.html">CallPolicies</a>. <code>ArgList</code> is an <a
-      href="../../../mpl/doc/ref/Sequences.html">MPL sequence</a> of C++ argument
+      href="../../../mpl/doc/refmanual/forward-sequence.html">MPL sequence</a> of C++ argument
       types (<i>A1,&nbsp;A2,...&nbsp;AN</i>) such that if
       <code>a1,&nbsp;a2</code>...&nbsp;<code>aN</code> are objects of type
       <i>A1,&nbsp;A2,...&nbsp;AN</i> respectively, the expression <code>new
@@ -201,8 +201,7 @@ BOOST_PYTHON_MODULE(make_function_test)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/manage_new_object.html

@@ -136,8 +136,7 @@ BOOST_PYTHON_MODULE(my_module)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/module.html

@@ -71,7 +71,7 @@ This macro generates two functions in the scope where it is used:
 and <code>void&nbsp;init_module_<i>name</i>()</code>, whose body must
 follow the macro invocation. <code>init_<i>name</i></code> passes
 <code>init_module_<i>name</i></code> to <code><a
-href="errors.html#handle_exception">handle_exception</a>()</code> so
+href="errors.html#handle_exception-spec">handle_exception</a>()</code> so
 that any C++ exceptions generated are safely processeed. During the
 body of <code>init_<i>name</i></code>, the current <code><a
 href="scope.html#scope-spec">scope</a></code> refers to the module
@@ -104,5 +104,5 @@ RuntimeError: Unidentifiable C++ Exception
 
 
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. All Rights Reserved.</i>
+    Abrahams</a> 2002. </i>
 

doc/v2/numeric.html

@@ -261,8 +261,7 @@ void set_first_element(numeric::array& y, double value)
     <p>Revised 03 October, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/object.html

@@ -186,7 +186,7 @@
         </dl>
 
         <dl class="page-index">
-          <dt><a href="#operators-spec">operators</a></dt>
+          <dt><a href="#object_operators-spec">operators</a></dt>
         </dl>
       </dd>
 
@@ -232,7 +232,7 @@ x[slice(_,_,-1)]
     <p>The policies which are used for proxies representing an attribute
     access to a <code>const&nbsp;object</code>.</p>
 
-    <h4><a name="class-spec-synopsis"></a>Class
+    <h4><a name="const_attribute_policies-spec-synopsis"></a>Class
     <code>const_attribute_policies</code> synopsis</h4>
 <pre>
 namespace boost { namespace python { namespace api
@@ -927,8 +927,7 @@ object sum_items(object seq)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/opaque_pointer_converter.html

@@ -123,7 +123,7 @@ explicit opaque_pointer_converter(char const* name);
 
     <h2><a name="examples"></a>Example</h2>
 
-        please see example for <a href="return_opaque_pointer.html#example">
+        please see example for <a href="return_opaque_pointer.html#examples">
           return_opaque_pointer</a>.
 
     <h2><a name="see-also"></a>See Also</h2>

doc/v2/operators.html

@@ -57,7 +57,7 @@
               <dt><a href="#self_t-spec-value-unary-ops">Class
               <code>self_t</code> unary operations</a></dt>
 
-              <dt><a href="#self_t-spec-value-value-ops">Class
+              <dt><a href="#self_t-spec-value-ops">Class
               <code>self_t</code> value operations</a></dt>
             </dl>
           </dd>
@@ -900,8 +900,7 @@ BOOST_PYTHON_MODULE(demo)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/overloads.html

@@ -190,7 +190,7 @@ struct X
     Y inner;
 };
 
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(X_f_overloads, X::f, 1, 3)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(f_member_overloads, f, 1, 3)
 
 BOOST_PYTHON_MODULE(args_ext)
 {
@@ -205,7 +205,7 @@ BOOST_PYTHON_MODULE(args_ext)
             
     class_<X>("X", "This is X's docstring")
         .def("f1", &X::f, 
-                X_f_overloads(
+                f_member_overloads(
                     args("x", "y", "z"), "f's docstring"
                 )[return_internal_reference<>()]
         )
@@ -220,8 +220,7 @@ BOOST_PYTHON_MODULE(args_ext)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/overview.html

@@ -1,48 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../boost.css">
-<title>Boost.Python - Overview</title>
-</head>
-<body link="#0000ff" vlink="#800080">
-<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
-    "header">
-  <tr> 
-    <td valign="top" width="300"> 
-          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
-          "C++ Boost" src="../../../../boost.png" border="0"></a></h3>
-    </td>
-    <td valign="top"> 
-      <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
-      <h2 align="center">Overview</h2>
-    </td>
-  </tr>
-</table>
-<hr>
-<dl class="index">
-  <dt><a href="#introduction">Introduction</a></dt>
-  <dt><a href="#topic1">First topic</a></dt>
-  <dt><a href="#topic2">Second topic</a></dt>
-  <dt><a href="#footnotes">Footnotes</a></dt>
-</dl>
-<h2><a name="introduction"></a>Introduction</h2>
-<p>{{text}}</p>
-<h2><a name="topic1"></a>First Topic</h2>
-<p>{{text}}</p>
-<h2><a name="topic2"></a>Second Topic</h2>
-<p>{{text}}</p>
-<h2><a name="footnotes"></a>Footnotes</h2>
-<dl>
-  <dt><a name="footnote1" class="footnote">(1)</a> {{text}}</dt>
-  <dt><a name="footnote2" class="footnote">(2)</a> {{text}}</dt>
-</dl>
-<hr>
-<p>Revised 
-  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  13 November, 2002
-  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-</p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
-</body>
-</html>

doc/v2/pickle.html

@@ -315,7 +315,7 @@ class we make all instances pickleable:
 </pre>
 
 See also the
-<a href="../tutorial/doc/extending_wrapped_objects_in_python.html"
+<a href="../tutorial/doc/html/python/techniques.html#python.extending_wrapped_objects_in_python"
 >tutorial section</a> on injecting additional methods from Python.
 
 <hr>

doc/v2/platforms.html

@@ -51,13 +51,11 @@
               3.1, and 3.2 on <a href="http://www.redhat.com">RedHat Linux 7.3</a>
               for Intel x86</dt>
 
-              <dt><a href=
-              "http://www.tru64unix.compaq.com/cplus/index.html">Tru64 CXX
-              6.5.1</a> on OSF v. 5.1 for Dec/Compaq Alpha</dt>
+              <dt>Tru64 CXX 6.5.1 on OSF v. 5.1 for Dec/Compaq
+              Alpha</dt>
 
-              <dt><a href=
-              "http://www.sgi.com/developers/devtools/languages/mipspro.html">
-              MIPSPro 7.3.1.2m</a> on <a href=
+              <dt>
+              MIPSPro 7.3.1.2m on <a href=
               "http://www.sgi.com/software/irix6.5/">IRIX 6.5</a> for SGI
               mips</dt>
 
@@ -70,21 +68,16 @@
 
           <dd>
             <dl>
-              <dt><a href=
-              "http://developer.intel.com/software/products/kcc/">KCC
-              3.4d</a> on OSF v. 5.1 for Dec/Compaq Alpha</dt>
+              <dt>KCC 3.4d on OSF v. 5.1 for Dec/Compaq Alpha</dt>
 
-              <dt><a href=
-              "http://developer.intel.com/software/products/kcc/">KCC
-              3.4d</a> on AIX</dt>
+              <dt>KCC 3.4d</a> on AIX</dt>
             </dl>
           </dd>
         </dl>
         <br>
       </dd>
 
-      <dt><a href="http://www.microsoft.com/windowsxp/default.asp">Microsoft
-      Windows XP Professional</a> with Python <a href=
+      <dt>Microsoft Windows XP Professional with Python <a href=
       "http://www.python.org/2.2">2.2</a>, <a href=
       "http://www.python.org/2.2.1">2.2.1</a>, and <a href=
       "http://www.python.org/2.2.2">2.2.2b1</a>:</dt>
@@ -133,8 +126,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/pointee.html

@@ -45,8 +45,8 @@
 
     <p><code>&lt;boost/python/pointee.hpp&gt;</code> introduces a
     traits <a
-    href="../../../mpl/doc/index.html#metafunctions">metafunction</a>
-    template <code>pointee&lt;T&gt;</code> which can be used to extract the &quot;pointed-to&quot; type from the type of a pointer or smart pointer.
+    href="../../../mpl/doc/refmanual/metafunction.html">metafunction</a>
+    template <code>pointee&lt;T&gt;</code> that can be used to extract the &quot;pointed-to&quot; type from the type of a pointer or smart pointer.
 
     <h2><a name="classes"></a>Classes</h2>
 
@@ -112,5 +112,5 @@ BOOST_PYTHON_MODULE(pointee_demo)
 
 
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. All Rights Reserved.</i>
+    Abrahams</a> 2002. </i>
 

doc/v2/progress_reports.html

@@ -39,6 +39,6 @@ design decisions and links to relevant discussions.
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
+  2002. </i></p>
 </body>
 </html>

doc/v2/ptr.html

@@ -259,5 +259,5 @@ void pass_as_arg(expensive_to_copy* x, PyObject* f)
 
 
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. All Rights Reserved.</i>
+    Abrahams</a> 2002. </i>
 

doc/v2/python.html

@@ -101,8 +101,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/rationale.html

@@ -1,48 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../boost.css">
-<title>Boost.Python - Rationale</title>
-</head>
-<body link="#0000ff" vlink="#800080">
-<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
-    "header">
-  <tr> 
-    <td valign="top" width="300"> 
-          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
-          "C++ Boost" src="../../../../boost.png" border="0"></a></h3>
-    </td>
-    <td valign="top"> 
-      <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
-      <h2 align="center">Rationale</h2>
-    </td>
-  </tr>
-</table>
-<hr>
-<dl class="index">
-  <dt><a href="#introduction">Introduction</a></dt>
-  <dt><a href="#topic1">First topic</a></dt>
-  <dt><a href="#topic2">Second topic</a></dt>
-  <dt><a href="#footnotes">Footnotes</a></dt>
-</dl>
-<h2><a name="introduction"></a>Introduction</h2>
-<p>{{text}}</p>
-<h2><a name="topic1"></a>First Topic</h2>
-<p>{{text}}</p>
-<h2><a name="topic2"></a>Second Topic</h2>
-<p>{{text}}</p>
-<h2><a name="footnotes"></a>Footnotes</h2>
-<dl>
-  <dt><a name="footnote1" class="footnote">(1)</a> {{text}}</dt>
-  <dt><a name="footnote2" class="footnote">(2)</a> {{text}}</dt>
-</dl>
-<hr>
-<p>Revised 
-  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  13 November, 2002
-  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-</p>
-<p><i>&copy; Copyright <a href="../../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
-</body>
-</html>

doc/v2/raw_function.html

@@ -109,8 +109,7 @@ Python:
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/reference.html

@@ -13,7 +13,7 @@
  p.c3 {font-style: italic}
  h2.c2 {text-align: center}
  h1.c1 {text-align: center}
-                                        </style>
+                                            </style>
   </head>
 
   <body>
@@ -76,7 +76,7 @@
       <dt><a href=
       "Dereferenceable.html#Dereferenceable-concept">Dereferenceable</a></dt>
 
-      <dt><a href="Dereferenceable.html#Extractor-concept">Extractor</a></dt>
+      <dt><a href="Extractor.html#Extractor-concept">Extractor</a></dt>
 
       <dt><a href=
       "HolderGenerator.html#HolderGenerator-concept">HolderGenerator</a></dt>
@@ -96,158 +96,217 @@
 
     <h2><a name="high_level">High Level Components</a></h2>
 
-    
-<dl>
-  <dt><a href="class.html">class.hpp/class_fwd.hpp</a></dt>
-  <dd> 
-    <dl class="index">
-      <dt><a href="class.html#classes">Classes</a></dt>
-      <dd> 
+    <dl>
+      <dt><a href="class.html">class.hpp/class_fwd.hpp</a></dt>
+
+      <dd>
         <dl class="index">
-          <dt><a href="class.html#class_-spec">class_</a></dt>
-          <dt><a href="class.html#bases-spec">bases</a></dt>
+          <dt><a href="class.html#classes">Classes</a></dt>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="class.html#class_-spec">class_</a></dt>
+
+              <dt><a href="class.html#bases-spec">bases</a></dt>
+            </dl>
+          </dd>
         </dl>
       </dd>
-    </dl>
-  </dd>
-  <dt><a href="def.html">def.hpp</a></dt>
-  <dd> 
-    <dl class="index">
-      <dt><a href="def.html#functions">Functions</a></dt>
-      <dd> 
-        <dl class="page-index">
-          <dt><a href="def.html#def-spec">def</a></dt>
+
+      <dt><a href="def.html">def.hpp</a></dt>
+
+      <dd>
+        <dl class="index">
+          <dt><a href="def.html#functions">Functions</a></dt>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="def.html#def-spec">def</a></dt>
+            </dl>
+          </dd>
         </dl>
       </dd>
-    </dl>
-  </dd>
-  <dt><a href="def_visitor.html">def_visitor.hpp</a></dt>
-  <dd> 
-    <dl class="index">
-      <dt><a href="def_visitor.html#classes">Classes</a></dt>
-    </dl>
-  </dd>
-  <dt><a href="enum.html">enum.hpp</a></dt>
-  <dd> 
-    <dl class="index">
-      <dt><a href="enum.html#classes">Classes</a></dt>
-      <dd> 
+
+      <dt><a href="def_visitor.html">def_visitor.hpp</a></dt>
+
+      <dd>
         <dl class="index">
-          <dt><a href="enum.html#enum_-spec">enum_</a></dt>
+          <dt><a href="def_visitor.html#classes">Classes</a></dt>
         </dl>
       </dd>
-    </dl>
-  </dd>
-  <dt><a href="errors.html">errors.hpp</a></dt>
-  <dd> 
-    <dl class="index">
-      <dt><a href="errors.html#classes">Classes</a></dt>
-      <dd> 
+
+      <dt><a href="enum.html">enum.hpp</a></dt>
+
+      <dd>
         <dl class="index">
-          <dt><a href=
+          <dt><a href="enum.html#classes">Classes</a></dt>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="enum.html#enum_-spec">enum_</a></dt>
+            </dl>
+          </dd>
+        </dl>
+      </dd>
+
+      <dt><a href="errors.html">errors.hpp</a></dt>
+
+      <dd>
+        <dl class="index">
+          <dt><a href="errors.html#classes">Classes</a></dt>
+
+          <dd>
+            <dl class="index">
+              <dt><a href=
               "errors.html#error_already_set-spec">error_already_set</a></dt>
-        </dl>
-      </dd>
-      <dt><a href="errors.html#functions">Functions</a></dt>
-      <dd> 
-        <dl class="index">
-          <dt><a href=
+            </dl>
+          </dd>
+
+          <dt><a href="errors.html#functions">Functions</a></dt>
+
+          <dd>
+            <dl class="index">
+              <dt><a href=
               "errors.html#handle_exception-spec">handle_exception</a></dt>
-          <dt><a href=
+
+              <dt><a href=
               "errors.html#expect_non_null-spec">expect_non_null</a></dt>
-          <dt><a href=
+
+              <dt><a href=
               "errors.html#throw_error_already_set-spec">throw_error_already_set</a></dt>
+            </dl>
+          </dd>
         </dl>
       </dd>
-    </dl>
-  </dd>
-  <dt><a href=
-      "exception_translator.html">exception_translator.hpp</a></dt>
-  <dd> 
-    <dl class="index">
+
       <dt><a href=
+      "exception_translator.html">exception_translator.hpp</a></dt>
+
+      <dd>
+        <dl class="index">
+          <dt><a href=
           "exception_translator.html#functions">Functions</a></dt>
-      <dd> 
-        <dl class="index">
-          <dt><a href=
+
+          <dd>
+            <dl class="index">
+              <dt><a href=
               "exception_translator.html#register_exception_translator-spec">register_exception_translator</a></dt>
+            </dl>
+          </dd>
         </dl>
       </dd>
-    </dl>
-  </dd>
-  <dt><a href="init.html">init.hpp</a></dt>
-  <dd> 
-    <dl class="index">
-      <dt><a href="init.html#classes">Classes</a></dt>
-      <dd> 
+
+      <dt><a href="init.html">init.hpp</a></dt>
+
+      <dd>
         <dl class="index">
-          <dt><a href="init.html#init-spec">init</a></dt>
-          <dt><a href="init.html#optional-spec">optional</a></dt>
+          <dt><a href="init.html#classes">Classes</a></dt>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="init.html#init-spec">init</a></dt>
+
+              <dt><a href="init.html#optional-spec">optional</a></dt>
+            </dl>
+          </dd>
         </dl>
       </dd>
-    </dl>
-  </dd>
-  <dt><a href="iterator.html">iterator.hpp</a></dt>
-  <dd> 
-    <dl class="index">
-      <dt><a href="iterator.html#classes">Classes</a></dt>
-      <dd> 
+
+      <dt><a href="iterator.html">iterator.hpp</a></dt>
+
+      <dd>
         <dl class="index">
-          <dt><a href="iterator.html#iterator-spec">iterator</a></dt>
-          <dt><a href="iterator.html#iterators-spec">iterators</a></dt>
+          <dt><a href="iterator.html#classes">Classes</a></dt>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="iterator.html#iterator-spec">iterator</a></dt>
+
+              <dt><a href="iterator.html#iterators-spec">iterators</a></dt>
+            </dl>
+          </dd>
+
+          <dt><a href="iterator.html#functions">Functions</a></dt>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="iterator.html#range-spec">range</a></dt>
+            </dl>
+          </dd>
         </dl>
       </dd>
-      <dt><a href="iterator.html#functions">Functions</a></dt>
-      <dd> 
+
+      <dt><a href="module.html">module.hpp</a></dt>
+
+      <dd>
         <dl class="index">
-          <dt><a href="iterator.html#range-spec">range</a></dt>
-        </dl>
-      </dd>
-    </dl>
-  </dd>
-  <dt><a href="module.html">module.hpp</a></dt>
-  <dd> 
-    <dl class="index">
-      <dt><a href="module.html#macros">Macros</a></dt>
-      <dd> 
-        <dl class="index">
-          <dt><a href=
+          <dt><a href="module.html#macros">Macros</a></dt>
+
+          <dd>
+            <dl class="index">
+              <dt><a href=
               "module.html#BOOST_PYTHON_MODULE-spec">BOOST_PYTHON_MODULE</a></dt>
+            </dl>
+          </dd>
+        </dl>
+      </dd>
+
+      <dt><a href="operators.html">operators.hpp</a></dt>
+
+      <dd>
+        <dl class="index">
+          <dt><a href="operators.html#classes">Classes</a></dt>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="operators.html#self_t-spec">self_t</a></dt>
+
+              <dt><a href="operators.html#other-spec">other</a></dt>
+
+              <dt><a href="operators.html#operator_-spec">operator_</a></dt>
+            </dl>
+          </dd>
+
+          <dt><a href="operators.html#objects">Objects</a></dt>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="operators.html#self-spec">self</a></dt>
+            </dl>
+          </dd>
+        </dl>
+      </dd>
+
+      <dt><a href="scope.html">scope.hpp</a></dt>
+
+      <dd>
+        <dl class="index">
+          <dt><a href="scope.html#classes">Classes</a></dt>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="scope.html#scope-spec">scope</a></dt>
+            </dl>
+          </dd>
+        </dl>
+      </dd>
+
+      <dt><a href="wrapper.html">wrapper.hpp</a></dt>
+
+      <dd>
+        <dl class="index">
+          <dt><a href="wrapper.html#classes">Classes</a></dt>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="wrapper.html#override-spec">override</a></dt>
+
+              <dt><a href="wrapper.html#wrapper-spec">wrapper</a></dt>
+            </dl>
+          </dd>
         </dl>
       </dd>
     </dl>
-  </dd>
-  <dt><a href="operators.html">operators.hpp</a></dt>
-  <dd> 
-    <dl class="index">
-      <dt><a href="operators.html#classes">Classes</a></dt>
-      <dd> 
-        <dl class="index">
-          <dt><a href="operators.html#self_t-spec">self_t</a></dt>
-          <dt><a href="operators.html#other-spec">other</a></dt>
-          <dt><a href="operators.html#operator_-spec">operator_</a></dt>
-        </dl>
-      </dd>
-      <dt><a href="operators.html#objects">Objects</a></dt>
-      <dd> 
-        <dl class="index">
-          <dt><a href="operators.html#self-spec">self</a></dt>
-        </dl>
-      </dd>
-    </dl>
-  </dd>
-  <dt><a href="scope.html">scope.hpp</a></dt>
-  <dd> 
-    <dl class="index">
-      <dt><a href="scope.html#classes">Classes</a></dt>
-      <dd> 
-        <dl class="index">
-          <dt><a href="scope.html#scope-spec">scope</a></dt>
-        </dl>
-      </dd>
-    </dl>
-  </dd>
-</dl>
 
     <h2><a name="object_wrappers">Object Wrappers</a></h2>
 
@@ -357,6 +416,7 @@
           </dd>
         </dl>
       </dd>
+
       <dt><a href="slice.html">slice.hpp</a></dt>
 
       <dd>
@@ -921,7 +981,7 @@
           <dd>
             <dl class="index">
               <dt>class template <a href=
-              "pointee.html#pointee">pointee</a></dt>
+              "pointee.html#pointee-spec">pointee</a></dt>
             </dl>
           </dd>
         </dl>
@@ -978,22 +1038,24 @@
 
     <h2><a name="topics">Topics</a></h2>
 
-    
-<dl>
-  <dt><a href="callbacks.html">Calling Python Functions and Methods</a></dt>
-  <dt><a href="pickle.html">Pickle Support</a><br>
-    <a href="indexing.html">Indexing Support</a></dt>
-</dl>
+    <dl>
+      <dt><a href="callbacks.html">Calling Python Functions and
+      Methods</a></dt>
+
+      <dt><a href="pickle.html">Pickle Support</a><br>
+       <a href="indexing.html">Indexing Support</a></dt>
+    </dl>
     <hr>
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     19 July, 2003 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+     31 October, 2004 
+<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p class="c3">&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002
+.</p>
   </body>
 </html>
 

doc/v2/reference_existing_object.html

@@ -102,9 +102,9 @@ template <class T> struct apply
 
       <dt><b>Returns:</b> <code>typedef <a href=
       "to_python_indirect.html#to_python_indirect-spec">to_python_indirect</a>&lt;T,V&gt;
-      type</code>, where <code>V</code> is a <a href=
-      "to_python_indirect.html#HolderObjectGenerator">HolderObjectGenerator</a>
-      which constructs an instance holder containing an <i>unowned</i>
+      type</code>, where <code>V</code> is a class whose
+      static <code>execute</code> function constructs an instance
+      holder containing an <i>unowned</i>
       <code>U*</code> pointing to the referent of the wrapped function's
       return value.</dt>
     </dl>
@@ -171,8 +171,7 @@ BOOST_PYTHON_MODULE(singleton)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/register_ptr_to_python.html

@@ -152,7 +152,7 @@ TypeError: No to_python (by-value) converter found for C++ type: class boost::sh
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
+  2002. </i></p>
 </body>
 </html>  
 

doc/v2/return_arg.html

@@ -213,7 +213,7 @@ BOOST_PYTHON_MODULE(return_self_ext)
 
     <p><i>&copy; Copyright <a href=
     "../../../../people/dave_abrahams.htm">Dave Abrahams</a> and Nikolay
-    Mladenov 2003. All Rights Reserved.</i></p>
+    Mladenov 2003. </i></p>
   </body>
 </html>
 

doc/v2/return_by_value.html

@@ -140,8 +140,7 @@ BOOST_PYTHON_MODULE(my_module)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/return_internal_reference.html

@@ -137,8 +137,8 @@ namespace boost { namespace python
 }}
 </pre>
 
-    <h4><a name="default_call_policies-spec-statics"></a>Class
-    <code>default_call_policies</code> static functions</h4>
+    <h4><a name="return_internal_reference-spec-statics"></a>Class
+    <code>return_internal_reference</code> static functions</h4>
 <pre>
 PyObject* postcall(PyObject* args, PyObject* result);
 </pre>
@@ -220,8 +220,7 @@ BOOST_PYTHON_MODULE(internal_refs)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/return_value_policy.html

@@ -158,8 +158,7 @@ BOOST_PYTHON_MODULE(my_module)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/scope.html

@@ -163,8 +163,7 @@ BOOST_PYTHON_MODULE(nested)
     <p>Revised 09 October, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/slice.html

@@ -53,7 +53,7 @@ for the Python <a
  href="http://www.python.org/doc/2.3.3/api/slice-objects.html">slice</a>
 type.</p>
 <h2><a name="classes"></a>Classes</h2>
-<h3><a name="class-spec"></a>Class <code>slice</code></h3>
+<h3><a name="slice-spec"></a>Class <code>slice</code></h3>
 <p>Exposes the extended slicing protocol by wrapping the built-in slice
 type. The semantics of the constructors and member functions defined
 below can be fully understood by reading the <a
@@ -134,7 +134,7 @@ slice(Int1 start, Int2 stop, Int3 step);
   <dt><b>Effects:</b> constructs a new slice with start stop and step
 values.&nbsp; Equivalent to the slice object created
 by the built-in Python function <code><a
- href="http://www.python.org/doc/current/lib/built-in-functions.html#12h-62">slice(start,stop,step)</a></code>,
+ href="http://www.python.org/doc/current/lib/built-in-funcs.html">slice(start,stop,step)</a></code>,
 or as part of the Python expression <code>base[start:stop:step]</code>.</dt>
   <dt><b>Throws:</b> <code>error_already_set</code> and sets a Python <code>TypeError</code>
 exception if no conversion is possible from the arguments to type

doc/v2/str.html

@@ -228,8 +228,7 @@ str remove_angle_brackets(str x)
     <p>Revised 3 October, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/to_python_converter.html

@@ -197,8 +197,7 @@ BOOST_PYTHON_MODULE(to_python_converter)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>