This commit was manufactured by cvs2svn to create tag

'Version_1_33_1'.

[SVN r31916]

build/Jamfile

@@ -0,0 +1,96 @@
+#  (C) Copyright David Abrahams 2001. 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.
+#
+# Boost.Python library Jamfile
+
+
+# declare the location of this subproject relative to the root
+subproject libs/python/build ;
+
+# bring in the rules for python
+import python ;
+
+if [ check-python-config ]
+{
+    
+  local bpl-linkflags ;
+
+  if $(UNIX) && ( $(OS) = AIX )
+  {
+      bpl-linkflags = <linkflags>"-e initlibboost_python" ;
+  }
+
+  # Enabling intrinsics (/0i) or maximize speed (/02) seem to cause
+  # internal compiler errors with this toolset.
+  local msvc-stlport-workarounds
+    = <optimization>off "<cxxflags>-Ogty -O1 -Gs" ;
+    
+  local sources =
+    numeric.cpp
+    list.cpp
+    long.cpp
+    dict.cpp
+    tuple.cpp
+    str.cpp
+    slice.cpp
+
+    aix_init_module.cpp
+    converter/from_python.cpp
+    converter/registry.cpp
+    converter/type_id.cpp
+    object/enum.cpp
+    object/class.cpp
+    object/function.cpp
+    object/inheritance.cpp
+    object/life_support.cpp
+    object/pickle_support.cpp
+    errors.cpp
+    module.cpp
+    converter/builtin_converters.cpp
+    converter/arg_to_python_base.cpp
+    object/iterator.cpp
+    object_protocol.cpp
+    object_operators.cpp
+    wrapper.cpp
+    ;
+  
+  dll boost_python
+    : ../src/$(sources)
+    : $(BOOST_PYTHON_V2_PROPERTIES)
+      <define>BOOST_PYTHON_SOURCE
+      $(bpl-linkflags)
+        <msvc-stlport><release>$(msvc-stlport-workarounds)
+        <darwin><*><linkflags>-bind_at_load
+        <gcc-3_3-darwin><*><linkflags>-bind_at_load
+      ;
+
+  template extension
+    : <dll>boost_python
+    : <sysinclude>../../..
+    ;
+  
+  lib boost_python
+    : # sources
+      ../src/$(sources)
+        
+    : # requirements
+      $(BOOST_PYTHON_V2_PROPERTIES)
+      <define>BOOST_PYTHON_SOURCE
+      <define>BOOST_STATIC_LIB
+      $(bpl-linkflags)
+        <msvc-stlport><release>$(msvc-stlport-workarounds)
+      ;
+
+  stage bin-stage : <dll>boost_python <lib>boost_python
+    : <tag><debug>"_debug"
+      <tag><debug-python>"_pydebug"
+    :
+        debug release
+    ;
+
+  install python lib
+    : <dll>boost_python <lib>boost_python
+    ;
+}

build/Jamfile.v2

@@ -1,151 +1,66 @@
-# Copyright David Abrahams 2001-2006. Distributed under the Boost
-# Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
 import os ;
-import indirect ;
 import modules ;
-import feature ;
 
 import python ;
 
-if ! [ python.configured ] && ! ( --without-python in  [ modules.peek : ARGV ] )
-{
-    # Attempt default configuration of python
-    import toolset : using ;
-    using python ;
-}
+if [ python.configured ] {
+    
 
-if [ python.configured ] || ( --without-python in  [ modules.peek : ARGV ] )
-{
-    alias config-warning ;
+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
+
+# 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)
+    ;
+
+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
+    converter/registry.cpp
+    converter/type_id.cpp
+    object/enum.cpp
+    object/class.cpp
+    object/function.cpp
+    object/inheritance.cpp
+    object/life_support.cpp
+    object/pickle_support.cpp
+    errors.cpp
+    module.cpp
+    converter/builtin_converters.cpp
+    converter/arg_to_python_base.cpp
+    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
 {
-    message config-warning
-        : "warning: No python installation configured and autoconfiguration"
-        : "note: failed.  See http://www.boost.org/libs/python/doc/building.html"
-        : "note: for configuration instructions or pass --without-python to"
-        : "note: suppress this message and silently skip all Boost.Python targets"
-        ;
-}
-
-rule find-py3-version
-{
-    local versions = [ feature.values python ] ;
-    local py3ver ;
-    for local v in $(versions)
-    {
-        if $(v) >= 3.0
-        {
-            py3ver = $(v) ;
-        }
-    }
-    return $(py3ver) ;
-}
-
-py3-version = [ find-py3-version ] ;
-
-project boost/python
-  : source-location ../src
-  : requirements
-    -<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
-    <tag>@$(__name__).tag
-  ;
-
-rule tag ( name : type ? : property-set )
-{
-    local result = $(name) ;
-    if $(type) in STATIC_LIB SHARED_LIB IMPORT_LIB
-    {
-        if $(name) = boost_python && $(PYTHON_ID)
-        {
-            result = $(result)-$(PYTHON_ID) ;
-        }
-    }
-    
-    # forward to the boost tagging rule
-    return  [ indirect.call $(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag 
-                $(result) : $(type) : $(property-set) ] ;
-}
-
-rule cond ( test ? : yes * : no * ) { if $(test) { return $(yes) ; } else { return $(no) ; } }
-rule unless ( test ? : yes * : no * ) { if ! $(test) { return $(yes) ; } else { return $(no) ; } }
-
-rule lib_boost_python ( is-py3 ? )
-{
-
-    lib [ cond $(is-py3) : boost_python3 : boost_python ]
-        : # sources
-        numeric.cpp
-        list.cpp
-        long.cpp
-        dict.cpp
-        tuple.cpp
-        str.cpp
-        slice.cpp
-
-        converter/from_python.cpp
-        converter/registry.cpp
-        converter/type_id.cpp
-        object/enum.cpp
-        object/class.cpp
-        object/function.cpp
-        object/inheritance.cpp
-        object/life_support.cpp
-        object/pickle_support.cpp
-        errors.cpp
-        module.cpp
-        converter/builtin_converters.cpp
-        converter/arg_to_python_base.cpp
-        object/iterator.cpp
-        object/stl_iterator.cpp
-        object_protocol.cpp
-        object_operators.cpp
-        wrapper.cpp
-        import.cpp
-        exec.cpp
-        object/function_doc_signature.cpp
-        :   # requirements
-            <link>static:<define>BOOST_PYTHON_STATIC_LIB 
-            <define>BOOST_PYTHON_SOURCE
-          
-            # On Windows, all code using Python has to link to the Python
-            # import library.
-            #
-            # On *nix we never link libboost_python to libpython.  When
-            # extending Python, all Python symbols are provided by the
-            # Python interpreter executable.  When embedding Python, the
-            # client executable is expected to explicitly link to
-            # /python//python (the target representing libpython) itself.
-            #
-            # python_for_extensions is a target defined by Boost.Build to
-            # provide the Python include paths, and on Windows, the Python
-            # import library, as usage requirements.
-            [ cond [ python.configured ] : <library>/python//python_for_extensions ]
-            
-            # we prevent building when there is no python available
-            # as it's not possible anyway, and to cause dependents to
-            # fail to build
-            [ unless [ python.configured ] : <build>no ]
-            <dependency>config-warning
-
-            <python-debugging>on:<define>BOOST_DEBUG_PYTHON
-            [ cond $(is-py3) : <python>$(py3-version) ]
-        :   # default build
-            <link>shared
-        :   # usage requirements
-            <link>static:<define>BOOST_PYTHON_STATIC_LIB
-            <python-debugging>on:<define>BOOST_DEBUG_PYTHON
-        ;
-
-}
-
-lib_boost_python ;
-boost-install boost_python ;
-
-if $(py3-version)
-{
-    lib_boost_python yes ;
-    boost-install boost_python3 ;
+    ECHO "warning: Python location is not configured" ;
+    ECHO "warning: the Boost.Python library won't be built" ;
 }

build/VisualStudio/boost_python.dsp

@@ -0,0 +1,890 @@
+# Microsoft Developer Studio Project File - Name="boost_python" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=BOOST_PYTHON - WIN32 RELEASE
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "boost_python.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "boost_python.mak" CFG="BOOST_PYTHON - WIN32 RELEASE"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "boost_python - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "boost_python - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "boost_python - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "../bin-stage"
+# PROP Intermediate_Dir "release-obj"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+F90=df.exe
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "BPL_EXPORTS" /YX /FD /Zm800 /Zm800 /Zm800 /c
+# ADD CPP /nologo /MD /W3 /GR /GX /O2 /I "../../../../" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "BOOST_PYTHON_DYNAMIC_LIB" /D "BOOST_PYTHON_SOURCE" /FD /Zm800 /Zm800 /Zm800 /Zm800 /c
+# SUBTRACT CPP /YX
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x1409 /d "NDEBUG"
+# ADD RSC /l 0x1409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib /nologo /dll /machine:I386
+
+!ELSEIF  "$(CFG)" == "boost_python - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "../bin-stage"
+# PROP Intermediate_Dir "debug-obj"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+F90=df.exe
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "BPL_EXPORTS" /YX /FD /Zm800 /Zm800 /Zm800 /GZ /c
+# ADD CPP /nologo /MDd /W3 /GR /GX /Zi /Od /I "../../../../" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "BOOST_PYTHON_DYNAMIC_LIB" /D "BOOST_PYTHON_SOURCE" /FD /Zm800 /Zm800 /Zm800 /Zm800 /Zm800 /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x1409 /d "_DEBUG"
+# ADD RSC /l 0x1409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib /nologo /dll /incremental:no /debug /machine:I386 /out:"../bin-stage/boost_python_debug.dll" /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "boost_python - Win32 Release"
+# Name "boost_python - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=..\..\src\aix_init_module.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\converter\arg_to_python_base.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\converter\builtin_converters.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object\class.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\dict.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object\enum.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\errors.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\converter\from_python.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object\function.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object\inheritance.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object\iterator.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object\life_support.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\list.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\long.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\module.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\numeric.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object_operators.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object_protocol.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object\pickle_support.cpp
+# End Source File
+# Begin Source File
+
+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
+
+SOURCE=..\..\src\tuple.cpp
+# End Source File
+# Begin Source File
+
+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"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Group "detail"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\aix_init_module.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\api_placeholder.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\arg_tuple_size.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\borrowed_ptr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\call_object.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\caller.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\char_array.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\config.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\construct.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\convertible.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\cv_category.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\decorated_type_id.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\def_helper.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\defaults_def.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\defaults_gen.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\dependent.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\destroy.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\exception_handler.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\force_instantiate.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\if_else.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\indirect_traits.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\make_keyword_range_fn.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\make_tuple.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\map_entry.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\member_function_cast.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\module_base.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\module_init.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\msvc_typeinfo.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\none.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\not_specified.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\operator_id.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\overloads_fwd.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\pointee.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\preprocessor.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\python22_fixed.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\raw_pyobject.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\referent_storage.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\result.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\returning.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\scope.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\string_literal.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\target.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\translate_exception.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\type_list.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\type_list_impl.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\type_list_impl_no_pts.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\type_list_utils.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\unwind_type.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\void_ptr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\void_return.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\wrap_python.hpp
+# End Source File
+# End Group
+# Begin Group "converter"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\arg_from_python.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\arg_to_python.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\arg_to_python_base.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\builtin_converters.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\constructor_function.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\convertible_function.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\from_python.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\implicit.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\obj_mgr_arg_from_python.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\object_manager.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\pointer_type_id.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\pyobject_traits.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\pyobject_type.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\pytype_arg_from_python.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\pytype_object_mgr_traits.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\registered.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\registered_pointee.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\registrations.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\registry.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\return_from_python.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\rvalue_from_python_data.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\to_python_function_type.hpp
+# End Source File
+# End Group
+# Begin Group "object"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\add_to_namespace.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\class.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\class_converters.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\class_detail.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\class_wrapper.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\construct.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\enum_base.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\find_instance.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\forward.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\function.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\function_handle.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\function_object.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\inheritance.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\instance.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\iterator.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\iterator_core.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\life_support.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\make_holder.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\make_instance.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\pickle_support.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\pointer_holder.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\py_function.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\select_holder.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\value_holder.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\value_holder_fwd.hpp
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\arg_from_python.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\args.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\args_fwd.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\back_reference.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\base_type_traits.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\bases.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\borrowed.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\call.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\call_method.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\cast.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\class.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\class_fwd.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\copy_const_reference.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\copy_non_const_reference.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\data_members.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\def.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\default_call_policies.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\dict.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\enum.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\errors.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\exception_translator.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\extract.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\handle.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\handle_fwd.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\has_back_reference.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\implicit.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\init.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\instance_holder.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\iterator.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\list.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\long.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\lvalue_from_pytype.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\make_function.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\manage_new_object.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\module.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\module_init.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\numeric.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_attributes.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_call.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_core.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_fwd.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_items.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_operators.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_protocol.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_protocol_core.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_slices.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\operators.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\operators2.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\other.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\overloads.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\pointee.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\proxy.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\ptr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\refcount.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\reference_existing_object.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\return_internal_reference.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\return_value_policy.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\scope.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\self.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\signature.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\slice_nil.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\str.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\tag.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\to_python_converter.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\to_python_indirect.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\to_python_value.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\tuple.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\type_id.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\with_custodian_and_ward.hpp
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

build/VisualStudio/boost_python.dsw

@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "boost_python"=".\boost_python.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+

class.cpp

@@ -1,28 +0,0 @@
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-#include <boost/python/module.hpp>
-#include <boost/python/def.hpp>
-#include <boost/python/object.hpp>
-#include <boost/python/class.hpp>
-
-using namespace boost::python;
-
-struct X
-{
-    int x;
-    X(int n) : x(n) { }
-};
-
-int x_function(X& x)
-{   return x.x;
-}
-
-
-BOOST_PYTHON_MODULE(class_ext)
-{
-    class_<X>("X", init<int>());
-    def("x_function", x_function);
-}
-
-#include "module_tail.cpp"

doc/Jamfile

@@ -1,23 +0,0 @@
-# Copyright David Abrahams 2006. Distributed under the Boost
-# Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-import docutils ;
-
-import path ;
-sources = building.rst ;
-bases = $(sources:S=) ;
-  
-# This is a path relative to the html/ subdirectory where the
-# generated output will eventually be moved.
-stylesheet = "--stylesheet=../../../rst.css" ;
-
-for local b in $(bases)
-{
-    html $(b) : $(b).rst : 
-      
-    <docutils-html>"-gdt --source-url="./$(b).rst" --link-stylesheet --traceback --trim-footnote-reference-space --footnote-references=superscript "$(stylesheet)
-  ;
-}
-
-alias htmls : $(bases) ;
-stage . : $(bases) ;

doc/PyConDC_2003/bpl.html

@@ -1,11 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=

doc/PyConDC_2003/bpl.txt

@@ -1,5 +1 @@
-.. Copyright David Abrahams 2006. Distributed under the Boost
-.. Software License, Version 1.0. (See accompanying
-.. file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
 This file has been moved to http://www.boost-consulting.com/writing/bpl.txt.

doc/PyConDC_2003/bpl_mods.txt

@@ -1,7 +1,3 @@
-Copyright David Abrahams 2006. Distributed under the Boost
-Software License, Version 1.0. (See accompanying
-file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
 .. This is a comment. Note how any initial comments are moved by
    transforms to after the document title, subtitle, and docinfo.
 
@@ -27,6 +23,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
           Somerville, MA 02143
 :Contact: dave@boost-consulting.com
 :organization: `Boost Consulting`_
+:date: $Date$
 :status: This is a "work in progress"
 :version: 1
 :copyright: Copyright David Abrahams 2002. All rights reserved

doc/PyConDC_2003/default.css

@@ -1,10 +1,10 @@
 /*
 :Author: David Goodger
 :Contact: goodger@users.sourceforge.net
+:date: $Date$
+:version: $Revision$
 :copyright: This stylesheet has been placed in the public domain.
 
-boostinspect:nolicense
-
 Default cascading style sheet for the HTML output of Docutils.
 */
 

doc/boost.css

@@ -1,7 +1,3 @@
-/* Copyright David Abrahams 2006. Distributed under the Boost
-   Software License, Version 1.0. (See accompanying 
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-*/
 H1
 {
     FONT-SIZE: 200%

doc/building.rst

@@ -1,680 +0,0 @@
-.. Copyright David Abrahams 2006. Distributed under the Boost
-.. Software License, Version 1.0. (See accompanying
-.. file LICENSE_1_0.txt or copy at
-.. http://www.boost.org/LICENSE_1_0.txt)
-
-==============================================
- |(logo)|__ Boost.Python Build and Test HOWTO
-==============================================
-
-.. |(logo)| image:: ../../../boost.png
-   :alt: Boost C++ Libraries:
-   :class: boost-logo
-
-__ ../index.html
-
-
-.. section-numbering::
-   :depth: 2
-
-.. contents:: Contents
-   :depth: 2
-   :class: sidebar small
-
-.. |newer| replace:: *newer*
-
-Requirements
-============
-
-Boost.Python requires `Python 2.2`_ [#2.2]_ *or* |newer|__.  
-
-.. _Python 2.2: http://www.python.org/2.2
-__ http://www.python.org
-
-Background
-==========
-
-There are two basic models for combining C++ and Python:
-
-- extending_, in which the end-user launches the Python interpreter
-  executable and imports Python “extension modules” written in C++.
-  Think of taking a library written in C++ and giving it a Python
-  interface so Python programmers can use it.  From Python, these
-  modules look just like regular Python modules.
-
-- embedding_, in which the end-user launches a program written
-  in C++ that in turn invokes the Python interpreter as a library
-  subroutine.  Think of adding scriptability to an existing
-  application.
-
-.. _extending: http://www.python.org/doc/current/ext/intro.html
-.. _embedding: http://www.python.org/doc/current/ext/embedding.html
-
-The key distinction between extending and embedding is the location
-of the C++ ``main()`` function: in the Python interpreter executable,
-or in some other program, respectively.  Note that even when
-embedding Python in another program, `extension modules are often
-the best way to make C/C++ functionality accessible to Python
-code`__, so the use of extension modules is really at the heart of
-both models.
-
-__ http://www.python.org/doc/current/ext/extending-with-embedding.html
-
-Except in rare cases, extension modules are built as
-dynamically-loaded libraries with a single entry point, which means
-you can change them without rebuilding either the other extension
-modules or the executable containing ``main()``.
-
-.. _quickstart:
-
-No-Install Quickstart
-=====================
-
-There is no need to “install Boost” in order to get started using
-Boost.Python.  These instructions use Boost.Build_ projects,
-which will build those binaries as soon as they're needed.  Your
-first tests may take a little longer while you wait for
-Boost.Python to build, but doing things this way will save you from
-worrying about build intricacies like which library binaries to use
-for a specific compiler configuration and figuring out the right
-compiler options to use yourself.
-
-.. .. raw:: html
-
-   <div style="width:50%">
-
-.. Note:: Of course it's possible to use other build systems to
-   build Boost.Python and its extensions, but they are not
-   officially supported by Boost.  Moreover **99% of all “I can't
-   build Boost.Python” problems come from trying to use another
-   build system** without first following these instructions.
-
-   If you want to use another system anyway, we suggest that you
-   follow these instructions, and then invoke ``bjam`` with the
-
-   .. parsed-literal::
-
-     ``-a -o``\ *filename* 
-
-   options to dump the build commands it executes to a file, so
-   you can see what your alternate build system needs to do.
-
-.. .. raw:: html
- 
-   </div>
-
-.. _Boost.Build: ../../../tools/build/index.html
-
-Basic Procedure
----------------
-
-1. Get Boost; see sections 1 and 2 [`Unix/Linux`__, `Windows`__\ ] of the
-   Boost `Getting Started Guide`_.
-
-   __ ../../../more/getting_started/unix-variants.html#get-boost
-   __ ../../../more/getting_started/windows.html#get-boost
-
-2. Get the ``bjam`` build driver.  See section 5 [`Unix/Linux`__,
-   `Windows`__\ ] of the Boost `Getting Started Guide`_.
-
-   __ ../../../more/getting_started/unix-variants.html#prepare-to-use-a-boost-library-binary
-   __ ../../../more/getting_started/windows.html#prepare-to-use-a-boost-library-binary
-
-
-3. cd into the ``libs/python/example/quickstart/`` directory of your
-   Boost installation, which contains a small example project.
-
-4. Invoke ``bjam``.  Replace the “\ ``stage``\ “ argument from the
-   example invocation from section 5 of the `Getting Started
-   Guide`_ with “\ ``test``\ ,“ to build all the test targets.  Also add
-   the argument “\ ``--verbose-test``\ ” to see the output generated by
-   the tests when they are run.
-
-   On Windows, your ``bjam`` invocation might look something like:
-
-   .. parsed-literal::
-
-     C:\\boost_1_34_0\\…\\quickstart> **bjam toolset=msvc --verbose-test test**
-
-   and on Unix variants, perhaps,
-
-   .. parsed-literal::
-
-     ~/boost_1_34_0/…/quickstart$ **bjam toolset=gcc --verbose-test test**
-
-.. Admonition:: Note to Windows Users
-
-   For the sake of concision, the rest of this guide will use
-   unix-style forward slashes in pathnames instead of the
-   backslashes with which you may be more familiar.  The forward
-   slashes should work everywhere except in `Command Prompt`_
-   windows, where you should use backslashes.
-
-   .. _Command Prompt: ../../../more/getting_started/windows.html#command-prompt
-
-If you followed this procedure successfully, you will have built an
-extension module called ``extending`` and tested it by running a
-Python script called ``test_extending.py``.  You will also have
-built and run a simple application called ``embedding`` that embeds
-python.
-
-.. _Getting Started Guide: ../../../more/getting_started/index.html
-
-In Case of Trouble
-------------------
-
-If you're seeing lots of compiler and/or linker error messages,
-it's probably because Boost.Build is having trouble finding your
-Python installation.  You might want to pass the
-``--debug-configuration`` option to ``bjam`` the first few times
-you invoke it, to make sure that Boost.Build is correctly locating
-all the parts of your Python installation.  If it isn't, consider
-`Configuring Boost.Build`_ as detailed below.
-
-If you're still having trouble, Someone on one of the following
-mailing lists may be able to help:
-
-* The `Boost.Build mailing list`__ for issues related to Boost.Build
-* The Python `C++ Sig`__ for issues specifically related to Boost.Python
-
-__ http://www.boost.org/more/mailing_lists.htm#jamboost
-__ http://www.boost.org/more/mailing_lists.htm#cplussig
-
-In Case Everything Seemed to Work
----------------------------------
-
-Rejoice!  If you're new to Boost.Python, at this point it might be
-a good idea to ignore build issues for a while and concentrate on
-learning the library by going through the tutorial_ and perhaps
-some of the `reference documentation`_, trying out what you've
-learned about the API by modifying the quickstart project.
-
-.. _reference documentation: v2/reference.html
-.. _tutorial: tutorial/index.html
-
-Modifying the Example Project
------------------------------
-
-If you're content to keep your extension module forever in one
-source file called |extending.cpp|_, inside your Boost
-distribution, and import it forever as ``extending``, then you can
-stop here.  However, it's likely that you will want to make a few
-changes.  There are a few things you can do without having to learn
-Boost.Build_ in depth.
-
-The project you just built is specified in two files in the current
-directory: |boost-build.jam|_, which tells ``bjam`` where it can
-find the interpreted code of the Boost build system, and
-|Jamroot|_, which describes the targets you just built.  These
-files are heavily commented, so they should be easy to modify.
-Take care, however, to preserve whitespace.  Punctuation such as
-``;`` will not be recognized as intended by ``bjam`` if it is not
-surrounded by whitespace.
-
-.. |boost-build.jam| replace:: ``boost-build.jam``
-.. _boost-build.jam: ../example/quickstart/boost-build.jam
-
-.. |Jamroot| replace:: ``Jamroot``
-.. _Jamroot: ../example/quickstart/Jamroot
-
-.. |extending.cpp| replace:: ``extending.cpp``
-.. _extending.cpp: ../example/quickstart/extending.cpp
-
-Relocate the Project
-....................
-
-You'll probably want to copy this project elsewhere so you can
-change it without modifying your Boost distribution.  To do that,
-simply
-
-a. copy the entire ``libs/python/example/quickstart/`` directory
-   into a new directory.
-
-b. In the new copies of |boost-build.jam|_ and |Jamroot|_, locate
-   the relative path near the top of the file that is clearly
-   marked by a comment, and edit that path so that it refers to the
-   same directory your Boost distribution as it referred to when
-   the file was in its original location in the
-   ``libs/python/example/quickstart/`` directory.
-
-For example, if you moved the project from
-``/home/dave/boost_1_34_0/libs/python/example/quickstart`` to
-``/home/dave/my-project``, you could change the first path in
-|boost-build.jam|_ from
-
-.. parsed-literal::
-
-  **../../../..**\ /tools/build/v2
-
-to
-
-.. parsed-literal::
-
-  **/home/dave/boost_1_34_0**\ /tools/build/v2
-
-and change the first path in |Jamroot|_ from
-
-.. parsed-literal::
-
-  **../../../..**
-
-to
-
-.. parsed-literal::
-
-  **/home/dave/boost_1_34_0**
-
-Add New or Change Names of Existing Source Files
-................................................
-
-The names of additional source files involved in building your
-extension module or embedding application can be listed in
-|Jamroot|_ right alongside ``extending.cpp`` or ``embedding.cpp``
-respectively.  Just be sure to leave whitespace around each
-filename::
-
-  … file1.cpp file2.cpp file3.cpp …
-
-Naturally, if you want to change the name of a source file you can
-tell Boost.Build about it by editing the name in |Jamroot|_.
-
-Change the Name of your Extension Module
-........................................
-
-The name of the extension module is determined by two things:
-
-1. the name in |Jamroot|_ immediately following ``python-extension``, and 
-2. the name passed to ``BOOST_PYTHON_MODULE`` in |extending.cpp|_.
-
-To change the name of the extension module from ``extending`` to
-``hello``, you'd edit |Jamroot|_, changing
-
-.. parsed-literal::
-
-  python-extension **extending** : extending.cpp ;
-
-to
-
-.. parsed-literal::
-
-  python-extension **hello** : extending.cpp ;
-
-and you'd edit extending.cpp, changing
-
-.. parsed-literal::
-
-  BOOST_PYTHON_MODULE(\ **extending**\ )
-
-to
-
-.. parsed-literal::
-
-  BOOST_PYTHON_MODULE(\ **hello**\ )
-
-Installing Boost.Python on your System
-======================================
-
-Since Boost.Python is a separately-compiled (as opposed to
-`header-only`_) library, its user relies on the services of a
-Boost.Python library binary.  
-
-.. _header-only: ../../../more/getting_started/windows.html#header-only-libraries
-
-If you need a regular installation of the Boost.Python library
-binaries on your system, the Boost `Getting Started Guide`_ will
-walk you through the steps of creating one.  If building binaries
-from source, you might want to supply the ``--with-python``
-argument to ``bjam`` (or the ``--with-libraries=python`` argument
-to ``configure``), so only the Boost.Python binary will be built,
-rather than all the Boost binaries.
-
-
-Configuring Boost.Build
-=======================
-
-As described in the `Boost.Build reference manual`__, a file called
-``user-config.jam`` in your home directory [#home-dir]_ is used to
-specify the tools and libraries available to the build system. You
-may need to create or edit ``user-config.jam`` to tell Boost.Build
-how to invoke Python, ``#include`` its headers, and link with its
-libraries.
-
-__ http://www.boost.orgdoc/html/bbv2/advanced.html#bbv2.advanced.configuration
-
-.. Admonition:: Users of Unix-Variant OSes
-
-   If you are using a unix-variant OS and you ran Boost's
-   ``configure`` script, it may have generated a
-   ``user-config.jam`` for you. [#overwrite]_ If your ``configure``\
-   /\ ``make`` sequence was successful and Boost.Python binaries
-   were built, your ``user-config.jam`` file is probably already
-   correct.
-
-If you have one fairly “standard” python installation for your
-platform, you might not need to do anything special to describe it.  If
-you haven't configured python in ``user-config.jam`` (and you don't
-specify ``--without-python`` on the Boost.Build command line),
-Boost.Build will automatically execute the equivalent of ::
-
-  import toolset : using ; 
-  using python ;
-
-which automatically looks for Python in the most likely places.
-However, that only happens when using the Boost.Python project file
-(e.g. when referred to by another project as in the quickstart_
-method).  If instead you are linking against separately-compiled
-Boost.Python binaries, you should set up a ``user-config.jam`` file
-with at least the minimal incantation above.
-
-Python Configuration Parameters
--------------------------------
-
-If you have several versions of Python installed, or Python is
-installed in an unusual way, you may want to supply any or all of
-the following optional parameters to ``using python``.
-
-version
-  the version of Python to use.  Should be in Major.Minor
-  format, for example, ``2.3``.  Do not include the subminor
-  version (i.e. *not* ``2.5.1``).  If you have multiple Python
-  versions installed, the version will usually be the only
-  configuration argument required.
-
-cmd-or-prefix
-  preferably, a command that invokes a Python interpreter.
-  Alternatively, the installation prefix for Python libraries and
-  header files.  Only use the alternative formulation if there is
-  no appropriate Python executable available.
-
-includes
-  the ``#include`` paths for Python headers.  Normally the correct
-  path(s) will be automatically deduced from ``version`` and/or
-  ``cmd-or-prefix``.  
-
-libraries
-  the path to Python library binaries.  On MacOS/Darwin,
-  you can also pass the path of the Python framework.  Normally the
-  correct path(s) will be automatically deduced from ``version``
-  and/or ``cmd-or-prefix``. 
-
-condition
-  if specified, should be a set of Boost.Build
-  properties that are matched against the build configuration when
-  Boost.Build selects a Python configuration to use.  See examples
-  below for details.
-
-extension-suffix
-  A string to append to the name of extension
-  modules before the true filename extension.  You almost certainly
-  don't need to use this.  Usually this suffix is only used when
-  targeting a Windows debug build of Python, and will be set
-  automatically for you based on the value of the
-  |python-debugging|_ feature.  However, at least one Linux
-  distribution (Ubuntu Feisty Fawn) has a specially configured
-  `python-dbg`__ package that claims to use such a suffix.
-
-.. |python-debugging| replace:: ``<python-debugging>``
-
-__ https://wiki.ubuntu.com/PyDbgBuilds
-
-
-Examples
---------
-
-Note that in the examples below, case and *especially whitespace* are
-significant.
-
-- If you have both python 2.5 and python 2.4 installed,
-  ``user-config.jam`` might contain::
-  
-    using python : 2.5 ;  # Make both versions of Python available 
-
-    using python : 2.4 ;  # To build with python 2.4, add python=2.4 
-                          # to your command line.
-
-  The first version configured (2.5) becomes the default.  To build
-  against python 2.4, add ``python=2.4`` to the ``bjam`` command line.
-
-- If you have python installed in an unusual location, you might
-  supply the path to the interpreter in the ``cmd-or-prefix``
-  parameter::
-
-    using python : : /usr/local/python-2.6-beta/bin/python ;
-
-- If you have a separate build of Python for use with a particular
-  toolset, you might supply that toolset in the ``condition``
-  parameter::
-
-    using python ;  # use for most toolsets
-    
-    # Use with Intel C++ toolset
-    using python 
-         : # version
-         : c:\\Devel\\Python-2.5-IntelBuild\\PCBuild\\python # cmd-or-prefix
-         : # includes
-         : # libraries
-         : <toolset>intel # condition
-         ;
-
-
-- If you have downloaded the Python sources and built both the
-  normal and the “\ `python debugging`_\ ” builds from source on
-  Windows, you might see::
-
-    using python : 2.5 : C:\\src\\Python-2.5\\PCBuild\\python ;
-    using python : 2.5 : C:\\src\\Python-2.5\\PCBuild\\python_d
-      : # includes
-      : # libs
-      : <python-debugging>on ;
-
-- You can set up your user-config.jam so a bjam built under Windows 
-  can build/test both Windows and Cygwin_ python extensions.  Just pass
-  ``<target-os>cygwin`` in the ``condition`` parameter
-  for the cygwin python installation::
-
-    # windows installation
-    using python ;
-
-    # cygwin installation
-    using python : : c:\\cygwin\\bin\\python2.5 : : : <target-os>cygwin ;
-
-  when you put target-os=cygwin in your build request, it should build
-  with the cygwin version of python: [#flavor]_
-
-    bjam target-os=cygwin toolset=gcc 
-
-  This is supposed to work the other way, too (targeting windows
-  python with a Cygwin_ bjam) but it seems as though the support in
-  Boost.Build's toolsets for building that way is broken at the
-  time of this writing.
-
-- Note that because of `the way Boost.Build currently selects target
-  alternatives`__, you might have be very explicit in your build
-  requests.  For example, given::
-
-    using python : 2.5 ; # a regular windows build
-    using python : 2.4 : : : : <target-os>cygwin ;
-
-  building with ::
-
-    bjam target-os=cygwin
-
-  will yield an error.  Instead, you'll need to write::
-
-    bjam target-os=cygwin/python=2.4
-
-.. _Cygwin: http://cygwin.com
-
-__ http://zigzag.cs.msu.su/boost.build/wiki/AlternativeSelection
-
-Choosing a Boost.Python Library Binary
-======================================
-
-If—instead of letting Boost.Build construct and link with the right
-libraries automatically—you choose to use a pre-built Boost.Python
-library, you'll need to think about which one to link with.  The
-Boost.Python binary comes in both static and dynamic flavors.  Take
-care to choose the right flavor for your application. [#naming]_
-
-The Dynamic Binary
-------------------
-
-The dynamic library is the safest and most-versatile choice:
-
-- A single copy of the library code is used by all extension
-  modules built with a given toolset. [#toolset-specific]_
-
-- The library contains a type conversion registry.  Because one
-  registry is shared among all extension modules, instances of a
-  class exposed to Python in one dynamically-loaded extension
-  module can be passed to functions exposed in another such module.
-
-The Static Binary
------------------
-
-It might be appropriate to use the static Boost.Python library in
-any of the following cases:
-
-- You are extending_ python and the types exposed in your
-  dynamically-loaded extension module don't need to be used by any
-  other Boost.Python extension modules, and you don't care if the
-  core library code is duplicated among them.
-
-- You are embedding_ python in your application and either:
-
-  - You are targeting a Unix variant OS other than MacOS or AIX,
-    where the dynamically-loaded extension modules can “see” the
-    Boost.Python library symbols that are part of the executable.
-
-  - Or, you have statically linked some Boost.Python extension
-    modules into your application and you don't care if any
-    dynamically-loaded Boost.Python extension modules are able to
-    use the types exposed by your statically-linked extension
-    modules (and vice-versa).
-
-``#include`` Issues
-===================
-
-1. If you should ever have occasion to ``#include "python.h"``
-   directly in a translation unit of a program using Boost.Python,
-   use ``#include "boost/python/detail/wrap_python.hpp"`` instead.
-   It handles several issues necessary for use with Boost.Python,
-   one of which is mentioned in the next section.
-
-2. Be sure not to ``#include`` any system headers before
-   ``wrap_python.hpp``.  This restriction is actually imposed by
-   Python, or more properly, by Python's interaction with your
-   operating system.  See
-   http://docs.python.org/ext/simpleExample.html for details.
-
-.. _python-debugging:
-.. _python debugging:
-
-Python Debugging Builds
-=======================
-
-Python can be built in a special “python debugging” configuration
-that adds extra checks and instrumentation that can be very useful
-for developers of extension modules.  The data structures used by
-the debugging configuration contain additional members, so **a
-Python executable built with python debugging enabled cannot be
-used with an extension module or library compiled without it, and
-vice-versa.**
-
-Since pre-built “python debugging” versions of the Python
-executable and libraries are not supplied with most distributions
-of Python, [#get-debug-build]_ and we didn't want to force our users
-to build them, Boost.Build does not automatically enable python
-debugging in its ``debug`` build variant (which is the default).
-Instead there is a special build property called
-``python-debugging`` that, when used as a build property, will
-define the right preprocessor symbols and select the right
-libraries to link with.
-
-On unix-variant platforms, the debugging versions of Python's data
-structures will only be used if the symbol ``Py_DEBUG`` is defined.
-On many windows compilers, when extension modules are built with
-the preprocessor symbol ``_DEBUG``, Python defaults to force
-linking with a special debugging version of the Python DLL.  Since
-that symbol is very commonly used even when Python is not present,
-Boost.Python temporarily undefines _DEBUG when Python.h
-is #included from ``boost/python/detail/wrap_python.hpp`` - unless
-``BOOST_DEBUG_PYTHON`` is defined.  The upshot is that if you want
-“python debugging”and you aren't using Boost.Build, you should make
-sure ``BOOST_DEBUG_PYTHON`` is defined, or python debugging will be
-suppressed.
-
-Testing Boost.Python
-====================
-
-To run the full test suite for Boost.Python, invoke ``bjam`` in the
-``libs/python/test`` subdirectory of your Boost distribution.
-
-Notes for MinGW (and Cygwin with -mno-cygwin) GCC Users
-=======================================================
-
-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 `Installing
-Python Modules`__ to create ``libpythonXX.a``, where ``XX``
-corresponds to the major and minor version numbers of your Python
-installation.
-
-__ http://www.python.org/doc/current/inst/index.html
-
------------------------------
-
-.. [#2.2] Note that although we tested earlier versions of
-   Boost.Python with Python 2.2, and we don't *think* we've done
-   anything to break compatibility, this release of Boost.Python
-   may not have been tested with versions of Python earlier than
-   2.4, so we're not 100% sure that python 2.2 and 2.3 are
-   supported.
-
-.. [#naming] Information about how to identify the
-   static and dynamic builds of Boost.Python:
-
-   * `on Windows`__
-   * `on Unix variants`__
-
-   __ ../../../more/getting_started/windows.html#library-naming
-   __ ../../../more/getting_started/unix-variants.html#library-naming
-
-.. [#toolset-specific] Because of the way most \*nix platforms
-   share symbols among dynamically-loaded objects, I'm not certain
-   that extension modules built with different compiler toolsets
-   will always use different copies of the Boost.Python library
-   when loaded into the same Python instance.  Not using different
-   libraries could be a good thing if the compilers have compatible
-   ABIs, because extension modules built with the two libraries
-   would be interoperable.  Otherwise, it could spell disaster,
-   since an extension module and the Boost.Python library would
-   have different ideas of such things as class layout. I would
-   appreciate someone doing the experiment to find out what
-   happens.
-
-.. [#overwrite] ``configure`` overwrites the existing
-   ``user-config.jam`` in your home directory
-   (if any) after making a backup of the old version.
-
-.. [#flavor] Note that the ``<target-os>cygwin`` feature is
-   different from the ``<flavor>cygwin`` subfeature of the ``gcc``
-   toolset, and you might need handle both explicitly if you also
-   have a MinGW GCC installed.
-
-.. [#home-dir] Windows users, your home directory can be
-   found by typing::
-
-     ECHO %HOMEDRIVE%%HOMEPATH%
-
-   into a `command prompt`_ window.
-
-.. [#get-debug-build] On Unix and similar platforms, a debugging
-   python and associated libraries are built by adding
-   ``--with-pydebug`` when configuring the Python build. On
-   Windows, the debugging version of Python is generated by
-   the "Win32 Debug" target of the Visual Studio project in the
-   PCBuild subdirectory of a full Python source code distribution.

doc/index.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -147,9 +144,7 @@
 
       <dt><a href="v2/faq.html">Frequently Asked Questions (FAQs)</a></dt>
       
-      <dt><a href="http://www.language-binding.net/pyplusplus/pyplusplus.html">Py++ Boost.Python code generator</a></dt>
-
-      <dt><a href="../pyste/index.html">Pyste Boost.Python code generator (no longer maintained)</a></dt>
+      <dt><a href="../pyste/index.html">Pyste (Boost.Python code generator)</a></dt>
 
       <dt><a href="internals.html">Internals Documentation</a></dt>
 
@@ -177,7 +172,7 @@
     <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
-    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
+    <p><i>&copy; Copyright <a href="../../../people/dave_abrahams.htm">Dave
     Abrahams</a> 2002-2003.</i></p>
   </body>
 </html>

doc/news.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
   <meta name="generator" content=
@@ -32,97 +29,6 @@
   <hr>
 
   <dl class="page-index">
-
-    <dt>Current SVN</dt>
-    <dd>
-      <ul>
-        <li>Python 3 support:</li>
-          <ul>
-              <li>All the current Boost.Python test cases passed. Extension modules using 
-                  Boost.Python expected to support Python 3 smoothly.</li>
-              <li>Introduced <code>object.contains</code> where <code>x.contains(y)</code>
-                   is equivalent to Python code <code>y in x</code>. 
-                  Now <code>dict.has_key</code> is just a wrapper of <code>object.contains</code>.
-              </li>
-              <li>When building against Python 3, <code>str.decode</code> will be removed.</li>
-              <li>When building against Python 3, the original signature of <code>list.sort</code>, which is:
-                  <pre>void sort(object_cref cmpfunc);</pre>
-                  will change to:
-                  <pre>void sort(args_proxy const &args, kwds_proxy const &kwds);</pre>
-
-                  This is because in Python 3 <code>list.sort</code> requires all its arguments be keyword arguments.
-                  So you should call it like this:
-                  <pre>x.sort(*tuple(), **dict(make_tuple(make_tuple("reverse", true))));</pre>
-
-              </li>
-              <li>According to <a href="http://www.python.org/dev/peps/pep-3123/">PEP 3123</a>, 
-                  when building Boost.Python against Python older than 2.6, the following macros will
-                  be defined in Boost.Python header:
-                <pre>
-# define Py_TYPE(o)    (((PyObject*)(o))->ob_type)
-# define Py_REFCNT(o)  (((PyObject*)(o))->ob_refcnt)
-# define Py_SIZE(o)    (((PyVarObject*)(o))->ob_size)</pre>
-                  So extension writers can use these macro directly, to make code clean and compatible with Python 3.
-              </li>
-          </ul> 
-      </ul>
-    </dd>
-
-    <dt>1.39.0 Release</dt>
-
-    <dd>
-      <ul>
-        <li>Pythonic signatures are now automatically appended to the
-        docstrings.
-
-        <li>Use <a href="v2/docstring_options.html"
-        ><code>docstring_options.hpp</code></a> header 
-        control the content of docstrings.
-	
-	<li>This new feature increases the size of the modules by about 14%.
-        If this is not acceptable it can be turned off by defining the macro
-        BOOST_PYTHON_NO_PY_SIGNATURES. Modules compiled with and without the macro
-        defined are compatible.
-        </li>
-	<li> If BOOST_PYTHON_NO_PY_SIGNATURES is undefined, this version defines the 
-        macro BOOST_PYTHON_SUPPORTS_PY_SIGNATURES. This allows writing code that will compile
-        with older version of Boost.Python (see <a href="v2/pytype_function.html#examples">here</a>).
-        </li>
-	<li>By defining BOOST_PYTHON_PY_SIGNATURES_PROPER_INIT_SELF_TYPE, and at a cost
-        of another 14% size increase, proper pythonic type is generated for the "self"
-        parameter of the __init__ methods.
-        </li>
-        
-        <li> To support this new feature changes were made to the 
-        <a href="v2/to_python_converter.html"><code>to_python_converter.hpp</code></a>, 
-        <a href="v2/default_call_policies.html"><code>default_call_policies</code></a>,
-        <a href="v2/ResultConverter.html"><code>ResultConverter</code></a>,
-        <a href="v2/CallPolicies.html"><code>CallPolicies</code></a> and some others.
-        Efforts were made not to have interface breaking changes. 
-        </li>
-
-      </ul>
-    </dd>
-
-    <dt>12 May 2007 - 1.34.0 release</dt>
-
-    <dd>
-      <ul>
-        <li>C++ signatures are now automatically appended to the
-        docstrings.
-
-        <li>New <a href="v2/docstring_options.html"
-        ><code>docstring_options.hpp</code></a> header to
-        control the content of docstrings.
-
-        <li>Support for converting <code>void*</code> to/from python,
-        with <code><a
-        href="v2/opaque.html">opaque_pointer_converter</a></code>
-        as the return value policy.  Thanks to Niall Douglas for the
-        initial patch.
-      </ul>
-    </dd>
-
     <dt>19 October 2005 - 1.33.1 release</dt>
 
     <dd>
@@ -291,7 +197,7 @@ BOOST_PYTHON_MODULE(test)
 
     <dd><a href="mailto:Gottfried.Ganssauge-at-haufe.de">Gottfried
     Gan&szlig;auge</a> has contributed <a href=
-    "v2/opaque.html">opaque pointer support</a>.<br>
+    "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>
@@ -365,7 +271,7 @@ BOOST_PYTHON_MODULE(test)
    19 November 2004 
   <!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
 
-  <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
+  <p><i>&copy; Copyright <a href="../../../people/dave_abrahams.htm">Dave
   Abrahams</a> 2002-2003.</i></p>
 </body>
 </html>

doc/polymorphism.txt

@@ -1,8 +1,3 @@
-.. Copyright David Abrahams 2006. Distributed under the Boost
-.. Software License, Version 1.0. (See accompanying
-.. file LICENSE_1_0.txt or copy at
-.. http://www.boost.org/LICENSE_1_0.txt)
-
 How Runtime Polymorphism is expressed in Boost.Python:
 -----------------------------------------------------
 

doc/projects.html

@@ -1,472 +1,436 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
-<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">
-  <link rel="stylesheet" type="text/css" href="boost.css">
-
-  <title>Boost.Python - Projects using Boost.Python</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">Projects using Boost.Python</h2>
-      </td>
-    </tr>
-  </table>
-  <hr>
-
-  <h2>Introduction</h2>
-
-  <p>This is a partial list of projects using Boost.Python. If you are using
-  Boost.Python as your Python/C++ binding solution, we'd be proud to list
-  your project on this page. Just <a href=
-  "mailto:c++-sig@python.org">post</a> a short description of your project
-  and how Boost.Python helps you get the job done, and we'll add it to this
-  page .</p>
-  <hr>
-
-  <h3>Data Analysis</h3>
-
-  <dl class="page-index">
-    <dt><b><a href="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>
-    acquisition systems. Neuralab combines presentation quality graphics, a
-    numerical analysis library, and the <a href=
-    "http://www.python.org">Python</a> scripting engine in a single
-    application. With Neuralab, Neuralynx users can perform common analysis
-    tasks with just a few mouse clicks. More advanced users can create custom
-    Python scripts, which can optionally be assigned to menus and mouse
-    clicks.</dd>
-  </dl>
-
-  <dl class="page-index">
-    <dt><b>TSLib</b> - <a href="http://www.fortressinv.com">Fortress
-    Investment Group LLC</a></dt>
-
-    <dd>
-      Fortress Investment Group has contracted <a href=
-      "http://www.boost-consulting.com">Boost Consulting</a> to develop core
-      internal financial analysis tools in C++ and to prepare Python bindings
-      for them using Boost.Python.
-
-      <p>Tom Barket of Fortress writes:</p>
-
-      <blockquote>
-        We have a large C++ analytical library specialized for research in
-        finance and economics, built for speed and mission critical
-        stability. Yet Python offers us the flexibility to test out new ideas
-        quickly and increase the productivity of our time versus working in
-        C++. There are several key features which make Python stand out. Its
-        elegance, stability, and breadth of resources on the web are all
-        valuable, but the most important is its extensibility, due to its
-        open source transparency. Boost.Python makes Python extensibility
-        extremely simple and straightforward, yet preserves a great deal of
-        power and control.
-      </blockquote>
-    </dd>
-  </dl>
-
-  <h3>Educational</h3>
-
-  <dl class="page-index">
-    <dt><a href="http://edu.kde.org/kig"><b>Kig</b></a></dt>
-
-    <dd>
-      <p>KDE Interactive Geometry is a high-school level educational tool,
-      built for the KDE desktop. It is a nice tool to let students work with
-      geometrical constructions. It is meant to be the most intuitive, yet
-      featureful application of its kind.</p>
-
-      <p>Versions after 0.6.x (will) support objects built by the user
-      himself in the Python language. The exporting of the relevant internal
-      API's were done using Boost.Python, which made the process very
-      easy.</p>
-    </dd>
-  </dl>
-
-  <h3>Enterprise Software</h3>
-
-  <dl class="page-index">
-    <dt><b><a href="http://openwbem.sourceforge.net">OpenWBEM</a></b></dt>
-
-    <dd>
-      The OpenWBEM project is an effort to develop an open-source
-      implementation of Web Based Enterprise Management suitable for
-      commercial and non-commercial application
-
-      <p><a href="mailto:dnuffer@sco.com">Dan Nuffer</a> writes:</p>
-
-      <blockquote>
-        I'm using Boost.Python to wrap the client API of OpenWBEM.This will
-        make it easier to do rapid prototyping, testing, and scripting when
-        developing management solutions that use WBEM.
-      </blockquote>
-    </dd>
-
-    <dt><b><a href="http://www.transversal.com">Metafaq</a></b></dt>
-
-    <dd>
-      Metafaq, from <a href="http://www.transversal.com">Transversal,
-      Inc.</a>, is an enterprise level online knowledge base management
-      system.
-
-      <p><a href="mailto:ben.young-at-transversal.com">Ben Young</a>
-      writes:</p>
-
-      <blockquote>
-        Boost.Python is used in an automated process to generate python
-        bindings to our api which is exposed though multiple backends and
-        frontends. This allows us to write quick tests and bespoke scripts to
-        perform one off tasks without having to go through the full
-        compilation cycle.
-      </blockquote>
-    </dd>
-  </dl>
-
-  <h3>Games</h3>
-
-  <dl>
-    <dt><b><a href="http://www.firaxis.com">Civilization IV</a></b></dt>
-  </dl>
-
-  <blockquote>
-    &ldquo;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>&rdquo;</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>
-
-    <dd>
-      <a href="http://vegastrike.sourceforge.net">Vega Strike</a> is the 3D
-      Space Simulator that allows you to trade and bounty hunt in a vast
-      universe. Players face dangers, decisions, piracy, and aliens.
-
-      <p><a href="http://vegastrike.sourceforge.net">Vega Strike</a> has
-      decided to base its scripting on python, using boost as the layer
-      between the class hierarchy in python and the class hierarchy in C++.
-      The result is a very flexible scripting system that treats units as
-      native python classes when designing missions or writing AI's.</p>
-
-      <p>A large economic and planetary simulation is currently being run in
-      the background in python and the results are returned back into C++ in
-      the form of various factions' spaceships appearing near worlds that
-      they are simulated to be near in python if the player is in the general
-      neighborhood.</p>
-    </dd>
-  </dl>
-
-  <h3>Graphics</h3>
-
-  <dl class="page-index">
-    <dt><b><a href="http://sourceforge.net/projects/pyosg">OpenSceneGraph
-    Bindings</a></b></dt>
-
-    <dd><a href="mailto:gideon@computer.org">Gideon May</a> has created a set
-    of bindings for <a href=
-    "http://www.openscenegraph.org">OpenSceneGraph</a>, a cross-platform
-    C++/OpenGL library for the real-time visualization.<br>
-    &nbsp;</dd>
-
-    <dt><b><a href=
-    "http://www.slac.stanford.edu/grp/ek/hippodraw/index.html">HippoDraw</a></b></dt>
-
-    <dd>
-      HippoDraw is a data analysis environment consisting of a canvas upon
-      which graphs such as histograms, scattter plots, etc, are prsented. It
-      has a highly interactive GUI interface, but some things you need to do
-      with scripts. HippoDraw can be run as Python extension module so that
-      all the manipulation can be done from either Python or the GUI.
-
-      <p>Before the web page came online, <a href=
-      "mailto:Paul_Kunz@SLAC.Stanford.EDU">Paul F. Kunz</a> wrote:</p>
-
-      <blockquote>
-        Don't have a web page for the project, but the organization's is
-        <a href=
-        "http://www.slac.stanford.edu">http://www.slac.stanford.edu</a> (the
-        first web server site in America, I installed it).
-      </blockquote>Which was just too cool a piece of trivia to omit.<br>
-      &nbsp;
-    </dd>
-
-    <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:
-
-      <blockquote>
-        IPLT is an image processing library and toolbox for the structural
-        biology electron microscopy community. I would call it a
-        budding/evolving project, since it is currently not in production
-        stage, but rather under heavy development. Python is used as the main
-        scripting/interaction level, but also for rapid prototyping, since
-        the underlying C++ class library is pretty much fully exposed via
-        boost.python (at least the high-level interface). The combined power
-        of C++ and Python for this project turned out to be just awesome.
-      </blockquote><br>
-      &nbsp;
-    </dd>
-
-    <dt><a href=
-    "http://www.procoders.net/pythonmagick"><b>PythonMagick</b></a></dt>
-
-    <dd>PythonMagick binds the <a href=
-    "http://www.graphicsmagick.org">GraphicsMagick</a> image manipulation
-    library to Python.<br>
-    &nbsp;</dd>
-
-    <dt><a href="http://www.vpython.org"><b>VPython</b></a></dt>
-
-    <dd>
-      <a href="mailto:Bruce_Sherwood-at-ncsu.edu">Bruce Sherwood</a> writes:
-
-      <blockquote>
-        VPython is an extension for Python that makes it easy to create
-        navigable 3D animations, which are generated as a side effect of
-        computational code. VPython is used in education for various
-        purposes, including teaching physics and programming, but it has also
-        been used by research scientists to visualize systems or data in 3D.
-      </blockquote><br>
-      &nbsp;
-    </dd>
-  </dl>
-
-  <h3>Scientific Computing</h3>
-
-  <dl class="page index">
-    <dt><a href="http://camfr.sourceforge.net"><b>CAMFR</b></a></dt>
-
-    <dd>
-      CAMFR is a photonics and electromagnetics modelling tool. Python is
-      used for computational steering.
-
-      <p><a href="mailto:Peter.Bienstman@rug.ac.be">Peter Bienstman</a>
-      writes:</p>
-
-      <blockquote>
-        Thanks for providing such a great tool!
-      </blockquote>
-    </dd>
-
-    <dt><a href="http://cctbx.sourceforge.net"><b>cctbx - Computational
-    Crystallography Toolbox</b></a></dt>
-
-    <dd>
-      Computational Crystallography is concerned with the derivation of
-      atomic models of crystal structures, given experimental X-ray
-      diffraction data. The cctbx is an open-source library of fundamental
-      algorithms for crystallographic computations. The core algorithms are
-      implemented in C++ and accessed through higher-level Python interfaces.
-
-      <p>The cctbx grew together with Boost.Python and is designed from the
-      ground up as a hybrid Python/C++ system. With one minor exception,
-      run-time polymorphism is completely handled by Python. C++ compile-time
-      polymorphism is used to implement performance critical algorithms. The
-      Python and C++ layers are seamlessly integrated using Boost.Python.</p>
-
-      <p>The SourceForge cctbx project is organized in modules to facilitate
-      use in non-crystallographic applications. The scitbx module implements
-      a general purpose array family for scientific applications and pure C++
-      ports of FFTPACK and the L-BFGS quasi-Newton minimizer.</p>
-    </dd>
-
-    <dt><a href="http://www.llnl.gov/CASC/emsolve"><b>EMSolve</b></a></dt>
-
-    <dd>EMSolve is a provably stable, charge conserving, and energy
-    conserving solver for Maxwell's equations.<br>
-    &nbsp;</dd>
-
-    <dt><b><a href="http://cern.ch/gaudi">Gaudi</a></b> and <b><a href=
-    "http://cern.ch/Gaudi/RootPython/">RootPython</a></b></dt>
-
-    <dd>
-      Gaudi is a framework for particle physics collision data processing
-      applications developed in the context of the LHCb and ATLAS experiments
-      at CERN.
-
-      <p><a href="mailto:Pere.Mato@cern.ch">Pere Mato Vila</a> writes:</p>
-
-      <blockquote>
-        We are using Boost.Python to provide scripting/interactive capability
-        to our framework. We have a module called "GaudiPython" implemented
-        using Boost.Python that allows the interaction with any framework
-        service or algorithm from python. RootPython also uses Boost.Python
-        to provide a generic "gateway" between the <a href=
-        "http://root.cern.ch">ROOT</a> framework and python
-
-        <p>Boost.Python is great. We managed very quickly to interface our
-        framework to python, which is great language. We are trying to
-        facilitate to our physicists (end-users) a rapid analysis application
-        development environment based on python. For that, Boost.Python plays
-        and essential role.</p>
-      </blockquote>
-    </dd>
-
-    <dt><b><a href="http://www.esss.com.br">ESSS</a></b></dt>
-
-    <dd>
-      ESSS (Engineering Simulation and Scientific Software) is a company that
-      provides engineering solutions and acts in the brazilian and
-      south-american market providing products and services related to
-      Computational Fluid Dynamics and Image Analysis.
-
-      <p><a href="mailto:bruno@esss.com.br">Bruno da Silva de Oliveira</a>
-      writes:</p>
-
-      <blockquote>
-        Recently we moved our work from working exclusively with C++ to an
-        hybrid-language approach, using Python and C++, with Boost.Python
-        providing the layer between the two. The results are great so far!
-      </blockquote>
-
-      <p>Two projects have been developed so far with this technology:</p>
-
-      <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/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 results.</p>
-    </dd>
-
-    <dt><b><a href="http://polybori.sourceforge.net/">PolyBoRi</a></b></dt>
-
-    <dd>
-      <p><a href="mailto:brickenstein@mfo.de"
-        >Michael Brickenstein</a> writes:</p>
-
-      <blockquote>
-        <p>The core of PolyBoRi is a C++ library, which provides
-        high-level data types for Boolean polynomials and monomials,
-        exponent vectors, as well as for the underlying polynomial
-        rings and subsets of the powerset of the Boolean variables. As
-        a unique approach, binary decision diagrams are used as
-        internal storage type for polynomial structures. On top of
-        this C++-library we provide a Python interface. This allows
-        parsing of complex polynomial systems, as well as sophisticated
-        and extendable strategies for Gr&ouml;bner basis computation.
-        Boost.Python has helped us to create this interface in a
-        very clean way.</p>
-      </blockquote>
-    </dd>
-
-    <dt><b><a href="http://pyrap.googlecode.com/">Pyrap</a></b></dt>
-    <dd>
-      <p><a href="diepen@astron.nl"
-        >Ger van Diepen</a> writes:</p>
-
-      <blockquote>
-        <p>Pyrap is the python interface to the Radio-Astronomical Package
-        casacore (<a href="http://casacore.googlecode.com/"
-        >casacore.googlecode.com</a>). Astronomers love pyrap because
-        it makes it easily possible to get their data (observed with
-        radio-astronomical telescopes like LOFAR, ASKAP, and eVLA) in numpy
-        arrays and do basic data inspection and manipulation using the many
-        python packages that are available.</p>
-
-        <p>Boost.Python made it quite easily possible to create converters for
-        the various data types, also for numpy arrays and individual elements
-        of a numpy array. It's nice they work fully recursively. Mapping C++
-        functions to Python was straightforward.</p>
-      </blockquote>
-    </dd>
-
-    <dt><b><a href="http://www.rdkit.org/"
-           >RDKit: Cheminformatics and Machine Learning Software</a></b></dt>
-
-    <dd>
-      A collection of cheminformatics and machine-learning software
-      written in C++ and Python.
-    </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>
-    <dt><a href="http://www.jayacard.org"><b>Jayacard</b></a></dt>
-
-    <dd>
-      Jayacard aims at developing a secure portable open source operating
-      system for contactless smart cards and a complete suite of high quality
-      development tools to ease smart card OS and application development.
-
-      <p>The core of the smart card reader management is written in C++ but
-      all the development tools are written in the friendly Python language.
-      Boost plays the fundamental role of binding the tools to our core smart
-      card reader library.</p>
-    </dd>
-  </dl>
-  <hr>
-
-  <p>Revised
-  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-   29 May, 2008</p>
-
-  <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
-  Abrahams</a> 2002-2008.</i></p>
-</body>
+  <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="utf-8">
+    <link rel="stylesheet" type="text/css" href="boost.css">
+
+    <title>Boost.Python - Projects using Boost.Python</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">Projects using Boost.Python</h2>
+        </td>
+      </tr>
+    </table>
+    <hr>
+
+    <h2>Introduction</h2>
+
+    <p>This is a partial list of projects using Boost.Python. If you are
+    using Boost.Python as your Python/C++ binding solution, we'd be proud to
+    list your project on this page. Just <a href=
+    "mailto:c++-sig@python.org">post</a> a short description of your project
+    and how Boost.Python helps you get the job done, and we'll add it to this
+    page .</p>
+    <hr>
+
+    <h3>Data Analysis</h3>
+
+    <dl class="page-index">
+      <dt><b><a href=
+      "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>
+      acquisition systems. Neuralab combines presentation quality graphics, a
+      numerical analysis library, and the <a href=
+      "http://www.python.org">Python</a> scripting engine in a single
+      application. With Neuralab, Neuralynx users can perform common analysis
+      tasks with just a few mouse clicks. More advanced users can create
+      custom Python scripts, which can optionally be assigned to menus and
+      mouse clicks.</dd>
+    </dl>
+
+    <dl class="page-index">
+      <dt><b>TSLib</b> - <a href="http://www.fortressinv.com">Fortress
+      Investment Group LLC</a></dt>
+
+      <dd>
+        Fortress Investment Group has contracted <a href=
+        "http://www.boost-consulting.com">Boost Consulting</a> to develop
+        core internal financial analysis tools in C++ and to prepare Python
+        bindings for them using Boost.Python. 
+
+        <p>Tom Barket of Fortress writes:</p>
+
+        <blockquote>
+          We have a large C++ analytical library specialized for research in
+          finance and economics, built for speed and mission critical
+          stability. Yet Python offers us the flexibility to test out new
+          ideas quickly and increase the productivity of our time versus
+          working in C++. There are several key features which make Python
+          stand out. Its elegance, stability, and breadth of resources on the
+          web are all valuable, but the most important is its extensibility,
+          due to its open source transparency. Boost.Python makes Python
+          extensibility extremely simple and straightforward, yet preserves a
+          great deal of power and control.
+        </blockquote>
+      </dd>
+    </dl>
+
+    <h3>Educational</h3>
+
+    <dl class="page-index">
+      <dt><a href="http://edu.kde.org/kig"><b>Kig</b></a></dt>
+
+      <dd>
+        <p>KDE Interactive Geometry is a high-school level educational tool,
+        built for the KDE desktop. It is a nice tool to let students work
+        with geometrical constructions. It is meant to be the most intuitive,
+        yet featureful application of its kind.</p>
+
+        <p>Versions after 0.6.x (will) support objects built by the user
+        himself in the Python language. The exporting of the relevant
+        internal API's were done using Boost.Python, which made the process
+        very easy.</p>
+      </dd>
+    </dl>
+
+    <h3>Enterprise Software</h3>
+
+    <dl class="page-index">
+      <dt><b><a href="http://openwbem.sourceforge.net">OpenWBEM</a></b></dt>
+
+      <dd>
+        The OpenWBEM project is an effort to develop an open-source
+        implementation of Web Based Enterprise Management suitable for
+        commercial and non-commercial application 
+
+        <p><a href="mailto:dnuffer@sco.com">Dan Nuffer</a> writes:</p>
+
+        <blockquote>
+          I'm using Boost.Python to wrap the client API of OpenWBEM.This will
+          make it easier to do rapid prototyping, testing, and scripting when
+          developing management solutions that use WBEM.
+        </blockquote>
+      </dd>
+
+      <dt><b><a href="http://www.transversal.com">Metafaq</a></b></dt>
+
+      <dd>
+        Metafaq, from <a href="http://www.transversal.com">Transversal,
+        Inc.</a>, is an enterprise level online knowledge base management
+        system. 
+
+        <p><a href="mailto:ben.young-at-transversal.com">Ben Young</a>
+        writes:</p>
+
+        <blockquote>
+          Boost.Python is used in an automated process to generate python
+          bindings to our api which is exposed though multiple backends and
+          frontends. This allows us to write quick tests and bespoke scripts
+          to perform one off tasks without having to go through the full
+          compilation cycle.
+        </blockquote>
+      </dd>
+    </dl>
+
+    <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>
+
+      <dd>
+        <a href="http://vegastrike.sourceforge.net">Vega Strike</a> is the 3D
+        Space Simulator that allows you to trade and bounty hunt in a vast
+        universe. Players face dangers, decisions, piracy, and aliens. 
+
+        <p><a href="http://vegastrike.sourceforge.net">Vega Strike</a> has
+        decided to base its scripting on python, using boost as the layer
+        between the class hierarchy in python and the class hierarchy in C++.
+        The result is a very flexible scripting system that treats units as
+        native python classes when designing missions or writing AI's.</p>
+
+        <p>A large economic and planetary simulation is currently being run
+        in the background in python and the results are returned back into
+        C++ in the form of various factions' spaceships appearing near worlds
+        that they are simulated to be near in python if the player is in the
+        general neighborhood.</p>
+      </dd>
+    </dl>
+
+    <h3>Graphics</h3>
+
+    <dl class="page-index">
+      <dt><b><a href="http://sourceforge.net/projects/pyosg">OpenSceneGraph
+      Bindings</a></b></dt>
+
+      <dd><a href="mailto:gideon@computer.org">Gideon May</a> has created a
+      set of bindings for <a href=
+      "http://www.openscenegraph.org">OpenSceneGraph</a>, a cross-platform
+      C++/OpenGL library for the real-time visualization.<br>
+       &nbsp;</dd>
+
+      <dt><b><a href=
+      "http://www.slac.stanford.edu/grp/ek/hippodraw/index.html">HippoDraw</a></b></dt>
+
+      <dd>
+        HippoDraw is a data analysis environment consisting of a canvas upon
+        which graphs such as histograms, scattter plots, etc, are prsented.
+        It has a highly interactive GUI interface, but some things you need
+        to do with scripts. HippoDraw can be run as Python extension module
+        so that all the manipulation can be done from either Python or the
+        GUI. 
+
+        <p>Before the web page came online, <a href=
+        "mailto:Paul_Kunz@SLAC.Stanford.EDU">Paul F. Kunz</a> wrote:</p>
+
+        <blockquote>
+          Don't have a web page for the project, but the organization's is <a
+          href=
+          "http://www.slac.stanford.edu">http://www.slac.stanford.edu</a>
+          (the first web server site in America, I installed it).
+        </blockquote>
+        Which was just too cool a piece of trivia to omit.<br>
+         &nbsp;
+      </dd>
+
+      <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: 
+
+        <blockquote>
+          IPLT is an image processing library and toolbox for the structural
+          biology electron microscopy community. I would call it a
+          budding/evolving project, since it is currently not in production
+          stage, but rather under heavy development. Python is used as the
+          main scripting/interaction level, but also for rapid prototyping,
+          since the underlying C++ class library is pretty much fully exposed
+          via boost.python (at least the high-level interface). The combined
+          power of C++ and Python for this project turned out to be just
+          awesome.
+        </blockquote>
+        <br>
+         &nbsp;
+      </dd>
+
+      <dt><a href=
+      "http://www.procoders.net/pythonmagick"><b>PythonMagick</b></a></dt>
+
+      <dd>PythonMagick binds the <a href=
+      "http://www.graphicsmagick.org">GraphicsMagick</a> image manipulation
+      library to Python.<br>
+       &nbsp;</dd>
+    </dl>
+
+    <h3>Scientific Computing</h3>
+
+    <dl class="page index">
+      <dt><a href="http://camfr.sourceforge.net"><b>CAMFR</b></a></dt>
+
+      <dd>
+        CAMFR is a photonics and electromagnetics modelling tool. Python is
+        used for computational steering. 
+
+        <p><a href="mailto:Peter.Bienstman@rug.ac.be">Peter Bienstman</a>
+        writes:</p>
+
+        <blockquote>
+          Thanks for providing such a great tool!
+        </blockquote>
+      </dd>
+
+      <dt><a href="http://cctbx.sourceforge.net"><b>cctbx - Computational
+      Crystallography Toolbox</b></a></dt>
+
+      <dd>
+        Computational Crystallography is concerned with the derivation of
+        atomic models of crystal structures, given experimental X-ray
+        diffraction data. The cctbx is an open-source library of fundamental
+        algorithms for crystallographic computations. The core algorithms are
+        implemented in C++ and accessed through higher-level Python
+        interfaces. 
+
+        <p>The cctbx grew together with Boost.Python and is designed from the
+        ground up as a hybrid Python/C++ system. With one minor exception,
+        run-time polymorphism is completely handled by Python. C++
+        compile-time polymorphism is used to implement performance critical
+        algorithms. The Python and C++ layers are seamlessly integrated using
+        Boost.Python.</p>
+
+        <p>The SourceForge cctbx project is organized in modules to
+        facilitate use in non-crystallographic applications. The scitbx
+        module implements a general purpose array family for scientific
+        applications and pure C++ ports of FFTPACK and the LBFGS conjugate
+        gradient minimizer.</p>
+      </dd>
+
+      <dt><a href="http://www.llnl.gov/CASC/emsolve"><b>EMSolve</b></a></dt>
+
+      <dd>EMSolve is a provably stable, charge conserving, and energy
+      conserving solver for Maxwell's equations.<br>
+       &nbsp;</dd>
+
+      <dt><b><a href="http://cern.ch/gaudi">Gaudi</a></b> and <b><a href=
+      "http://cern.ch/Gaudi/RootPython/">RootPython</a></b></dt>
+
+      <dd>
+        Gaudi is a framework for particle physics collision data processing
+        applications developed in the context of the LHCb and ATLAS
+        experiments at CERN. 
+
+        <p><a href="mailto:Pere.Mato@cern.ch">Pere Mato Vila</a> writes:</p>
+
+        <blockquote>
+          We are using Boost.Python to provide scripting/interactive
+          capability to our framework. We have a module called "GaudiPython"
+          implemented using Boost.Python that allows the interaction with any
+          framework service or algorithm from python. RootPython also uses
+          Boost.Python to provide a generic "gateway" between the <a href=
+          "http://root.cern.ch">ROOT</a> framework and python 
+
+          <p>Boost.Python is great. We managed very quickly to interface our
+          framework to python, which is great language. We are trying to
+          facilitate to our physicists (end-users) a rapid analysis
+          application development environment based on python. For that,
+          Boost.Python plays and essential role.</p>
+        </blockquote>
+      </dd>
+
+      <dt><b><a href="http://www.esss.com.br">ESSS</a></b></dt>
+
+      <dd>
+        ESSS (Engineering Simulation and Scientific Software) is a company
+        that provides engineering solutions and acts in the brazilian and
+        south-american market providing products and services related to
+        Computational Fluid Dynamics and Image Analysis. 
+
+        <p><a href="mailto:bruno@esss.com.br">Bruno da Silva de Oliveira</a>
+        writes:</p>
+
+        <blockquote>
+          Recently we moved our work from working exclusively with C++ to an
+          hybrid-language approach, using Python and C++, with Boost.Python
+          providing the layer between the two. The results are great so far!
+        </blockquote>
+
+        <p>Two projects have been developed so far with this technology:</p>
+
+        <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/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
+        results.</p>
+      </dd>
+
+      <dt><b><a href="http://www.rationaldiscovery.com">Rational Discovery
+      LLC</a></b></dt>
+
+      <dd>
+        Rational Discovery provides computational modeling, combinatorial
+        library design and custom software development services to the
+        pharmaceutical, biotech and chemical industries. We do a substantial
+        amount of internal research to develop new approaches for applying
+        machine-learning techniques to solve chemical problems. Because we're
+        a small organization and chemistry is a large and complex field, it
+        is essential that we be able to quickly and easily prototype and test
+        new algorithms. 
+
+        <p>For our internal software, we implement core data structures in C
+        and expose them to Python using Boost.Python. Algorithm development
+        is done in Python and then translated to C if required (often it's
+        not). This hybrid development approach not only greatly increases our
+        productivity, but it also allows "non-developers" (people without C
+        experience) to take part in method development. Learning C is a
+        daunting task, but "Python fits your brain." (Thanks to Bruce Eckel
+        for the quote.)</p>
+      </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>
+      <dt><a href="http://www.jayacard.org"><b>Jayacard</b></a></dt>
+
+      <dd>
+        Jayacard aims at developing a secure portable open source operating
+        system for contactless smart cards and a complete suite of high
+        quality development tools to ease smart card OS and application
+        development. 
+
+        <p>The core of the smart card reader management is written in C++ but
+        all the development tools are written in the friendly Python
+        language. Boost plays the fundamental role of binding the tools to
+        our core smart card reader library.</p>
+      </dd>
+    </dl>
+    <hr>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     15 July, 2003</p>
+
+    <p><i>&copy; Copyright <a href="../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002-2003.</i></p>
+  </body>
 </html>
+

doc/support.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -67,7 +64,7 @@
      12 Sept, 2003 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
-    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
+    <p><i>&copy; Copyright <a href="../../../people/dave_abrahams.htm">Dave
     Abrahams</a> 2003.</i></p>
   </body>
 </html>

doc/tutorial/doc/Jamfile.v2

@@ -1,18 +1,12 @@
-# Copyright Joel de Guzman 2006. Distributed under the Boost
-# Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 project boost/libs/python/doc/tutorial/doc ;
 
 import boostbook : boostbook ;
 using quickbook ;
 
-path-constant images : html ;
-
 boostbook tutorial
     :
         tutorial.qbk
     :
         <xsl:param>boost.root=../../../../../..
-        <format>pdf:<xsl:param>img.src.path=$(images)/
-        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/python/doc/tutorial/doc/html
+        <xsl:param>boost.libraries=../../../../../../libs/libraries.htm
     ;

doc/tutorial/doc/html/boostbook.css

@@ -0,0 +1,430 @@
+/*=============================================================================
+    Copyright (c) 2004 Joel de Guzman
+    http://spirit.sourceforge.net/
+
+    Use, modification and distribution is subject to the Boost Software
+    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+
+/*=============================================================================
+    Body defaults
+=============================================================================*/
+
+    body 
+    {
+        margin: 1em;
+        font-family: sans-serif;
+    }
+
+/*=============================================================================
+    Paragraphs
+=============================================================================*/
+
+    p 
+    {
+        text-align: justify;
+        font-size: 11pt; 
+        line-height: 1.2;
+    }
+
+/*=============================================================================
+    Program listings
+=============================================================================*/
+
+    tt.computeroutput
+    {
+        font-size: 10pt;
+    }
+
+    pre.synopsis
+    {
+        font-size: 10pt;
+        margin: 1pc 4% 0pc 4%;
+        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+    }
+
+    .programlisting, 
+    .screen
+    {
+        font-size: 10pt;
+        display: block;
+        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% }
+    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
+    {
+        font-weight: bold;
+        margin-bottom: 1pc;
+    }
+
+    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
+    {
+        font-size: 11pt;
+        line-height: 1.3;
+    }
+    
+    /* Unordered lists */
+    ul 
+    {
+        text-align: justify;
+    }
+    
+    /* Ordered lists */
+    ol 
+    {
+        text-align: justify;
+    }
+
+/*=============================================================================
+    Links
+=============================================================================*/
+
+    a
+    {
+        text-decoration: none; /* no underline */
+    }
+    
+    a:hover
+    {
+        text-decoration: underline;
+    }
+
+/*=============================================================================
+    Spirit style navigation
+=============================================================================*/
+
+    .spirit-nav
+    {
+        text-align: right;
+    }
+    
+    .spirit-nav a
+    {
+        color: white;
+        padding-left: 0.5em;
+    }
+    
+    .spirit-nav img
+    {
+        border-width: 0px;
+    }
+
+/*=============================================================================
+    Table of contents
+=============================================================================*/
+
+    .toc
+    {
+       margin: 1pc 4% 0pc 4%;
+       padding: 0.5pc;
+       font-size: 11pt; 
+       line-height: 1.3;
+    }
+    
+    .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;
+    }
+    
+    /* Table Cells */
+    div.informaltable table tr td, 
+    div.table table tr td
+    {
+        padding: 0.5em;
+        text-align: justify;
+        font-size: 11pt;
+    }
+
+    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

@@ -1,40 +1,42 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Chapter&#160;1.&#160;python 2.0</title>
-<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="next" href="python/hello.html" title="Building Hello World">
+<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.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%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<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="../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</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>
-</tr></table>
+</table>
 <hr>
-<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a></div>
-<div class="chapter">
+<div class="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><h2 class="title">
-<a name="python"></a>Chapter&#160;1.&#160;python 2.0</h2></div>
+<a name="python"></a>Chapter 1. python 1.0</h2></div>
 <div><div class="author"><h3 class="author">
 <span class="firstname">Joel</span> <span class="surname">de Guzman</span>
 </h3></div></div>
 <div><div class="author"><h3 class="author">
 <span class="firstname">David</span> <span class="surname">Abrahams</span>
 </h3></div></div>
-<div><p class="copyright">Copyright &#169; 2002-2005 Joel
-      de Guzman, David Abrahams</p></div>
+<div><p class="copyright">Copyright © 2002-2005 Joel de Guzman, David Abrahams</p></div>
 <div><div class="legalnotice">
-<a name="python.legal"></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>)
+<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>
@@ -42,8 +44,8 @@
 <p><b>Table of Contents</b></p>
 <dl>
 <dt><span class="section"><a href="index.html#python.quickstart">QuickStart</a></span></dt>
-<dt><span class="section"><a href="python/hello.html">Building Hello World</a></span></dt>
-<dt><span class="section"><a href="python/exposing.html">Exposing Classes</a></span></dt>
+<dt><span class="section"><a href="python/hello.html"> Building Hello World</a></span></dt>
+<dt><span class="section"><a href="python/exposing.html"> Exposing Classes</a></span></dt>
 <dd><dl>
 <dt><span class="section"><a href="python/exposing.html#python.constructors">Constructors</a></span></dt>
 <dt><span class="section"><a href="python/exposing.html#python.class_data_members">Class Data Members</a></span></dt>
@@ -60,19 +62,18 @@
 <dt><span class="section"><a href="python/functions.html#python.default_arguments">Default Arguments</a></span></dt>
 <dt><span class="section"><a href="python/functions.html#python.auto_overloading">Auto-Overloading</a></span></dt>
 </dl></dd>
-<dt><span class="section"><a href="python/object.html">Object Interface</a></span></dt>
+<dt><span class="section"><a href="python/object.html"> Object Interface</a></span></dt>
 <dd><dl>
 <dt><span class="section"><a href="python/object.html#python.basic_interface">Basic Interface</a></span></dt>
 <dt><span class="section"><a href="python/object.html#python.derived_object_types">Derived Object types</a></span></dt>
 <dt><span class="section"><a href="python/object.html#python.extracting_c___objects">Extracting C++ objects</a></span></dt>
 <dt><span class="section"><a href="python/object.html#python.enums">Enums</a></span></dt>
-<dt><span class="section"><a href="python/object.html#python.creating_python_object">Creating <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">object</span></code> from <code class="computeroutput"><span class="identifier">PyObject</span><span class="special">*</span></code></a></span></dt>
 </dl></dd>
 <dt><span class="section"><a href="python/embedding.html">Embedding</a></span></dt>
 <dd><dl><dt><span class="section"><a href="python/embedding.html#python.using_the_interpreter">Using the interpreter</a></span></dt></dl></dd>
 <dt><span class="section"><a href="python/iterators.html">Iterators</a></span></dt>
-<dt><span class="section"><a href="python/exception.html">Exception Translation</a></span></dt>
-<dt><span class="section"><a href="python/techniques.html">General Techniques</a></span></dt>
+<dt><span class="section"><a href="python/exception.html"> Exception Translation</a></span></dt>
+<dt><span class="section"><a href="python/techniques.html"> General Techniques</a></span></dt>
 <dd><dl>
 <dt><span class="section"><a href="python/techniques.html#python.creating_packages">Creating Packages</a></span></dt>
 <dt><span class="section"><a href="python/techniques.html#python.extending_wrapped_objects_in_python">Extending Wrapped Objects in Python</a></span></dt>
@@ -80,63 +81,54 @@
 </dl></dd>
 </dl>
 </div>
-<div class="section">
+<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>
 <p>
-      The Boost Python Library is a framework for interfacing Python and C++. It
-      allows you to quickly and seamlessly expose C++ classes functions and objects
-      to Python, and vice-versa, using no special tools -- just your C++ compiler.
-      It is designed to wrap C++ interfaces non-intrusively, so that you should not
-      have to change the C++ code at all in order to wrap it, making Boost.Python
-      ideal for exposing 3rd-party libraries to Python. The library's use of advanced
-      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>
-<h3>
-<a name="quickstart.hello_world"></a>
-      Hello World
-    </h3>
+The Boost Python Library is a framework for interfacing Python and
+C++. It allows you to quickly and seamlessly expose C++ classes
+functions and objects to Python, and vice-versa, using no special
+tools -- just your C++ compiler. It is designed to wrap C++ interfaces
+non-intrusively, so that you should not have to change the C++ code at
+all in order to wrap it, making Boost.Python ideal for exposing
+3rd-party libraries to Python. The library's use of advanced
+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="id372086"></a>Hello World</h2>
 <p>
-      Following C/C++ tradition, let's start with the "hello, world". A
-      C++ Function:
-    </p>
-<pre class="programlisting"><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="identifier">greet</span><span class="special">()</span>
-<span class="special">{</span>
-   <span class="keyword">return</span> <span class="string">"hello, world"</span><span class="special">;</span>
-<span class="special">}</span>
-</pre>
+Following C/C++ tradition, let's start with the "hello, world". A C++
+Function:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">char</span><span class="keyword"> const</span><span class="special">*</span><span class="identifier"> greet</span><span class="special">()</span><span class="special">
+{</span><span class="keyword">
+   return</span><span class="string"> "hello, world"</span><span class="special">;</span><span class="special">
+}</span></tt></pre>
 <p>
-      can be exposed to Python by writing a Boost.Python wrapper:
-    </p>
-<pre class="programlisting"><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>
+can be exposed to Python by writing a Boost.Python wrapper:</p>
+<pre class="programlisting"><tt class="literal"><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">
+using</span><span class="keyword"> namespace</span><span class="identifier"> boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">;</span><span class="identifier">
 
-<span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello_ext</span><span class="special">)</span>
-<span class="special">{</span>
-    <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">;</span>
-    <span class="identifier">def</span><span class="special">(</span><span class="string">"greet"</span><span class="special">,</span> <span class="identifier">greet</span><span class="special">);</span>
-<span class="special">}</span>
-</pre>
+BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello</span><span class="special">)</span><span class="special">
+{</span><span class="identifier">
+    def</span><span class="special">(</span><span class="string">"greet"</span><span class="special">,</span><span class="identifier"> greet</span><span class="special">);</span><span class="special">
+}</span></tt></pre>
 <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"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello_ext</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">hello_ext</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>
-</pre>
-<div class="blockquote"><blockquote class="blockquote"><p>
-        <span class="emphasis"><em><span class="bold"><strong>Next stop... Building your Hello World module
-        from start to finish...</strong></span></em></span>
-      </p></blockquote></div>
+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>
+<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"><p><small>Last revised: December 26, 2011 at 21:58:39 GMT</small></p></td>
-<td align="right"><div class="copyright-footer"></div></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>
-<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="images/next.png" alt="Next"></a></div>
 </body>
 </html>

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

@@ -1,72 +1,65 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Embedding</title>
-<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="prev" href="object.html" title="Object Interface">
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="prev" href="object.html" title=" Object Interface">
 <link rel="next" href="iterators.html" title="Iterators">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<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="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</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>
-</tr></table>
+</table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="object.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<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">
+<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 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 Python.
-      However, sometimes you may need to do the reverse: call Python code from the
-      C++-side. This requires you to <span class="emphasis"><em>embed</em></span> the Python interpreter
-      into your C++ program.
-    </p>
+By now you should know how to use Boost.Python to call your C++ code from
+Python. However, sometimes you may need to do the reverse: call Python code
+from the C++-side. This requires you to <span class="emphasis"><em>embed</em></span> the Python interpreter
+into your C++ program.</p>
 <p>
-      Currently, Boost.Python does not directly support everything you'll need when
-      embedding. Therefore you'll need to use the <a href="http://www.python.org/doc/current/api/api.html" target="_top">Python/C
-      API</a> to fill in 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" alt="smiley"></span>
-    </p>
-<h3>
-<a name="embedding.building_embedded_programs"></a>
-      Building embedded programs
-    </h3>
+Currently, Boost.Python does not directly support everything you'll need
+when embedding. Therefore you'll need to use the
+<a href="http://www.python.org/doc/current/api/api.html" target="_top">Python/C API</a> to fill in
+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="id456196"></a>Building embedded programs</h2>
 <p>
-      To be able to embed python into your programs, you have to link to both Boost.Python's
-      as well as Python's own runtime library.
-    </p>
+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>
 <p>
-      Boost.Python's library comes in two variants. Both are located in Boost's
-      <code class="literal">/libs/python/build/bin-stage</code> subdirectory. On Windows, the
-      variants are called <code class="literal">boost_python.lib</code> (for release builds)
-      and <code class="literal">boost_python_debug.lib</code> (for debugging). If you can't
-      find the libraries, 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>
+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" target="_top">Building and Testing</a> on how to do this.</p>
 <p>
-      Python's library can be found in the <code class="literal">/libs</code> subdirectory
-      of your Python directory. On Windows it is called pythonXY.lib where X.Y is
-      your major Python version number.
-    </p>
+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
+your major Python version number.</p>
 <p>
-      Additionally, Python's <code class="literal">/include</code> subdirectory has to be added
-      to your include path.
-    </p>
+Additionally, Python's <tt class="literal">/include</tt> subdirectory has to be added to your
+include path.</p>
 <p>
-      In a Jamfile, all the above boils down to:
-    </p>
-<pre class="programlisting">projectroot c:\projects\embedded_program ; # location of the program
+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
 
 # bring in the rules for python
 SEARCH on python.jam = $(BOOST_BUILD_PATH) ;
@@ -80,190 +73,274 @@ exe embedded_program # name of the executable
   $(PYTHON_PROPERTIES)
     &lt;library-path&gt;$(PYTHON_LIB_PATH)
     &lt;find-library&gt;$(PYTHON_EMBEDDED_LIBRARY) ;
-</pre>
-<h3>
-<a name="embedding.getting_started"></a>
-      Getting started
-    </h3>
+</tt></pre>
+<a name="embedding.getting_started"></a><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 class="orderedlist" type="1">
-<li class="listitem">
-          #include <code class="literal">&lt;boost/python.hpp&gt;</code>
-        </li>
-<li class="listitem">
-          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 <code class="literal">__main__</code> module.
-        </li>
-<li class="listitem">
-          Call other Python C API routines to use the interpreter.
-        </li>
+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><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.<br><br>
+</li>
+<li>
+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.
+</li>
 </ol></div>
-<div class="note"><table border="0" summary="Note">
-<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
-<th align="left">Note</th>
-</tr>
-<tr><td align="left" valign="top"><p>
-        <span class="bold"><strong>Note that at this time you must not call <a href="http://www.python.org/doc/current/api/initialization.html#l2h-656" target="_top">Py_Finalize</a>()
-        to stop the interpreter. This may be fixed in a future version of boost.python.</strong></span>
-      </p></td></tr>
-</table></div>
 <p>
-      (Of course, there can be other C++ code between all of these steps.)
-    </p>
-<div class="blockquote"><blockquote class="blockquote"><p>
-        <span class="emphasis"><em><span class="bold"><strong>Now that we can embed the interpreter in
-        our programs, lets see how to put it to use...</strong></span></em></span>
-      </p></blockquote></div>
-<div class="section">
+(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>
 <p>
-        As you probably already know, objects in Python are reference-counted. Naturally,
-        the <code class="literal">PyObject</code>s of the Python C API are also reference-counted.
-        There is a difference however. While the reference-counting is fully automatic
-        in Python, the Python C API requires you to do it <a href="http://www.python.org/doc/current/c-api/refcounting.html" target="_top">by
-        hand</a>. This is messy and especially hard to get right in the presence
-        of C++ exceptions. 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>
-<h3>
-<a name="using_the_interpreter.running_python_code"></a>
-        Running Python code
-      </h3>
+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.
+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
+<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="id456409"></a>Reference-counting handles and objects</h2>
 <p>
-        Boost.python provides three related functions to run Python code from C++.
-      </p>
-<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">eval</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">expression</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
-<span class="identifier">object</span> <span class="identifier">exec</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">code</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
-<span class="identifier">object</span> <span class="identifier">exec_file</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">filename</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
-</pre>
+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
+these a function uses, is listed in that function's documentation. The two
+require slightely different approaches to reference-counting but both can
+be 'handled' by Boost.Python.</p>
 <p>
-        eval evaluates the given expression and returns the resulting value. exec
-        executes the given code (typically a set of statements) returning the result,
-        and exec_file executes the code contained in the given file.
-      </p>
-<p>
-        The <code class="literal">globals</code> and <code class="literal">locals</code> parameters are
-        Python dictionaries containing the globals and locals of the context in which
-        to run the code. For most intents and purposes you can use the namespace
-        dictionary of the <code class="literal">__main__</code> module for both parameters.
-      </p>
-<p>
-        Boost.python provides a function to import a module:
-      </p>
-<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">import</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
-</pre>
-<p>
-        import imports a python module (potentially loading it into the running process
-        first), and returns it.
-      </p>
-<p>
-        Let's import the <code class="literal">__main__</code> module and run some Python code
-        in its namespace:
-      </p>
-<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
-<span class="identifier">object</span> <span class="identifier">main_namespace</span> <span class="special">=</span> <span class="identifier">main_module</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">);</span>
+For a function returning a <span class="emphasis"><em>borrowed reference</em></span> we'll have to tell the
+<tt class="literal">handle</tt> that the <tt class="literal">PyObject*</tt> is borrowed with the aptly named
+<a href="../../../../v2/handle.html#borrowed-spec" target="_top">borrowed</a> function. Two functions
+returning borrowed references are <a href="http://www.python.org/doc/current/api/importing.html#l2h-125" target="_top">PyImport_AddModule</a> and <a href="http://www.python.org/doc/current/api/moduleObjects.html#l2h-594" target="_top">PyModule_GetDict</a>.
+The former returns a reference to an already imported module, the latter
+retrieves a module's namespace dictionary. Let's use them to retrieve the
+namespace of the <tt class="literal"><span class="underline">_main</span>_</tt> module:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">object</span><span class="identifier"> main_module</span><span class="special">((</span><span class="identifier">
+    handle</span><span class="special">&lt;&gt;(</span><span class="identifier">borrowed</span><span class="special">(</span><a href="http://www.python.org/doc/current/api/importing.html#l2h-125" target="_top">PyImport_AddModule</a><span class="special">(</span><span class="string">"__main__"</span><span class="special">)))));</span><span class="identifier">
 
-<span class="identifier">object</span> <span class="identifier">ignored</span> <span class="special">=</span> <span class="identifier">exec</span><span class="special">(</span><span class="string">"hello = file('hello.txt', 'w')\n"</span>
-                      <span class="string">"hello.write('Hello world!')\n"</span>
-                      <span class="string">"hello.close()"</span><span class="special">,</span>
-                      <span class="identifier">main_namespace</span><span class="special">);</span>
-</pre>
+object</span><span class="identifier"> main_namespace</span><span class="special"> =</span><span class="identifier"> main_module</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">);</span></tt></pre>
 <p>
-        This should create a file called 'hello.txt' in the current directory containing
-        a phrase that is well-known in programming circles.
-      </p>
-<h3>
-<a name="using_the_interpreter.manipulating_python_objects"></a>
-        Manipulating Python objects
-      </h3>
+For a function returning a <span class="emphasis"><em>new reference</em></span> we can just create a <tt class="literal">handle</tt>
+out of the raw <tt class="literal">PyObject*</tt> without wrapping it in a call to borrowed. One
+such function that returns a new reference is <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a> which we'll
+discuss in the next section.</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>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="id456714"></a>Running Python code</h2>
 <p>
-        Often we'd like to have a class to manipulate Python objects. But we have
-        already seen such a class above, and in the <a href="object.html" target="_top">previous
-        section</a>: the aptly named <code class="literal">object</code> class and its
-        derivatives. We've already seen that they can be constructed from a <code class="literal">handle</code>.
-        The following examples should further illustrate this fact:
-      </p>
-<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
-<span class="identifier">object</span> <span class="identifier">main_namespace</span> <span class="special">=</span> <span class="identifier">main_module</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">object</span> <span class="identifier">ignored</span> <span class="special">=</span> <span class="identifier">exec</span><span class="special">(</span><span class="string">"result = 5 ** 2"</span><span class="special">,</span> <span class="identifier">main_namespace</span><span class="special">);</span>
-<span class="keyword">int</span> <span class="identifier">five_squared</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">main_namespace</span><span class="special">[</span><span class="string">"result"</span><span class="special">]);</span>
-</pre>
+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
+functions <a href="http://www.python.org/doc/current/api/veryhigh.html" target="_top">here</a>. They
+all work similarly so we will look at only one of them, namely:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">PyObject</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="keyword">char</span><span class="special"> *</span><span class="identifier">str</span><span class="special">,</span><span class="keyword"> int</span><span class="identifier"> start</span><span class="special">,</span><span class="identifier"> PyObject</span><span class="special"> *</span><span class="identifier">globals</span><span class="special">,</span><span class="identifier"> PyObject</span><span class="special"> *</span><span class="identifier">locals</span><span class="special">)</span></tt></pre>
+<p><a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a> takes the code to execute as a null-terminated (C-style)
+string in its <tt class="literal">str</tt> parameter. The function returns a new reference to a
+Python object. Which object is returned depends on the <tt class="literal">start</tt> paramater.</p>
 <p>
-        Here we create a dictionary object for the <code class="literal">__main__</code> module's
-        namespace. Then we assign 5 squared to the result variable and read this
-        variable from the dictionary. Another way to achieve the same result is to
-        use eval instead, which returns the result directly:
-      </p>
-<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">eval</span><span class="special">(</span><span class="string">"5 ** 2"</span><span class="special">);</span>
-<span class="keyword">int</span> <span class="identifier">five_squared</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">result</span><span class="special">);</span>
-</pre>
-<h3>
-<a name="using_the_interpreter.exception_handling"></a>
-        Exception handling
-      </h3>
+The <tt class="literal">start</tt> parameter is the start symbol from the Python grammar to use
+for interpreting the code. The possible values are:</p>
+<div class="informaltable">
+<h4>
+<a name="id456876"></a><span class="table-title">Start symbols</span>
+</h4>
+<table class="table">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th><a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-58" target="_top">Py_eval_input</a></th>
+<th>for interpreting isolated expressions</th>
+</tr></thead>
+<tbody>
+<tr>
+<td><a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-59" target="_top">Py_file_input</a></td>
+<td>for interpreting sequences of statements</td>
+</tr>
+<tr>
+<td><a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-60" target="_top">Py_single_input</a></td>
+<td>for interpreting a single statement</td>
+</tr>
+</tbody>
+</table>
+</div>
 <p>
-        If an exception occurs in the evaluation of the python expression, <a href="../../../../v2/errors.html#error_already_set-spec" target="_top">error_already_set</a>
-        is thrown:
-      </p>
-<pre class="programlisting"><span class="keyword">try</span>
-<span class="special">{</span>
-    <span class="identifier">object</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">eval</span><span class="special">(</span><span class="string">"5/0"</span><span class="special">);</span>
-    <span class="comment">// execution will never get here:</span>
-    <span class="keyword">int</span> <span class="identifier">five_divided_by_zero</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>
-<span class="special">}</span>
-<span class="keyword">catch</span><span class="special">(</span><span class="identifier">error_already_set</span> <span class="keyword">const</span> <span class="special">&amp;)</span>
-<span class="special">{</span>
-    <span class="comment">// handle the exception in some way</span>
-<span class="special">}</span>
-</pre>
+When using <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-58" target="_top">Py_eval_input</a>, the input string must contain a single expression
+and its result is returned. When using <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-59" target="_top">Py_file_input</a>, the string can
+contain an abitrary number of statements and None is returned.
+<a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-60" target="_top">Py_single_input</a> works in the same way as <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-59" target="_top">Py_file_input</a> but only accepts a
+single statement.</p>
 <p>
-        The <code class="literal">error_already_set</code> exception class doesn't carry any
-        information in itself. To find out more about the Python exception that occurred,
-        you need to use the <a href="http://www.python.org/doc/api/exceptionHandling.html" target="_top">exception
-        handling functions</a> of the Python C API in your catch-statement. This
-        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"><span class="keyword">catch</span><span class="special">(</span><span class="identifier">error_already_set</span> <span class="keyword">const</span> <span class="special">&amp;)</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">{</span>
-        <span class="comment">// handle ZeroDivisionError specially</span>
-    <span class="special">}</span>
-    <span class="keyword">else</span>
-    <span class="special">{</span>
-        <span class="comment">// print all other errors to stderr</span>
-        <span class="identifier">PyErr_Print</span><span class="special">();</span>
-    <span class="special">}</span>
-<span class="special">}</span>
-</pre>
+Lastly, the <tt class="literal">globals</tt> and <tt class="literal">locals</tt> parameters are Python dictionaries
+containing the globals and locals of the context in which to run the code.
+For most intents and purposes you can use the namespace dictionary of the
+<tt class="literal"><span class="underline">_main</span>_</tt> module for both parameters.</p>
 <p>
-        (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>
+We have already seen how to get the <tt class="literal"><span class="underline">_main</span>_</tt> module's namespace so let's
+run some Python code in it:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">object</span><span class="identifier"> main_module</span><span class="special">((</span><span class="identifier">
+    handle</span><span class="special">&lt;&gt;(</span><span class="identifier">borrowed</span><span class="special">(</span><a href="http://www.python.org/doc/current/api/importing.html#l2h-125" target="_top">PyImport_AddModule</a><span class="special">(</span><span class="string">"__main__"</span><span class="special">)))));</span><span class="identifier">
+
+object</span><span class="identifier"> main_namespace</span><span class="special"> =</span><span class="identifier"> main_module</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">
+
+handle</span><span class="special">&lt;&gt;</span><span class="identifier"> ignored</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">
+
+    "hello = file('hello.txt', 'w')\n"</span><span class="string">
+    "hello.write('Hello world!')\n"</span><span class="string">
+    "hello.close()"</span><span class="special">
+
+  ,</span> <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-59" target="_top">Py_file_input</a><span class="special">
+  ,</span><span class="identifier"> main_namespace</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">()</span><span class="special">
+  ,</span><span class="identifier"> main_namespace</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">())</span><span class="special">
+));</span></tt></pre>
+<p>
+Because the Python/C API doesn't know anything about <tt class="literal">object</tt>s, we used
+the object's <tt class="literal">ptr</tt> member function to retrieve the <tt class="literal">PyObject*</tt>.</p>
+<p>
+This should create a file called 'hello.txt' in the current directory
+containing a phrase that is well-known in programming circles.</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="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
+class to manipulate Python objects. But we have already seen such a class
+above, and in the <a href="object.html" target="_top">previous section</a>: the aptly
+named <tt class="literal">object</tt> class and it's derivatives. We've already seen that they
+can be constructed from a <tt class="literal">handle</tt>. The following examples should further
+illustrate this fact:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">object</span><span class="identifier"> main_module</span><span class="special">((</span><span class="identifier">
+     handle</span><span class="special">&lt;&gt;(</span><span class="identifier">borrowed</span><span class="special">(</span><a href="http://www.python.org/doc/current/api/importing.html#l2h-125" target="_top">PyImport_AddModule</a><span class="special">(</span><span class="string">"__main__"</span><span class="special">)))));</span><span class="identifier">
+
+object</span><span class="identifier"> main_namespace</span><span class="special"> =</span><span class="identifier"> main_module</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">
+
+handle</span><span class="special">&lt;&gt;</span><span class="identifier"> ignored</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">
+
+    "result = 5 ** 2"</span><span class="special">
+
+    ,</span> <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-59" target="_top">Py_file_input</a><span class="special">
+    ,</span><span class="identifier"> main_namespace</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">()</span><span class="special">
+    ,</span><span class="identifier"> main_namespace</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">())</span><span class="special">
+));</span><span class="keyword">
+
+int</span><span class="identifier"> five_squared</span><span class="special"> =</span><span class="identifier"> extract</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">main_namespace</span><span class="special">[</span><span class="string">"result"</span><span class="special">]);</span></tt></pre>
+<p>
+Here we create a dictionary object for the <tt class="literal"><span class="underline">_main</span>_</tt> module's namespace.
+Then we assign 5 squared to the result variable and read this variable from
+the dictionary. Another way to achieve the same result is to let
+<a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a> return the result directly with <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-58" target="_top">Py_eval_input</a>:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">object</span><span class="identifier"> result</span><span class="special">((</span><span class="identifier">handle</span><span class="special">&lt;&gt;(</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 ** 2"</span><span class="special">
+        ,</span> <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-58" target="_top">Py_eval_input</a><span class="special">
+        ,</span><span class="identifier"> main_namespace</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">()</span><span class="special">
+        ,</span><span class="identifier"> main_namespace</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">()))</span><span class="special">
+));</span><span class="keyword">
+
+int</span><span class="identifier"> five_squared</span><span class="special"> =</span><span class="identifier"> extract</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">result</span><span class="special">);</span></tt></pre>
+<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="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
+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">
+    object</span><span class="identifier"> result</span><span class="special">((</span><span class="identifier">handle</span><span class="special">&lt;&gt;(</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">
+      ,</span> <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-58" target="_top">Py_eval_input</a><span class="special">
+      ,</span><span class="identifier"> main_namespace</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">()</span><span class="special">
+      ,</span><span class="identifier"> main_namespace</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">()))</span><span class="special">
+    ));</span><span class="comment">
+
+    // execution will never get here:
+</span><span class="keyword">    int</span><span class="identifier"> five_divided_by_zero</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><span class="special">
+}</span><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="comment">
+    // 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>
+<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">
+    {</span><span class="comment">
+        // handle ZeroDivisionError specially
+</span><span class="special">    }</span><span class="keyword">
+    else</span><span class="special">
+    {</span><span class="comment">
+        // print all other errors to stderr
+</span><span class="identifier">        PyErr_Print</span><span class="special">();</span><span class="special">
+    }</span><span class="special">
+}</span></tt></pre>
+<p>
+(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
+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">
+   ,</span> <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-58" target="_top">Py_eval_input</a><span class="special">
+   ,</span><span class="identifier"> main_namespace</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">()</span><span class="special">
+   ,</span><span class="identifier"> main_namespace</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">()))));</span><span class="keyword">
+
+if</span><span class="special"> (!</span><span class="identifier">result</span><span class="special">)</span><span class="comment">
+    // Python exception occurred
+</span><span class="keyword">else</span><span class="comment">
+    // everything went okay, it's safe to use the result
+</span></tt></pre>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
-      de Guzman, David Abrahams<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
-        http://www.boost.org/LICENSE_1_0.txt </a>)
-      </p>
-</div></td>
+<td align="right"><small>Copyright © 2002-2005 Joel de Guzman, David Abrahams</small></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="object.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<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>
 </body>
 </html>

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

@@ -1,63 +1,54 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Exception Translation</title>
-<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<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.66.1">
+<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
 <link rel="prev" href="iterators.html" title="Iterators">
-<link rel="next" href="techniques.html" title="General Techniques">
+<link rel="next" href="techniques.html" title=" General Techniques">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<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="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</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>
-</tr></table>
+</table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="iterators.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="techniques.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<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">
+<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>
+<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 default exception
-      handler that translates selected standard exceptions, then gives up:
-    </p>
-<pre class="programlisting"><span class="keyword">raise</span> <span class="identifier">RuntimeError</span><span class="special">,</span> <span class="string">'unidentifiable C++ Exception'</span>
-</pre>
+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
+default exception handler that translates selected standard exceptions,
+then gives up:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">raise</span><span class="identifier"> RuntimeError</span><span class="special">,</span><span class="char"> 'unidentifiable C++ Exception'</span></tt></pre>
 <p>
-      Users may provide custom translation. Here's an example:
-    </p>
-<pre class="programlisting"><span class="identifier">struct</span> <span class="identifier">PodBayDoorException</span><span class="special">;</span>
-<span class="identifier">void</span> <span class="identifier">translator</span><span class="special">(</span><span class="identifier">PodBayDoorException</span> <span class="identifier">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">{</span>
-    <span class="identifier">PyErr_SetString</span><span class="special">(</span><span class="identifier">PyExc_UserWarning</span><span class="special">,</span> <span class="string">"I'm sorry Dave..."</span><span class="special">);</span>
-<span class="special">}</span>
-<span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">kubrick</span><span class="special">)</span> <span class="special">{</span>
-     <span class="identifier">register_exception_translator</span><span class="special">&lt;</span>
-          <span class="identifier">PodBayDoorException</span><span class="special">&gt;(</span><span class="identifier">translator</span><span class="special">);</span>
-     <span class="special">...</span>
-</pre>
+Users may provide custom translation. Here's an example:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">struct</span><span class="identifier"> PodBayDoorException</span><span class="special">;</span><span class="keyword">
+void</span><span class="identifier"> translator</span><span class="special">(</span><span class="identifier">PodBayDoorException</span><span class="keyword"> const</span><span class="special">&amp;</span><span class="identifier"> x</span><span class="special">)</span><span class="special"> {</span><span class="identifier">
+    PyErr_SetString</span><span class="special">(</span><span class="identifier">PyExc_UserWarning</span><span class="special">,</span><span class="string"> "I'm sorry Dave..."</span><span class="special">);</span><span class="special">
+}</span><span class="identifier">
+BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">kubrick</span><span class="special">)</span><span class="special"> {</span><span class="identifier">
+     register_exception_translator</span><span class="special">&lt;</span><span class="identifier">
+          PodBayDoorException</span><span class="special">&gt;(</span><span class="identifier">translator</span><span class="special">);</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"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
-      de Guzman, David Abrahams<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
-        http://www.boost.org/LICENSE_1_0.txt </a>)
-      </p>
-</div></td>
+<td align="right"><small>Copyright © 2002-2005 Joel de Guzman, David Abrahams</small></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="iterators.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="techniques.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<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>
 </body>
 </html>

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

@@ -1,30 +1,30 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Exposing Classes</title>
-<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="prev" href="hello.html" title="Building Hello World">
+<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.66.1">
+<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="prev" href="hello.html" title=" Building Hello World">
 <link rel="next" href="functions.html" title="Functions">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<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="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</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>
-</tr></table>
+</table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="hello.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<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">
+<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>
+<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>
@@ -35,557 +35,442 @@
 <dt><span class="section"><a href="exposing.html#python.class_operators_special_functions">Class Operators/Special Functions</a></span></dt>
 </dl></div>
 <p>
-      Now let's expose a C++ class to Python.
-    </p>
+Now let's expose a C++ class to Python.</p>
 <p>
-      Consider a C++ class/struct that we want to expose to Python:
-    </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">World</span>
-<span class="special">{</span>
-    <span class="keyword">void</span> <span class="identifier">set</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="special">{</span> <span class="keyword">this</span><span class="special">-&gt;</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="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">greet</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">msg</span><span class="special">;</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="special">};</span>
-</pre>
+Consider a C++ class/struct that we want to expose to Python:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">struct</span><span class="identifier"> World</span><span class="special">
+{</span><span class="keyword">
+    void</span><span class="identifier"> set</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="special"> {</span><span class="keyword"> this</span><span class="special">-&gt;</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="identifier">
+    std</span><span class="special">::</span><span class="identifier">string</span><span class="identifier"> greet</span><span class="special">()</span><span class="special"> {</span><span class="keyword"> return</span><span class="identifier"> msg</span><span class="special">;</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="special">
+};</span></tt></pre>
 <p>
-      We can expose this to Python by writing a corresponding Boost.Python C++ Wrapper:
-    </p>
-<pre class="programlisting"><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">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">;</span>
+We can expose this to Python by writing a corresponding Boost.Python
+C++ Wrapper:</p>
+<pre class="programlisting"><tt class="literal"><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">
+using</span><span class="keyword"> namespace</span><span class="identifier"> boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">;</span><span class="identifier">
 
-<span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello</span><span class="special">)</span>
-<span class="special">{</span>
-    <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">World</span><span class="special">&gt;(</span><span class="string">"World"</span><span class="special">)</span>
-        <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"greet"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">greet</span><span class="special">)</span>
-        <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"set"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">set</span><span class="special">)</span>
-    <span class="special">;</span>
-<span class="special">}</span>
-</pre>
+BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello</span><span class="special">)</span><span class="special">
+{</span><span class="identifier">
+    class_</span><span class="special">&lt;</span><span class="identifier">World</span><span class="special">&gt;(</span><span class="string">"World"</span><span class="special">)</span><span class="special">
+        .</span><span class="identifier">def</span><span class="special">(</span><span class="string">"greet"</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">greet</span><span class="special">)</span><span class="special">
+        .</span><span class="identifier">def</span><span class="special">(</span><span class="string">"set"</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">set</span><span class="special">)</span><span class="special">
+    ;</span><span class="special">
+}</span></tt></pre>
 <p>
-      Here, we wrote a C++ class wrapper that exposes the member functions <code class="literal">greet</code>
-      and <code class="literal">set</code>. Now, after building our module as a shared library,
-      we may use our class <code class="literal">World</code> in Python. Here's a sample Python
-      session:
-    </p>
-<pre class="programlisting"><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="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>
-</pre>
-<div class="section">
+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>
+<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="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>
 <p>
-        Our previous example didn't have any explicit constructors. Since <code class="literal">World</code>
-        is declared as a plain struct, it has an implicit default constructor. Boost.Python
-        exposes the default constructor by default, which is why we were able to
-        write
-      </p>
-<pre class="programlisting"><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>
-</pre>
+Our previous example didn't have any explicit constructors.
+Since <tt class="literal">World</tt> is declared as a plain struct, it has an implicit default
+constructor. Boost.Python exposes the default constructor by default,
+which is why we were able to write</p>
+<pre class="programlisting"><tt class="literal"><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></tt></pre>
 <p>
-        We may wish to wrap a class with a non-default constructor. Let us build
-        on our previous example:
-      </p>
-<pre class="programlisting"><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</span>
-    <span class="keyword">void</span> <span class="identifier">set</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="special">{</span> <span class="keyword">this</span><span class="special">-&gt;</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="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">greet</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">msg</span><span class="special">;</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="special">};</span>
-</pre>
+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
+</span><span class="keyword">    void</span><span class="identifier"> set</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="special"> {</span><span class="keyword"> this</span><span class="special">-&gt;</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="identifier">
+    std</span><span class="special">::</span><span class="identifier">string</span><span class="identifier"> greet</span><span class="special">()</span><span class="special"> {</span><span class="keyword"> return</span><span class="identifier"> msg</span><span class="special">;</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="special">
+};</span></tt></pre>
 <p>
-        This time <code class="literal">World</code> has no default constructor; our previous
-        wrapping code would fail to compile when the library tried to expose it.
-        We have to tell <code class="literal">class_&lt;World&gt;</code> about the constructor
-        we want to expose instead.
-      </p>
-<pre class="programlisting"><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">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">;</span>
+This time <tt class="literal">World</tt> has no default constructor; our previous
+wrapping code would fail to compile when the library tried to expose
+it. We have to tell <tt class="literal">class_&lt;World&gt;</tt> about the constructor we want to
+expose instead.</p>
+<pre class="programlisting"><tt class="literal"><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">
+using</span><span class="keyword"> namespace</span><span class="identifier"> boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">;</span><span class="identifier">
 
-<span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello</span><span class="special">)</span>
-<span class="special">{</span>
-    <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">World</span><span class="special">&gt;(</span><span class="string">"World"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
-        <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"greet"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">greet</span><span class="special">)</span>
-        <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"set"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">set</span><span class="special">)</span>
-    <span class="special">;</span>
-<span class="special">}</span>
-</pre>
+BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello</span><span class="special">)</span><span class="special">
+{</span><span class="identifier">
+    class_</span><span class="special">&lt;</span><span class="identifier">World</span><span class="special">&gt;(</span><span class="string">"World"</span><span class="special">,</span><span class="identifier"> init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span><span class="special">
+        .</span><span class="identifier">def</span><span class="special">(</span><span class="string">"greet"</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">greet</span><span class="special">)</span><span class="special">
+        .</span><span class="identifier">def</span><span class="special">(</span><span class="string">"set"</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">set</span><span class="special">)</span><span class="special">
+    ;</span><span class="special">
+}</span></tt></pre>
+<p><tt class="literal">init&lt;std::string&gt;()</tt> exposes the constructor taking in a
+<tt class="literal">std::string</tt> (in Python, constructors are spelled
+"<tt class="literal">"<span class="underline">_init</span>_"</tt>").</p>
 <p>
-        <code class="literal">init&lt;std::string&gt;()</code> exposes the constructor taking
-        in a <code class="literal">std::string</code> (in Python, constructors are spelled
-        "<code class="literal">"__init__"</code>").
-      </p>
+We can expose additional constructors by passing more <tt class="literal">init&lt;...&gt;</tt>s to
+the <tt class="literal">def()</tt> member function. Say for example we have another World
+constructor taking in two doubles:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">World</span><span class="special">&gt;(</span><span class="string">"World"</span><span class="special">,</span><span class="identifier"> init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span><span class="special">
+    .</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span><span class="keyword"> double</span><span class="special">&gt;())</span><span class="special">
+    .</span><span class="identifier">def</span><span class="special">(</span><span class="string">"greet"</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">greet</span><span class="special">)</span><span class="special">
+    .</span><span class="identifier">def</span><span class="special">(</span><span class="string">"set"</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">set</span><span class="special">)</span><span class="special">
+;</span></tt></pre>
 <p>
-        We can expose additional constructors by passing more <code class="literal">init&lt;...&gt;</code>s
-        to the <code class="literal">def()</code> member function. Say for example we have
-        another World constructor taking in two doubles:
-      </p>
-<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">World</span><span class="special">&gt;(</span><span class="string">"World"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
-    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;())</span>
-    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"greet"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">greet</span><span class="special">)</span>
-    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"set"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">set</span><span class="special">)</span>
-<span class="special">;</span>
-</pre>
+On the other hand, if we do not wish to expose any constructors at
+all, we may use <tt class="literal">no_init</tt> instead:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Abstract</span><span class="special">&gt;(</span><span class="string">"Abstract"</span><span class="special">,</span><span class="identifier"> no_init</span><span class="special">)</span></tt></pre>
 <p>
-        On the other hand, if we do not wish to expose any constructors at all, we
-        may use <code class="literal">no_init</code> instead:
-      </p>
-<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Abstract</span><span class="special">&gt;(</span><span class="string">"Abstract"</span><span class="special">,</span> <span class="identifier">no_init</span><span class="special">)</span>
-</pre>
-<p>
-        This actually adds an <code class="literal">__init__</code> method which always raises
-        a Python RuntimeError exception.
-      </p>
+This actually adds an <tt class="literal"><span class="underline">_init</span>_</tt> method which always raises a
+Python RuntimeError exception.</p>
 </div>
-<div class="section">
+<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>
 <p>
-        Data members may also be exposed to Python so that they can be accessed as
-        attributes of the corresponding Python class. Each data member that we wish
-        to be exposed may be regarded as <span class="bold"><strong>read-only</strong></span>
-        or <span class="bold"><strong>read-write</strong></span>. Consider this class <code class="literal">Var</code>:
-      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Var</span>
-<span class="special">{</span>
-    <span class="identifier">Var</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">name</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">name</span><span class="special">(</span><span class="identifier">name</span><span class="special">),</span> <span class="identifier">value</span><span class="special">()</span> <span class="special">{}</span>
-    <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span> <span class="identifier">name</span><span class="special">;</span>
-    <span class="keyword">float</span> <span class="identifier">value</span><span class="special">;</span>
-<span class="special">};</span>
-</pre>
+Data members may also be exposed to Python so that they can be
+accessed as attributes of the corresponding Python class. Each data
+member that we wish to be exposed may be regarded as <span class="bold"><b>read-only</b></span> or
+<span class="bold"><b>read-write</b></span>.  Consider this class <tt class="literal">Var</tt>:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">struct</span><span class="identifier"> Var</span><span class="special">
+{</span><span class="identifier">
+    Var</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="identifier"> name</span><span class="special">)</span><span class="special"> :</span><span class="identifier"> name</span><span class="special">(</span><span class="identifier">name</span><span class="special">),</span><span class="identifier"> value</span><span class="special">()</span><span class="special"> {}</span><span class="identifier">
+    std</span><span class="special">::</span><span class="identifier">string</span><span class="keyword"> const</span><span class="identifier"> name</span><span class="special">;</span><span class="keyword">
+    float</span><span class="identifier"> value</span><span class="special">;</span><span class="special">
+};</span></tt></pre>
 <p>
-        Our C++ <code class="literal">Var</code> class and its data members can be exposed
-        to Python:
-      </p>
-<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Var</span><span class="special">&gt;(</span><span class="string">"Var"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
-    <span class="special">.</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"name"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Var</span><span class="special">::</span><span class="identifier">name</span><span class="special">)</span>
-    <span class="special">.</span><span class="identifier">def_readwrite</span><span class="special">(</span><span class="string">"value"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Var</span><span class="special">::</span><span class="identifier">value</span><span class="special">);</span>
-</pre>
+Our C++ <tt class="literal">Var</tt> class and its data members can be exposed to Python:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Var</span><span class="special">&gt;(</span><span class="string">"Var"</span><span class="special">,</span><span class="identifier"> init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span><span class="special">
+    .</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"name"</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">Var</span><span class="special">::</span><span class="identifier">name</span><span class="special">)</span><span class="special">
+    .</span><span class="identifier">def_readwrite</span><span class="special">(</span><span class="string">"value"</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">Var</span><span class="special">::</span><span class="identifier">value</span><span class="special">);</span></tt></pre>
 <p>
-        Then, in Python, assuming we have placed our Var class inside the namespace
-        hello as we did before:
-      </p>
-<pre class="programlisting"><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="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>
-</pre>
+Then, in Python, assuming we have placed our Var class inside the namespace
+hello as we did before:</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"> 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="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 <code class="literal">name</code> is exposed as <span class="bold"><strong>read-only</strong></span>
-        while <code class="literal">value</code> is exposed as <span class="bold"><strong>read-write</strong></span>.
-      </p>
-<pre class="programlisting"><span class="special">&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="error">?</span>
-<span class="identifier">AttributeError</span><span class="special">:</span> <span class="identifier">can</span><span class="error">'</span><span class="identifier">t</span> <span class="identifier">set</span> <span class="identifier">attribute</span>
-</pre>
+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"><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">
+<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>
 <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>
-<pre class="programlisting"><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">float</span> <span class="identifier">get</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
-    <span class="keyword">void</span> <span class="identifier">set</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">value</span><span class="special">);</span>
-    <span class="special">...</span>
-<span class="special">};</span>
-</pre>
+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">
+    float</span><span class="identifier"> get</span><span class="special">()</span><span class="keyword"> const</span><span class="special">;</span><span class="keyword">
+    void</span><span class="identifier"> set</span><span class="special">(</span><span class="keyword">float</span><span class="identifier"> value</span><span class="special">);</span><span class="special">
+    ...</span><span class="special">
+};</span></tt></pre>
 <p>
-        However, in Python attribute access is fine; it doesn't neccessarily break
-        encapsulation to let users handle attributes directly, because the attributes
-        can just be a different syntax for a method call. Wrapping our <code class="literal">Num</code>
-        class using Boost.Python:
-      </p>
-<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Num</span><span class="special">&gt;(</span><span class="string">"Num"</span><span class="special">)</span>
-    <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>
-    <span class="special">.</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>
-</pre>
+However, in Python attribute access is fine; it doesn't neccessarily break
+encapsulation to let users handle attributes directly, because the
+attributes can just be a different syntax for a method call. Wrapping our
+<tt class="literal">Num</tt> class using Boost.Python:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Num</span><span class="special">&gt;(</span><span class="string">"Num"</span><span class="special">)</span><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><span class="special">
+    .</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>
-<pre class="programlisting"><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="comment"># error!</span>
-</pre>
+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="comment"> # error!
+</span></tt></pre>
 <p>
-        Take note that the class property <code class="literal">rovalue</code> is exposed as
-        <span class="bold"><strong>read-only</strong></span> since the <code class="literal">rovalue</code>
-        setter member function is not passed in:
-      </p>
-<pre class="programlisting"><span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"rovalue"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">)</span>
-</pre>
+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">
+<div class="section" lang="en">
 <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 polymorphic
-        classes and class hierarchies related by inheritance. We will often have
-        to write Boost.Python wrappers for classes that are derived from abstract
-        base classes.
-      </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
+polymorphic classes and class hierarchies related by inheritance. We will
+often have to write Boost.Python wrappers for classes that are derived from
+abstract base classes.</p>
 <p>
-        Consider this trivial inheritance structure:
-      </p>
-<pre class="programlisting"><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">struct</span> <span class="identifier">Derived</span> <span class="special">:</span> <span class="identifier">Base</span> <span class="special">{};</span>
-</pre>
+Consider this trivial inheritance structure:</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">
+struct</span><span class="identifier"> Derived</span><span class="special"> :</span><span class="identifier"> Base</span><span class="special"> {};</span></tt></pre>
 <p>
-        And a set of C++ functions operating on <code class="literal">Base</code> and <code class="literal">Derived</code>
-        object instances:
-      </p>
-<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">b</span><span class="special">(</span><span class="identifier">Base</span><span class="special">*);</span>
-<span class="keyword">void</span> <span class="identifier">d</span><span class="special">(</span><span class="identifier">Derived</span><span class="special">*);</span>
-<span class="identifier">Base</span><span class="special">*</span> <span class="identifier">factory</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="keyword">new</span> <span class="identifier">Derived</span><span class="special">;</span> <span class="special">}</span>
-</pre>
+And a set of C++ functions operating on <tt class="literal">Base</tt> and <tt class="literal">Derived</tt> object
+instances:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">void</span><span class="identifier"> b</span><span class="special">(</span><span class="identifier">Base</span><span class="special">*);</span><span class="keyword">
+void</span><span class="identifier"> d</span><span class="special">(</span><span class="identifier">Derived</span><span class="special">*);</span><span class="identifier">
+Base</span><span class="special">*</span><span class="identifier"> factory</span><span class="special">()</span><span class="special"> {</span><span class="keyword"> return</span><span class="keyword"> new</span><span class="identifier"> Derived</span><span class="special">;</span><span class="special"> }</span></tt></pre>
 <p>
-        We've seen how we can wrap the base class <code class="literal">Base</code>:
-      </p>
-<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
-    <span class="comment">/*...*/</span>
-    <span class="special">;</span>
-</pre>
+We've seen how we can wrap the base class <tt class="literal">Base</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">&gt;(</span><span class="string">"Base"</span><span class="special">)</span><span class="comment">
+    /*...*/</span><span class="special">
+    ;</span></tt></pre>
 <p>
-        Now we can inform Boost.Python of the inheritance relationship between <code class="literal">Derived</code>
-        and its base class <code class="literal">Base</code>. Thus:
-      </p>
-<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Derived</span><span class="special">,</span> <span class="identifier">bases</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="string">"Derived"</span><span class="special">)</span>
-    <span class="comment">/*...*/</span>
-    <span class="special">;</span>
-</pre>
+Now we can inform Boost.Python of the inheritance relationship between
+<tt class="literal">Derived</tt> and its base class <tt class="literal">Base</tt>.  Thus:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Derived</span><span class="special">,</span><span class="identifier"> bases</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span><span class="special"> &gt;(</span><span class="string">"Derived"</span><span class="special">)</span><span class="comment">
+    /*...*/</span><span class="special">
+    ;</span></tt></pre>
 <p>
-        Doing so, we get some things for free:
-      </p>
-<div class="orderedlist"><ol class="orderedlist" type="1">
-<li class="listitem">
-            Derived automatically inherits all of Base's Python methods (wrapped
-            C++ member functions)
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>If</strong></span> Base is polymorphic, <code class="literal">Derived</code>
-            objects which have been passed to Python via a pointer or reference to
-            <code class="literal">Base</code> can be passed where a pointer or reference to
-            <code class="literal">Derived</code> is expected.
-          </li>
+Doing so, we get some things for free:</p>
+<div class="orderedlist"><ol type="1">
+<li>
+Derived automatically inherits all of Base's Python methods
+  (wrapped C++ member functions)
+</li>
+<li>
+<span class="bold"><b>If</b></span> Base is polymorphic, <tt class="literal">Derived</tt> objects which have been passed to
+  Python via a pointer or reference to <tt class="literal">Base</tt> can be passed where a pointer
+  or reference to <tt class="literal">Derived</tt> is expected.
+</li>
 </ol></div>
 <p>
-        Now, we will expose the C++ free functions <code class="literal">b</code> and <code class="literal">d</code>
-        and <code class="literal">factory</code>:
-      </p>
-<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"b"</span><span class="special">,</span> <span class="identifier">b</span><span class="special">);</span>
-<span class="identifier">def</span><span class="special">(</span><span class="string">"d"</span><span class="special">,</span> <span class="identifier">d</span><span class="special">);</span>
-<span class="identifier">def</span><span class="special">(</span><span class="string">"factory"</span><span class="special">,</span> <span class="identifier">factory</span><span class="special">);</span>
-</pre>
+Now, we shall expose the C++ free functions <tt class="literal">b</tt> and <tt class="literal">d</tt> and <tt class="literal">factory</tt>:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">def</span><span class="special">(</span><span class="string">"b"</span><span class="special">,</span><span class="identifier"> b</span><span class="special">);</span><span class="identifier">
+def</span><span class="special">(</span><span class="string">"d"</span><span class="special">,</span><span class="identifier"> d</span><span class="special">);</span><span class="identifier">
+def</span><span class="special">(</span><span class="string">"factory"</span><span class="special">,</span><span class="identifier"> factory</span><span class="special">);</span></tt></pre>
 <p>
-        Note that free function <code class="literal">factory</code> is being used to generate
-        new instances of class <code class="literal">Derived</code>. In such cases, we use
-        <code class="literal">return_value_policy&lt;manage_new_object&gt;</code> to instruct
-        Python to adopt the pointer to <code class="literal">Base</code> and hold the instance
-        in a new Python <code class="literal">Base</code> object until the the Python object
-        is destroyed. We will see more of Boost.Python <a class="link" href="functions.html#python.call_policies" title="Call Policies">call
-        policies</a> later.
-      </p>
-<pre class="programlisting"><span class="comment">// Tell Python to take ownership of factory's result</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>
-</pre>
+Note that free function <tt class="literal">factory</tt> is being used to generate new
+instances of class <tt class="literal">Derived</tt>. In such cases, we use
+<tt class="literal">return_value_policy&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" 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">
+<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>
 <p>
-        In this section, we will learn how to make functions behave polymorphically
-        through virtual functions. Continuing our example, let us add a virtual function
-        to our <code class="literal">Base</code> class:
-      </p>
-<pre class="programlisting"><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>
-</pre>
+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>
-        One of the goals of Boost.Python is to be minimally intrusive on an existing
-        C++ design. In principle, it should be possible to expose the interface for
-        a 3rd party library without changing it. It is not ideal to add anything
-        to our class <code class="computeroutput"><span class="identifier">Base</span></code>. Yet, when
-        you have a virtual function that's going to be overridden in Python and called
-        polymorphically <span class="bold"><strong>from C++</strong></span>, we'll need to
-        add some scaffoldings to make things work properly. What we'll do is write
-        a class wrapper that derives from <code class="computeroutput"><span class="identifier">Base</span></code>
-        that will unintrusively hook into the virtual functions so that a Python
-        override may be called:
-      </p>
-<pre class="programlisting"><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>
-</pre>
+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 <code class="computeroutput"><span class="identifier">Base</span></code>,
-        we also multiply- inherited <code class="computeroutput"><span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span></code> (See <a href="../../../../v2/wrapper.html" target="_top">Wrapper</a>).
-        The <code class="computeroutput"><span class="identifier">wrapper</span></code> template makes
-        the job of wrapping classes that are meant to overridden in Python, easier.
-      </p>
-<div class="sidebar">
-<div class="titlepage"></div>
+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 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>
-        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><strong>MSVC6/7 Workaround</strong></span>
-      </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>
-        If you are using Microsoft Visual C++ 6 or 7, you have to write <code class="computeroutput"><span class="identifier">f</span></code> as:
-      </p>
-<p>
-        <code 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></code>.
-      </p>
-</div>
-<p>
-        BaseWrap's overridden virtual member function <code class="computeroutput"><span class="identifier">f</span></code>
-        in effect calls the corresponding method of the Python object through <code class="computeroutput"><span class="identifier">get_override</span></code>.
-      </p>
-<p>
-        Finally, exposing <code class="computeroutput"><span class="identifier">Base</span></code>:
-      </p>
-<pre class="programlisting"><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>
-</pre>
-<p>
-        <code class="computeroutput"><span class="identifier">pure_virtual</span></code> signals Boost.Python
-        that the function <code class="computeroutput"><span class="identifier">f</span></code> is a
-        pure virtual function.
-      </p>
-<div class="note"><table border="0" summary="Note">
-<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
-<th align="left">Note</th>
-</tr>
-<tr><td align="left" valign="top">
-<p>
-          <span class="bold"><strong>member function and methods</strong></span>
-        </p>
-<p>
-          Python, like many object oriented languages uses the term <span class="bold"><strong>methods</strong></span>.
-          Methods correspond roughly to C++'s <span class="bold"><strong>member functions</strong></span>
-        </p>
-</td></tr>
+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>
 </div>
-<div class="section">
+<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>
 <p>
-        We've seen in the previous section how classes with pure virtual functions
-        are wrapped using Boost.Python's <a href="../../../../v2/wrapper.html" target="_top">class
-        wrapper</a> facilities. If we wish to wrap <span class="bold"><strong>non</strong></span>-pure-virtual
-        functions instead, the mechanism is a bit different.
-      </p>
+We've seen in the previous section how classes with pure virtual functions are 
+wrapped using Boost.Python's <a href="../../../../v2/wrapper.html" target="_top">class wrapper</a>
+facilities. If we wish to wrap <span class="bold"><b>non</b></span>-pure-virtual functions instead, the 
+mechanism is a bit different.</p>
 <p>
-        Recall that in the <a class="link" href="exposing.html#python.class_virtual_functions" title="Class Virtual Functions">previous
-        section</a>, we wrapped a class with a pure virtual function that we then
-        implemented in C++, or Python classes derived from it. Our base class:
-      </p>
-<pre class="programlisting"><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">};</span>
-</pre>
+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">
+};</span></tt></pre>
 <p>
-        had a pure virtual function <code class="literal">f</code>. If, however, its member
-        function <code class="literal">f</code> was not declared as pure virtual:
-      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span>
-<span class="special">{</span>
-    <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>
-</pre>
+had a pure virtual function <tt class="literal">f</tt>. If, however, its member function <tt class="literal">f</tt> was
+not declared as pure virtual:</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>
-        We wrap it this way:
-      </p>
-<pre class="programlisting"><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>
+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">
 
-    <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>
-</pre>
+    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>
-        Notice how we implemented <code class="computeroutput"><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">f</span></code>. Now,
-        we have to check if there is an override for <code class="computeroutput"><span class="identifier">f</span></code>.
-        If none, then we call <code class="computeroutput"><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">()</span></code>.
-      </p>
-<div class="sidebar">
-<div class="titlepage"></div>
+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>
-        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><strong>MSVC6/7 Workaround</strong></span>
-      </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>
-        If you are using Microsoft Visual C++ 6 or 7, you have to rewrite the line
-        with the <code class="computeroutput"><span class="special">*</span><span class="identifier">note</span><span class="special">*</span></code> as:
-      </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>
-        <code 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></code>.
-      </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="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>
+<p>
+Calling <tt class="literal">base.f()</tt>:</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">f</span><span class="special">()</span><span class="number">
+0</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>
 </div>
-<p>
-        Finally, exposing:
-      </p>
-<pre class="programlisting"><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>
-</pre>
-<p>
-        Take note that we expose both <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span></code> and <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">default_f</span></code>. Boost.Python needs to keep track
-        of 1) the dispatch function <code class="literal">f</code> and 2) the forwarding function
-        to its default implementation <code class="literal">default_f</code>. There's a special
-        <code class="literal">def</code> function for this purpose.
-      </p>
-<p>
-        In Python, the results would be as expected:
-      </p>
-<pre class="programlisting"><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="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>
-</pre>
-<p>
-        Calling <code class="literal">base.f()</code>:
-      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">base</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
-<span class="number">0</span>
-</pre>
-<p>
-        Calling <code class="literal">derived.f()</code>:
-      </p>
-<pre class="programlisting"><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>
-</pre>
-</div>
-<div class="section">
+<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>
-<h3>
-<a name="class_operators_special_functions.python_operators"></a>
-        Python Operators
-      </h3>
+<a name="class_operators_special_functions.python_operators"></a><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 this and
-        makes it easy to wrap C++ operator-powered classes.
-      </p>
+C is well known for the abundance of operators. C++ extends this to the
+extremes by allowing operator overloading. Boost.Python takes advantage of
+this and makes it easy to wrap C++ operator-powered classes.</p>
 <p>
-        Consider a file position class <code class="literal">FilePos</code> and a set of operators
-        that take on FilePos instances:
-      </p>
-<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">FilePos</span> <span class="special">{</span> <span class="comment">/*...*/</span> <span class="special">};</span>
+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">
 
-<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">FilePos</span>     <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">FilePos</span><span class="special">);</span>
-<span class="keyword">int</span>         <span class="keyword">operator</span><span class="special">-(</span><span class="identifier">FilePos</span><span class="special">,</span> <span class="identifier">FilePos</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">FilePos</span><span class="special">&amp;</span>    <span class="keyword">operator</span><span class="special">+=(</span><span class="identifier">FilePos</span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">);</span>
-<span class="identifier">FilePos</span><span class="special">&amp;</span>    <span class="keyword">operator</span><span class="special">-=(</span><span class="identifier">FilePos</span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">);</span>
-<span class="keyword">bool</span>        <span class="keyword">operator</span><span class="special">&lt;(</span><span class="identifier">FilePos</span><span class="special">,</span> <span class="identifier">FilePos</span><span class="special">);</span>
-</pre>
+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">
+FilePos</span><span class="keyword">     operator</span><span class="special">+(</span><span class="keyword">int</span><span class="special">,</span><span class="identifier"> FilePos</span><span class="special">);</span><span class="keyword">
+int</span><span class="keyword">         operator</span><span class="special">-(</span><span class="identifier">FilePos</span><span class="special">,</span><span class="identifier"> FilePos</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">
+FilePos</span><span class="special">&amp;</span><span class="keyword">    operator</span><span class="special">+=(</span><span class="identifier">FilePos</span><span class="special">&amp;,</span><span class="keyword"> int</span><span class="special">);</span><span class="identifier">
+FilePos</span><span class="special">&amp;</span><span class="keyword">    operator</span><span class="special">-=(</span><span class="identifier">FilePos</span><span class="special">&amp;,</span><span class="keyword"> int</span><span class="special">);</span><span class="keyword">
+bool</span><span class="keyword">        operator</span><span class="special">&lt;(</span><span class="identifier">FilePos</span><span class="special">,</span><span class="identifier"> FilePos</span><span class="special">);</span></tt></pre>
 <p>
-        The class and the various operators can be mapped to Python rather easily
-        and intuitively:
-      </p>
-<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">FilePos</span><span class="special">&gt;(</span><span class="string">"FilePos"</span><span class="special">)</span>
-    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">+</span> <span class="keyword">int</span><span class="special">())</span>          <span class="comment">// __add__</span>
-    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="keyword">int</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">self</span><span class="special">)</span>          <span class="comment">// __radd__</span>
-    <span class="special">.</span><span class="identifier">def</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="comment">// __sub__</span>
-    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">-</span> <span class="keyword">int</span><span class="special">())</span>          <span class="comment">// __sub__</span>
-    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">+=</span> <span class="keyword">int</span><span class="special">())</span>         <span class="comment">// __iadd__</span>
-    <span class="special">.</span><span class="identifier">def</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="keyword">int</span><span class="special">&gt;())</span>
-    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">&lt;</span> <span class="identifier">self</span><span class="special">);</span>          <span class="comment">// __lt__</span>
-</pre>
+The class and the various operators can be mapped to Python rather easily
+and intuitively:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">FilePos</span><span class="special">&gt;(</span><span class="string">"FilePos"</span><span class="special">)</span><span class="special">
+    .</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span><span class="special"> +</span><span class="keyword"> int</span><span class="special">())</span><span class="comment">          // __add__
+</span><span class="special">    .</span><span class="identifier">def</span><span class="special">(</span><span class="keyword">int</span><span class="special">()</span><span class="special"> +</span><span class="identifier"> self</span><span class="special">)</span><span class="comment">          // __radd__
+</span><span class="special">    .</span><span class="identifier">def</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="comment">           // __sub__
+</span><span class="special">    .</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span><span class="special"> -</span><span class="keyword"> int</span><span class="special">())</span><span class="comment">          // __sub__
+</span><span class="special">    .</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span><span class="special"> +=</span><span class="keyword"> int</span><span class="special">())</span><span class="comment">         // __iadd__
+</span><span class="special">    .</span><span class="identifier">def</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="keyword">int</span><span class="special">&gt;())</span><span class="special">
+    .</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span><span class="special"> &lt;</span><span class="identifier"> self</span><span class="special">);</span><span class="comment">          // __lt__
+</span></tt></pre>
 <p>
-        The code snippet above is very clear and needs almost no explanation at all.
-        It is virtually the same as the operators' signatures. Just take note that
-        <code class="literal">self</code> refers to FilePos object. Also, not every class
-        <code class="literal">T</code> that you might need to interact with in an operator
-        expression is (cheaply) default-constructible. You can use <code class="literal">other&lt;T&gt;()</code>
-        in place of an actual <code class="literal">T</code> instance when writing "self
-        expressions".
-      </p>
-<h3>
-<a name="class_operators_special_functions.special_methods"></a>
-        Special Methods
-      </h3>
+The code snippet above is very clear and needs almost no explanation at
+all. It is virtually the same as the operators' signatures. Just take
+note that <tt class="literal">self</tt> refers to FilePos object. Also, not every class <tt class="literal">T</tt> that
+you might need to interact with in an operator expression is (cheaply)
+default-constructible. You can use <tt class="literal">other&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="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"><span class="keyword">class</span> <span class="identifier">Rational</span>
-<span class="special">{</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>
+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"> 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">
 
-<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>
+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">
 
-<span class="identifier">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__</span>
-    <span class="special">.</span><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>                     <span class="comment">// __str__</span>
-    <span class="special">;</span>
-</pre>
+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__
+</span><span class="special">    .</span><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><span class="comment">                     // __str__
+</span><span class="special">    ;</span></tt></pre>
 <p>
-        Need we say more?
-      </p>
-<div class="note"><table border="0" summary="Note">
-<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
-<th align="left">Note</th>
-</tr>
-<tr><td align="left" valign="top"><p>
-          What is the business of <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code>? Well, the method <code class="computeroutput"><span class="identifier">str</span></code> requires the <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code> to do its work (i.e. <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code>
-          is used by the method defined by <code class="computeroutput"><span class="identifier">def</span><span class="special">(</span><span class="identifier">str</span><span class="special">(</span><span class="identifier">self</span><span class="special">))</span></code>.
-        </p></td></tr>
+Need we say more?</p>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<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"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
-      de Guzman, David Abrahams<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
-        http://www.boost.org/LICENSE_1_0.txt </a>)
-      </p>
-</div></td>
+<td align="right"><small>Copyright © 2002-2005 Joel de Guzman, David Abrahams</small></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="hello.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<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>
 </body>
 </html>

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

@@ -1,28 +1,28 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Functions</title>
-<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="prev" href="exposing.html" title="Exposing Classes">
-<link rel="next" href="object.html" title="Object Interface">
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="prev" href="exposing.html" title=" Exposing Classes">
+<link rel="next" href="object.html" title=" Object Interface">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<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="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</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>
-</tr></table>
+</table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="exposing.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="object.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<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">
+<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 class="toc"><dl>
@@ -32,20 +32,17 @@
 <dt><span class="section"><a href="functions.html#python.auto_overloading">Auto-Overloading</a></span></dt>
 </dl></div>
 <p>
-      In this chapter, we'll look at Boost.Python powered functions in closer detail.
-      We will see some facilities to make exposing C++ functions to Python safe from
-      potential pifalls such as dangling pointers and references. We will also see
-      facilities that will make it even easier for us to expose C++ functions that
-      take advantage of C++ features such as overloading and default arguments.
-    </p>
-<div class="blockquote"><blockquote class="blockquote"><p>
-        <span class="emphasis"><em>Read on...</em></span>
-      </p></blockquote></div>
+In this chapter, we'll look at Boost.Python powered functions in closer
+detail. We shall see some facilities to make exposing C++ functions to
+Python safe from potential pifalls such as dangling pointers and
+references. We shall also see facilities that will make it even easier for
+us to expose C++ functions that take advantage of C++ features such as
+overloading and default arguments.</p>
+<div class="blockquote"><blockquote class="blockquote"><p><span class="emphasis"><em>Read on...</em></span></p></blockquote></div>
 <p>
-      But before you do, you might want to fire up Python 2.2 or later and type
-      <code class="literal">&gt;&gt;&gt; import this</code>.
-    </p>
-<pre class="programlisting">&gt;&gt;&gt; import this
+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.
@@ -62,525 +59,422 @@ 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"><strong>right</strong></span> now.
+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>
-<div class="section">
+</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>
 <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 they really
-        don't tell us much. At the very least, we don't know the owner of the pointer
-        or the referenced object. No wonder languages such as Java and Python never
-        deal with such low level entities. In C++, it's usually considered a good
-        practice to use smart pointers which exactly describe ownership semantics.
-        Still, even good C++ interfaces use raw references and pointers sometimes,
-        so Boost.Python must deal with them. To do this, it may need your help. Consider
-        the following C++ function:
-      </p>
-<pre class="programlisting"><span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">);</span>
-</pre>
+In C++, we often deal with arguments and return types such as pointers
+and references. Such primitive types are rather, ummmm, low level and
+they really don't tell us much. At the very least, we don't know the
+owner of the pointer or the referenced object. No wonder languages
+such as Java and Python never deal with such low level entities. In
+C++, it's usually considered a good practice to use smart pointers
+which exactly describe ownership semantics. Still, even good C++
+interfaces use raw references and pointers sometimes, so Boost.Python
+must deal with them. To do this, it may need your help. Consider the
+following C++ function:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">X</span><span class="special">&amp;</span><span class="identifier"> f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span><span class="identifier"> y</span><span class="special">,</span><span class="identifier"> Z</span><span class="special">*</span><span class="identifier"> z</span><span class="special">);</span></tt></pre>
 <p>
-        How should the library wrap this function? A naive approach builds a Python
-        X object around result reference. This strategy might or might not work out.
-        Here's an example where it didn't
-      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="preprocessor"># x</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">some</span> <span class="identifier">C</span><span class="special">++</span> <span class="identifier">X</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">del</span> <span class="identifier">y</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">some_method</span><span class="special">()</span> <span class="preprocessor"># CRASH</span><span class="special">!</span>
-</pre>
+How should the library wrap this function? A naive approach builds a
+Python X object around result reference. This strategy might or might
+not work out. Here's an example where it didn't</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"> 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"> x</span><span class="identifier"> refers</span><span class="identifier"> to</span><span class="identifier"> some</span><span class="identifier"> C</span><span class="special">++</span><span class="identifier"> X</span><span class="special">
+&gt;&gt;&gt;</span><span class="identifier"> del</span><span class="identifier"> y</span><span class="special">
+&gt;&gt;&gt;</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">some_method</span><span class="special">()</span> #<span class="identifier"> CRASH</span><span class="special">!</span></tt></pre>
 <p>
-        What's the problem?
-      </p>
+What's the problem?</p>
 <p>
-        Well, what if f() was implemented as shown below:
-      </p>
-<pre class="programlisting"><span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">)</span>
-<span class="special">{</span>
-    <span class="identifier">y</span><span class="special">.</span><span class="identifier">z</span> <span class="special">=</span> <span class="identifier">z</span><span class="special">;</span>
-    <span class="keyword">return</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">x</span><span class="special">;</span>
-<span class="special">}</span>
-</pre>
+Well, what if f() was implemented as shown below:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">X</span><span class="special">&amp;</span><span class="identifier"> f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span><span class="identifier"> y</span><span class="special">,</span><span class="identifier"> Z</span><span class="special">*</span><span class="identifier"> z</span><span class="special">)</span><span class="special">
+{</span><span class="identifier">
+    y</span><span class="special">.</span><span class="identifier">z</span><span class="special"> =</span><span class="identifier"> z</span><span class="special">;</span><span class="keyword">
+    return</span><span class="identifier"> y</span><span class="special">.</span><span class="identifier">x</span><span class="special">;</span><span class="special">
+}</span></tt></pre>
 <p>
-        The problem is that the lifetime of result X&amp; is tied to the lifetime
-        of y, because the f() returns a reference to a member of the y object. This
-        idiom is is not uncommon and perfectly acceptable in the context of C++.
-        However, Python users should not be able to crash the system just by using
-        our C++ interface. In this case deleting y will invalidate the reference
-        to X. We have a dangling reference.
-      </p>
+The problem is that the lifetime of result X&amp; is tied to the lifetime
+of y, because the f() returns a reference to a member of the y
+object. This idiom is is not uncommon and perfectly acceptable in the
+context of C++. However, Python users should not be able to crash the
+system just by using our C++ interface. In this case deleting y will
+invalidate the reference to X. We have a dangling reference.</p>
 <p>
-        Here's what's happening:
-      </p>
-<div class="orderedlist"><ol class="orderedlist" type="1">
-<li class="listitem">
-            <code class="literal">f</code> is called passing in a reference to <code class="literal">y</code>
-            and a pointer to <code class="literal">z</code>
-          </li>
-<li class="listitem">
-            A reference to <code class="literal">y.x</code> is returned
-          </li>
-<li class="listitem">
-            <code class="literal">y</code> is deleted. <code class="literal">x</code> is a dangling reference
-          </li>
-<li class="listitem">
-            <code class="literal">x.some_method()</code> is called
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>BOOM!</strong></span>
-          </li>
+Here's what's happening:</p>
+<div class="orderedlist"><ol type="1">
+<li>
+<tt class="literal">f</tt> is called passing in a reference to <tt class="literal">y</tt> and a pointer to <tt class="literal">z</tt>
+</li>
+<li>
+A reference to <tt class="literal">y.x</tt> is returned
+</li>
+<li>
+<tt class="literal">y</tt> is deleted. <tt class="literal">x</tt> is a dangling reference
+</li>
+<li>
+<tt class="literal">x.some_method()</tt> is called
+</li>
+<li><span class="bold"><b>BOOM!</b></span></li>
 </ol></div>
 <p>
-        We could copy result into a new object:
-      </p>
-<pre class="programlisting"><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>
-</pre>
+We could copy result into a new object:</p>
+<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>
+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>
-<pre class="programlisting"><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">int</span> <span class="identifier">z_value</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">z</span><span class="special">-&gt;</span><span class="identifier">value</span><span class="special">();</span> <span class="special">}</span>
-<span class="special">};</span>
-</pre>
+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">
+    int</span><span class="identifier"> z_value</span><span class="special">()</span><span class="special"> {</span><span class="keyword"> return</span><span class="identifier"> z</span><span class="special">-&gt;</span><span class="identifier">value</span><span class="special">();</span><span class="special"> }</span><span class="special">
+};</span></tt></pre>
 <p>
-        Notice that the data member <code class="literal">z</code> is held by class Y using
-        a raw pointer. Now we have a potential dangling pointer problem inside Y:
-      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="preprocessor"># y</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">z</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">del</span> <span class="identifier">z</span>       <span class="preprocessor"># Kill</span> <span class="identifier">the</span> <span class="identifier">z</span> <span class="identifier">object</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">z_value</span><span class="special">()</span> <span class="preprocessor"># CRASH</span><span class="special">!</span>
-</pre>
+Notice that the data member <tt class="literal">z</tt> is held by class Y using a raw
+pointer. Now we have a potential dangling pointer problem inside Y:</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"> 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"> y</span><span class="identifier"> refers</span><span class="identifier"> to</span><span class="identifier"> z</span><span class="special">
+&gt;&gt;&gt;</span><span class="identifier"> del</span><span class="identifier"> z</span>       #<span class="identifier"> Kill</span><span class="identifier"> the</span><span class="identifier"> z</span><span class="identifier"> object</span><span class="special">
+&gt;&gt;&gt;</span><span class="identifier"> y</span><span class="special">.</span><span class="identifier">z_value</span><span class="special">()</span> #<span class="identifier"> CRASH</span><span class="special">!</span></tt></pre>
 <p>
-        For reference, here's the implementation of <code class="literal">f</code> again:
-      </p>
-<pre class="programlisting"><span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">)</span>
-<span class="special">{</span>
-    <span class="identifier">y</span><span class="special">.</span><span class="identifier">z</span> <span class="special">=</span> <span class="identifier">z</span><span class="special">;</span>
-    <span class="keyword">return</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">x</span><span class="special">;</span>
-<span class="special">}</span>
-</pre>
+For reference, here's the implementation of <tt class="literal">f</tt> again:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">X</span><span class="special">&amp;</span><span class="identifier"> f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span><span class="identifier"> y</span><span class="special">,</span><span class="identifier"> Z</span><span class="special">*</span><span class="identifier"> z</span><span class="special">)</span><span class="special">
+{</span><span class="identifier">
+    y</span><span class="special">.</span><span class="identifier">z</span><span class="special"> =</span><span class="identifier"> z</span><span class="special">;</span><span class="keyword">
+    return</span><span class="identifier"> y</span><span class="special">.</span><span class="identifier">x</span><span class="special">;</span><span class="special">
+}</span></tt></pre>
 <p>
-        Here's what's happening:
-      </p>
-<div class="orderedlist"><ol class="orderedlist" type="1">
-<li class="listitem">
-            <code class="literal">f</code> is called passing in a reference to <code class="literal">y</code>
-            and a pointer to <code class="literal">z</code>
-          </li>
-<li class="listitem">
-            A pointer to <code class="literal">z</code> is held by <code class="literal">y</code>
-          </li>
-<li class="listitem">
-            A reference to <code class="literal">y.x</code> is returned
-          </li>
-<li class="listitem">
-            <code class="literal">z</code> is deleted. <code class="literal">y.z</code> is a dangling
-            pointer
-          </li>
-<li class="listitem">
-            <code class="literal">y.z_value()</code> is called
-          </li>
-<li class="listitem">
-            <code class="literal">z-&gt;value()</code> is called
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>BOOM!</strong></span>
-          </li>
+Here's what's happening:</p>
+<div class="orderedlist"><ol type="1">
+<li>
+<tt class="literal">f</tt> is called passing in a reference to <tt class="literal">y</tt> and a pointer to <tt class="literal">z</tt>
+</li>
+<li>
+A pointer to <tt class="literal">z</tt> is held by <tt class="literal">y</tt>
+</li>
+<li>
+A reference to <tt class="literal">y.x</tt> is returned
+</li>
+<li>
+<tt class="literal">z</tt> is deleted. <tt class="literal">y.z</tt> is a dangling pointer
+</li>
+<li>
+<tt class="literal">y.z_value()</tt> is called
+</li>
+<li>
+<tt class="literal">z-&gt;value()</tt> is called
+</li>
+<li><span class="bold"><b>BOOM!</b></span></li>
 </ol></div>
-<h3>
-<a name="call_policies.call_policies"></a>
-        Call Policies
-      </h3>
+<a name="call_policies.call_policies"></a><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, <code class="literal">return_internal_reference</code> and <code class="literal">with_custodian_and_ward</code>
-        are our friends:
-      </p>
-<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span>
-    <span class="identifier">return_internal_reference</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span>
-        <span class="identifier">with_custodian_and_ward</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">&gt;</span> <span class="special">&gt;());</span>
-</pre>
+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>
+are our friends:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span><span class="identifier"> f</span><span class="special">,</span><span class="identifier">
+    return_internal_reference</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span><span class="identifier">
+        with_custodian_and_ward</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span><span class="number"> 2</span><span class="special">&gt;</span><span class="special"> &gt;());</span></tt></pre>
 <p>
-        What are the <code class="literal">1</code> and <code class="literal">2</code> parameters, you
-        ask?
-      </p>
-<pre class="programlisting"><span class="identifier">return_internal_reference</span><span class="special">&lt;</span><span class="number">1</span>
-</pre>
+What are the <tt class="literal">1</tt> and <tt class="literal">2</tt> parameters, you ask?</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">return_internal_reference</span><span class="special">&lt;</span><span class="number">1</span></tt></pre>
 <p>
-        Informs Boost.Python that the first argument, in our case <code class="literal">Y&amp;
-        y</code>, is the owner of the returned reference: <code class="literal">X&amp;</code>.
-        The "<code class="literal">1</code>" simply specifies the first argument.
-        In short: "return an internal reference <code class="literal">X&amp;</code> owned
-        by the 1st argument <code class="literal">Y&amp; y</code>".
-      </p>
-<pre class="programlisting"><span class="identifier">with_custodian_and_ward</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">&gt;</span>
-</pre>
+Informs Boost.Python that the first argument, in our case <tt class="literal">Y&amp; y</tt>, is the
+owner of the returned reference: <tt class="literal">X&amp;</tt>. The "<tt class="literal">1</tt>" simply specifies the
+first argument. In short: "return an internal reference <tt class="literal">X&amp;</tt> owned by the
+1st argument <tt class="literal">Y&amp; y</tt>".</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">with_custodian_and_ward</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span><span class="number"> 2</span><span class="special">&gt;</span></tt></pre>
 <p>
-        Informs Boost.Python that the lifetime of the argument indicated by ward
-        (i.e. the 2nd argument: <code class="literal">Z* z</code>) is dependent on the lifetime
-        of the argument indicated by custodian (i.e. the 1st argument: <code class="literal">Y&amp;
-        y</code>).
-      </p>
+Informs Boost.Python that the lifetime of the argument indicated by ward
+(i.e. the 2nd argument: <tt class="literal">Z* z</tt>) is dependent on the lifetime of the
+argument indicated by custodian (i.e. the 1st argument: <tt class="literal">Y&amp; y</tt>).</p>
 <p>
-        It is also important to note that we have defined two policies above. Two
-        or more policies can be composed by chaining. Here's the general syntax:
-      </p>
-<pre class="programlisting"><span class="identifier">policy1</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...,</span>
-    <span class="identifier">policy2</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...,</span>
-        <span class="identifier">policy3</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span>
-</pre>
+It is also important to note that we have defined two policies above. Two
+or more policies can be composed by chaining. Here's the general syntax:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">policy1</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...,</span><span class="identifier">
+    policy2</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...,</span><span class="identifier">
+        policy3</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...&gt;</span><span class="special"> &gt;</span><span class="special"> &gt;</span></tt></pre>
 <p>
-        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 class="itemizedlist" type="disc">
-<li class="listitem">
-            <span class="bold"><strong>with_custodian_and_ward</strong></span>: Ties lifetimes
-            of the arguments
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>with_custodian_and_ward_postcall</strong></span>: Ties
-            lifetimes of the arguments and results
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>return_internal_reference</strong></span>: Ties lifetime
-            of one argument to that of result
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>return_value_policy&lt;T&gt; with T one of:</strong></span>
-            <div class="itemizedlist"><ul class="itemizedlist" type="circle">
-<li class="listitem">
-                  <span class="bold"><strong>reference_existing_object</strong></span>: naive
-                  (dangerous) approach
-                </li>
-<li class="listitem">
-                  <span class="bold"><strong>copy_const_reference</strong></span>: Boost.Python
-                  v1 approach
-                </li>
-<li class="listitem">
-                  <span class="bold"><strong>copy_non_const_reference</strong></span>:
-                </li>
-<li class="listitem">
-                  <span class="bold"><strong>manage_new_object</strong></span>: Adopt a pointer
-                  and hold the instance
-                </li>
+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><br>
+ Ties lifetimes of the arguments
+</li>
+<li>
+<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><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><br>
+</li>
+<li>
+<span class="bold"><b>reference_existing_object</b></span><br>
+naive (dangerous) approach
+</li>
+<li>
+<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><br>
+</li>
+<li>
+<span class="bold"><b>manage_new_object</b></span><br>
+ Adopt a pointer and hold the instance
+</li>
 </ul></div>
-          </li>
-</ul></div>
-<div class="sidebar">
-<div class="titlepage"></div>
-<p>
-        <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span> <span class="bold"><strong>Remember the Zen, Luke:</strong></span>
-      </p>
-<p>
-        "Explicit is better than implicit"
-      </p>
-<p>
-        "In the face of ambiguity, refuse the temptation to guess"
-      </p>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<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"<br>
+
+"In the face of ambiguity, refuse the temptation to guess"<br>
+</td></tr></tbody>
+</table></div>
 </div>
-</div>
-<div class="section">
+<div class="section" lang="en">
 <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 overloaded
-        non-member functions.
-      </p>
+The following illustrates a scheme for manually wrapping an overloaded
+member functions. Of course, the same technique can be applied to wrapping
+overloaded non-member functions.</p>
 <p>
-        We have here our C++ class:
-      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">X</span>
-<span class="special">{</span>
-    <span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">)</span>
-    <span class="special">{</span>
-        <span class="keyword">return</span> <span class="keyword">true</span><span class="special">;</span>
-    <span class="special">}</span>
+We have here our C++ class:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">struct</span><span class="identifier"> X</span><span class="special">
+{</span><span class="keyword">
+    bool</span><span class="identifier"> f</span><span class="special">(</span><span class="keyword">int</span><span class="identifier"> a</span><span class="special">)</span><span class="special">
+    {</span><span class="keyword">
+        return</span><span class="keyword"> true</span><span class="special">;</span><span class="special">
+    }</span><span class="keyword">
 
-    <span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">b</span><span class="special">)</span>
-    <span class="special">{</span>
-        <span class="keyword">return</span> <span class="keyword">true</span><span class="special">;</span>
-    <span class="special">}</span>
+    bool</span><span class="identifier"> f</span><span class="special">(</span><span class="keyword">int</span><span class="identifier"> a</span><span class="special">,</span><span class="keyword"> double</span><span class="identifier"> b</span><span class="special">)</span><span class="special">
+    {</span><span class="keyword">
+        return</span><span class="keyword"> true</span><span class="special">;</span><span class="special">
+    }</span><span class="keyword">
 
-    <span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">b</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">c</span><span class="special">)</span>
-    <span class="special">{</span>
-        <span class="keyword">return</span> <span class="keyword">true</span><span class="special">;</span>
-    <span class="special">}</span>
+    bool</span><span class="identifier"> f</span><span class="special">(</span><span class="keyword">int</span><span class="identifier"> a</span><span class="special">,</span><span class="keyword"> double</span><span class="identifier"> b</span><span class="special">,</span><span class="keyword"> char</span><span class="identifier"> c</span><span class="special">)</span><span class="special">
+    {</span><span class="keyword">
+        return</span><span class="keyword"> true</span><span class="special">;</span><span class="special">
+    }</span><span class="keyword">
 
-    <span class="keyword">int</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">b</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">c</span><span class="special">)</span>
-    <span class="special">{</span>
-        <span class="keyword">return</span> <span class="identifier">a</span> <span class="special">+</span> <span class="identifier">b</span> <span class="special">+</span> <span class="identifier">c</span><span class="special">;</span>
-    <span class="special">};</span>
-<span class="special">};</span>
-</pre>
+    int</span><span class="identifier"> f</span><span class="special">(</span><span class="keyword">int</span><span class="identifier"> a</span><span class="special">,</span><span class="keyword"> int</span><span class="identifier"> b</span><span class="special">,</span><span class="keyword"> int</span><span class="identifier"> c</span><span class="special">)</span><span class="special">
+    {</span><span class="keyword">
+        return</span><span class="identifier"> a</span><span class="special"> +</span><span class="identifier"> b</span><span class="special"> +</span><span class="identifier"> c</span><span class="special">;</span><span class="special">
+    };</span><span class="special">
+};</span></tt></pre>
 <p>
-        Class X has 4 overloaded functions. We will start by introducing some member
-        function pointer variables:
-      </p>
-<pre class="programlisting"><span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">)</span>              <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
-<span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx2</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">)</span>      <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
-<span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx3</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">char</span><span class="special">)=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
-<span class="keyword">int</span>     <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx4</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)</span>    <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
-</pre>
+Class X has 4 overloaded functions. We shall start by introducing some
+member function pointer variables:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">bool</span><span class="special">    (</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">)</span><span class="special">              =</span><span class="special"> &amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span><span class="keyword">
+bool</span><span class="special">    (</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx2</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span><span class="keyword"> double</span><span class="special">)</span><span class="special">      =</span><span class="special"> &amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span><span class="keyword">
+bool</span><span class="special">    (</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx3</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span><span class="keyword"> double</span><span class="special">,</span><span class="keyword"> char</span><span class="special">)=</span><span class="special"> &amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span><span class="keyword">
+int</span><span class="special">     (</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx4</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span><span class="keyword"> int</span><span class="special">,</span><span class="keyword"> int</span><span class="special">)</span><span class="special">    =</span><span class="special"> &amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span></tt></pre>
 <p>
-        With these in hand, we can proceed to define and wrap this for Python:
-      </p>
-<pre class="programlisting"><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">fx1</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">fx2</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">fx3</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">fx4</span><span class="special">)</span>
-</pre>
+With these in hand, we can proceed to define and wrap this for Python:</p>
+<pre class="programlisting"><tt class="literal"><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"> fx1</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"> fx2</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"> fx3</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"> fx4</span><span class="special">)</span></tt></pre>
 </div>
-<div class="section">
+<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>
 <p>
-        Boost.Python wraps (member) function pointers. Unfortunately, C++ function
-        pointers carry no default argument info. Take a function <code class="literal">f</code>
-        with default arguments:
-      </p>
-<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span> <span class="special">=</span> <span class="number">3.14</span><span class="special">,</span> <span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="special">=</span> <span class="string">"hello"</span><span class="special">);</span>
-</pre>
+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
+arguments:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">int</span><span class="identifier"> f</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span><span class="keyword"> double</span><span class="special"> =</span><span class="number"> 3.14</span><span class="special">,</span><span class="keyword"> char</span><span class="keyword"> const</span><span class="special">*</span><span class="special"> =</span><span class="string"> "hello"</span><span class="special">);</span></tt></pre>
 <p>
-        But the type of a pointer to the function <code class="literal">f</code> has no information
-        about its default arguments:
-      </p>
-<pre class="programlisting"><span class="keyword">int</span><span class="special">(*</span><span class="identifier">g</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span><span class="keyword">double</span><span class="special">,</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*)</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">;</span>    <span class="comment">// defaults lost!</span>
-</pre>
+But the type of a pointer to the function <tt class="literal">f</tt> has no information
+about its default arguments:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">int</span><span class="special">(*</span><span class="identifier">g</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span><span class="keyword">double</span><span class="special">,</span><span class="keyword">char</span><span class="keyword"> const</span><span class="special">*)</span><span class="special"> =</span><span class="identifier"> f</span><span class="special">;</span><span class="comment">    // defaults lost!
+</span></tt></pre>
 <p>
-        When we pass this function pointer to the <code class="literal">def</code> function,
-        there is no way to retrieve the default arguments:
-      </p>
-<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span>                            <span class="comment">// defaults lost!</span>
-</pre>
+When we pass this function pointer to the <tt class="literal">def</tt> function, there is no way
+to retrieve the default arguments:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span><span class="identifier"> f</span><span class="special">);</span><span class="comment">                            // defaults lost!
+</span></tt></pre>
 <p>
-        Because of this, when wrapping C++ code, we had to resort to manual wrapping
-        as outlined in the <a class="link" href="functions.html#python.overloading" title="Overloading">previous section</a>,
-        or writing thin wrappers:
-      </p>
-<pre class="programlisting"><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="keyword">return</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">int</span> <span class="identifier">f2</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">return</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="special">}</span>
+Because of this, when wrapping C++ code, we had to resort to manual
+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">
+int</span><span class="identifier"> f2</span><span class="special">(</span><span class="keyword">int</span><span class="identifier"> x</span><span class="special">,</span><span class="keyword"> double</span><span class="identifier"> y</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="identifier">y</span><span class="special">);</span><span class="special"> }</span><span class="comment">
 
-<span class="comment">/*...*/</span>
+/*...*/
 
-    <span class="comment">// in module init</span>
-    <span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span>  <span class="comment">// all arguments</span>
-    <span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f2</span><span class="special">);</span> <span class="comment">// two arguments</span>
-    <span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f1</span><span class="special">);</span> <span class="comment">// one argument</span>
-</pre>
+    // in module init
+</span><span class="identifier">    def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span><span class="identifier"> f</span><span class="special">);</span><span class="comment">  // all arguments
+</span><span class="identifier">    def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span><span class="identifier"> f2</span><span class="special">);</span><span class="comment"> // two arguments
+</span><span class="identifier">    def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span><span class="identifier"> f1</span><span class="special">);</span><span class="comment"> // one argument
+</span></tt></pre>
 <p>
-        When you want to wrap functions (or member functions) that either:
-      </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-            have default arguments, or
-          </li>
-<li class="listitem">
-            are overloaded with a common sequence of initial arguments
-          </li>
+When you want to wrap functions (or member functions) that either:</p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+have default arguments, or
+</li>
+<li>
+are overloaded with a common sequence of initial arguments
+</li>
 </ul></div>
-<h3>
-<a name="default_arguments.boost_python_function_overloads"></a>
-        BOOST_PYTHON_FUNCTION_OVERLOADS
-      </h3>
+<a name="default_arguments.boost_python_function_overloads"></a><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"><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">{</span>
-    <span class="comment">/*...*/</span>
-<span class="special">}</span>
-</pre>
+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">
+{</span><span class="comment">
+    /*...*/</span><span class="special">
+}</span></tt></pre>
 <p>
-        The macro invocation:
-      </p>
-<pre class="programlisting"><span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
-</pre>
+The macro invocation:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span><span class="identifier"> foo</span><span class="special">,</span><span class="number"> 1</span><span class="special">,</span><span class="number"> 4</span><span class="special">)</span></tt></pre>
 <p>
-        will automatically create the thin wrappers for us. This macro will create
-        a class <code class="literal">foo_overloads</code> that can be passed on to <code class="literal">def(...)</code>.
-        The third and fourth macro argument are the minimum arguments and maximum
-        arguments, respectively. In our <code class="literal">foo</code> function the minimum
-        number of arguments is 1 and the maximum number of arguments is 4. The <code class="literal">def(...)</code>
-        function will automatically add all the foo variants for us:
-      </p>
-<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
-</pre>
-<h3>
-<a name="default_arguments.boost_python_member_function_overloads"></a>
-        BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS
-      </h3>
+will automatically create the thin wrappers for us. This macro will create
+a class <tt class="literal">foo_overloads</tt> that can be passed on to <tt class="literal">def(...)</tt>. The third
+and fourth macro argument are the minimum arguments and maximum arguments,
+respectively. In our <tt class="literal">foo</tt> function the minimum number of arguments is 1
+and the maximum number of arguments is 4. The <tt class="literal">def(...)</tt> function will
+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="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
-        Python. Then again, we have the same inconveniences as before when default
-        arguments or overloads with a common sequence of initial arguments come into
-        play. Another macro is provided to make this a breeze.
-      </p>
+Objects here, objects there, objects here there everywhere. More frequently
+than anything else, we need to expose member functions of our classes to
+Python. Then again, we have the same inconveniences as before when default
+arguments or overloads with a common sequence of initial arguments come
+into play. Another macro is provided to make this a breeze.</p>
 <p>
-        Like <code class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</code>, <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code>
-        may be used to automatically create the thin wrappers for wrapping member
-        functions. Let's have an example:
-      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">george</span>
-<span class="special">{</span>
-    <span class="keyword">void</span>
-    <span class="identifier">wack_em</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">c</span> <span class="special">=</span> <span class="char">'x'</span><span class="special">)</span>
-    <span class="special">{</span>
-        <span class="comment">/*...*/</span>
-    <span class="special">}</span>
-<span class="special">};</span>
-</pre>
+Like <tt class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</tt>,
+<tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt> may be used to automatically create
+the thin wrappers for wrapping member functions. Let's have an example:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">struct</span><span class="identifier"> george</span><span class="special">
+{</span><span class="keyword">
+    void</span><span class="identifier">
+    wack_em</span><span class="special">(</span><span class="keyword">int</span><span class="identifier"> a</span><span class="special">,</span><span class="keyword"> int</span><span class="identifier"> b</span><span class="special"> =</span><span class="number"> 0</span><span class="special">,</span><span class="keyword"> char</span><span class="identifier"> c</span><span class="special"> =</span><span class="char"> 'x'</span><span class="special">)</span><span class="special">
+    {</span><span class="comment">
+        /*...*/</span><span class="special">
+    }</span><span class="special">
+};</span></tt></pre>
 <p>
-        The macro invocation:
-      </p>
-<pre class="programlisting"><span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">george_overloads</span><span class="special">,</span> <span class="identifier">wack_em</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
-</pre>
+The macro invocation:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">george_overloads</span><span class="special">,</span><span class="identifier"> wack_em</span><span class="special">,</span><span class="number"> 1</span><span class="special">,</span><span class="number"> 3</span><span class="special">)</span></tt></pre>
 <p>
-        will generate a set of thin wrappers for george's <code class="literal">wack_em</code>
-        member function accepting a minimum of 1 and a maximum of 3 arguments (i.e.
-        the third and fourth macro argument). The thin wrappers are all enclosed
-        in a class named <code class="literal">george_overloads</code> that can then be used
-        as an argument to <code class="literal">def(...)</code>:
-      </p>
-<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"wack_em"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">george</span><span class="special">::</span><span class="identifier">wack_em</span><span class="special">,</span> <span class="identifier">george_overloads</span><span class="special">());</span>
-</pre>
+will generate a set of thin wrappers for george's <tt class="literal">wack_em</tt> member function
+accepting a minimum of 1 and a maximum of 3 arguments (i.e. the third and
+fourth macro argument). The thin wrappers are all enclosed in a class named
+<tt class="literal">george_overloads</tt> that can then be used as an argument to <tt class="literal">def(...)</tt>:</p>
+<pre class="programlisting"><tt class="literal"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"wack_em"</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">george</span><span class="special">::</span><span class="identifier">wack_em</span><span class="special">,</span><span class="identifier"> george_overloads</span><span class="special">());</span></tt></pre>
 <p>
-        See the <a href="../../../../v2/overloads.html#BOOST_PYTHON_FUNCTION_OVERLOADS-spec" target="_top">overloads
-        reference</a> for details.
-      </p>
-<h3>
-<a name="default_arguments.init_and_optional"></a>
-        init and optional
-      </h3>
+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="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 <code class="literal">init&lt;...&gt;</code>?
-        For example, given a class X with a constructor:
-      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">X</span>
-<span class="special">{</span>
-    <span class="identifier">X</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="char">'D'</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">c</span> <span class="special">=</span> <span class="string">"constructor"</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">);</span>
-    <span class="comment">/*...*/</span>
-<span class="special">}</span>
-</pre>
+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,
+given a class X with a constructor:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">struct</span><span class="identifier"> X</span><span class="special">
+{</span><span class="identifier">
+    X</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="char"> 'D'</span><span class="special">,</span><span class="identifier"> std</span><span class="special">::</span><span class="identifier">string</span><span class="identifier"> c</span><span class="special"> =</span><span class="string"> "constructor"</span><span class="special">,</span><span class="keyword"> double</span><span class="identifier"> d</span><span class="special"> =</span><span class="number"> 0.0</span><span class="special">);</span><span class="comment">
+    /*...*/</span><span class="special">
+}</span></tt></pre>
 <p>
-        You can easily add this constructor to Boost.Python in one shot:
-      </p>
-<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span> <span class="special">&gt;())</span>
-</pre>
+You can easily add this constructor to Boost.Python in one shot:</p>
+<pre class="programlisting"><tt class="literal"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span><span class="identifier"> optional</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span><span class="identifier"> std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span><span class="keyword"> double</span><span class="special">&gt;</span><span class="special"> &gt;())</span></tt></pre>
 <p>
-        Notice the use of <code class="literal">init&lt;...&gt;</code> and <code class="literal">optional&lt;...&gt;</code>
-        to signify the default (optional arguments).
-      </p>
+Notice the use of <tt class="literal">init&lt;...&gt;</tt> and <tt class="literal">optional&lt;...&gt;</tt> to signify the default
+(optional arguments).</p>
 </div>
-<div class="section">
+<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>
 <p>
-        It was mentioned in passing in the previous section that <code class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</code>
-        and <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code> can also be
-        used for overloaded functions and member functions with a common sequence
-        of initial arguments. Here is an example:
-      </p>
-<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">foo</span><span class="special">()</span>
-<span class="special">{</span>
-   <span class="comment">/*...*/</span>
-<span class="special">}</span>
+It was mentioned in passing in the previous section that
+<tt class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</tt> and <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt>
+can also be used for overloaded functions and member functions with a
+common sequence of initial arguments. Here is an example:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">void</span><span class="identifier"> foo</span><span class="special">()</span><span class="special">
+{</span><span class="comment">
+   /*...*/</span><span class="special">
+}</span><span class="keyword">
 
-<span class="keyword">void</span> <span class="identifier">foo</span><span class="special">(</span><span class="keyword">bool</span> <span class="identifier">a</span><span class="special">)</span>
-<span class="special">{</span>
-   <span class="comment">/*...*/</span>
-<span class="special">}</span>
+void</span><span class="identifier"> foo</span><span class="special">(</span><span class="keyword">bool</span><span class="identifier"> a</span><span class="special">)</span><span class="special">
+{</span><span class="comment">
+   /*...*/</span><span class="special">
+}</span><span class="keyword">
 
-<span class="keyword">void</span> <span class="identifier">foo</span><span class="special">(</span><span class="keyword">bool</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">b</span><span class="special">)</span>
-<span class="special">{</span>
-   <span class="comment">/*...*/</span>
-<span class="special">}</span>
+void</span><span class="identifier"> foo</span><span class="special">(</span><span class="keyword">bool</span><span class="identifier"> a</span><span class="special">,</span><span class="keyword"> int</span><span class="identifier"> b</span><span class="special">)</span><span class="special">
+{</span><span class="comment">
+   /*...*/</span><span class="special">
+}</span><span class="keyword">
 
-<span class="keyword">void</span> <span class="identifier">foo</span><span class="special">(</span><span class="keyword">bool</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">b</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">c</span><span class="special">)</span>
-<span class="special">{</span>
-   <span class="comment">/*...*/</span>
-<span class="special">}</span>
-</pre>
+void</span><span class="identifier"> foo</span><span class="special">(</span><span class="keyword">bool</span><span class="identifier"> a</span><span class="special">,</span><span class="keyword"> int</span><span class="identifier"> b</span><span class="special">,</span><span class="keyword"> char</span><span class="identifier"> c</span><span class="special">)</span><span class="special">
+{</span><span class="comment">
+   /*...*/</span><span class="special">
+}</span></tt></pre>
 <p>
-        Like in the previous section, we can generate thin wrappers for these overloaded
-        functions in one-shot:
-      </p>
-<pre class="programlisting"><span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
-</pre>
+Like in the previous section, we can generate thin wrappers for these
+overloaded functions in one-shot:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span><span class="identifier"> foo</span><span class="special">,</span><span class="number"> 0</span><span class="special">,</span><span class="number"> 3</span><span class="special">)</span></tt></pre>
 <p>
-        Then...
-      </p>
-<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="special">(</span><span class="keyword">void</span><span class="special">(*)(</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">))</span><span class="number">0</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
-</pre>
+Then...</p>
+<pre class="programlisting"><tt class="literal"><span class="special">.</span><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>
 <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>
-<h3>
-<a name="auto_overloading.manual_wrapping"></a>
-        Manual Wrapping
-      </h3>
+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="id452969"></a>Manual Wrapping</h2>
 <p>
-        It is important to emphasize however that <span class="bold"><strong>the overloaded
-        functions must have a common sequence of initial arguments</strong></span>. Otherwise,
-        our scheme above will not work. If this is not the case, we have to wrap
-        our functions <a class="link" href="functions.html#python.overloading" title="Overloading">manually</a>.
-      </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#python.overloading" title="Overloading">manually</a>.</p>
 <p>
-        Actually, we can mix and match manual wrapping of overloaded functions and
-        automatic wrapping through <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code>
-        and its sister, <code class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</code>. Following
-        up on our example presented in the section <a class="link" href="functions.html#python.overloading" title="Overloading">on
-        overloading</a>, since the first 4 overload functins have a common sequence
-        of initial arguments, we can use <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code>
-        to automatically wrap the first three of the <code class="literal">def</code>s and
-        manually wrap just the last. Here's how we'll do this:
-      </p>
-<pre class="programlisting"><span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">xf_overloads</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
-</pre>
+Actually, we can mix and match manual wrapping of overloaded functions and
+automatic wrapping through <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt> and
+its sister, <tt class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</tt>. Following up on our example
+presented in the section <a href="functions.html#python.overloading" title="Overloading">on 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
+how we'll do this:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">xf_overloads</span><span class="special">,</span><span class="identifier"> f</span><span class="special">,</span><span class="number"> 1</span><span class="special">,</span><span class="number"> 4</span><span class="special">)</span></tt></pre>
 <p>
-        Create a member function pointers as above for both X::f overloads:
-      </p>
-<pre class="programlisting"><span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">char</span><span class="special">)</span>    <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
-<span class="keyword">int</span>     <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx2</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)</span>        <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
-</pre>
+Create a member function pointers as above for both X::f overloads:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">bool</span><span class="special">    (</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span><span class="keyword"> double</span><span class="special">,</span><span class="keyword"> char</span><span class="special">)</span><span class="special">    =</span><span class="special"> &amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span><span class="keyword">
+int</span><span class="special">     (</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx2</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span><span class="keyword"> int</span><span class="special">,</span><span class="keyword"> int</span><span class="special">)</span><span class="special">        =</span><span class="special"> &amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span></tt></pre>
 <p>
-        Then...
-      </p>
-<pre class="programlisting"><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">fx1</span><span class="special">,</span> <span class="identifier">xf_overloads</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">fx2</span><span class="special">)</span>
-</pre>
+Then...</p>
+<pre class="programlisting"><tt class="literal"><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"> fx1</span><span class="special">,</span><span class="identifier"> xf_overloads</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"> fx2</span><span class="special">)</span></tt></pre>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
-      de Guzman, David Abrahams<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
-        http://www.boost.org/LICENSE_1_0.txt </a>)
-      </p>
-</div></td>
+<td align="right"><small>Copyright © 2002-2005 Joel de Guzman, David Abrahams</small></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="exposing.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="object.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<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>
 </body>
 </html>

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

@@ -1,195 +1,243 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Building Hello World</title>
-<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="prev" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="next" href="exposing.html" title="Exposing Classes">
+<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.66.1">
+<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="prev" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="next" href="exposing.html" title=" Exposing Classes">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<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="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</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>
-</tr></table>
+</table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../index.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<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">
+<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>
-<h3>
-<a name="hello.from_start_to_finish"></a>
-      From Start To Finish
-    </h3>
+<a name="python.hello"></a> Building Hello World</h2></div></div></div>
+<a name="hello.from_start_to_finish"></a><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 will outline the steps necessary
-      to achieve that. We will use the build tool that comes bundled with every boost
-      distribution: <span class="bold"><strong>bjam</strong></span>.
-    </p>
-<div class="note"><table border="0" summary="Note">
-<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
-<th align="left">Note</th>
-</tr>
-<tr><td align="left" valign="top">
-<p>
-        <span class="bold"><strong>Building without bjam</strong></span>
-      </p>
-<p>
-        Besides bjam, there are of course other ways to get your module built. What's
-        written here should not be taken as "the one and only way". There
-        are of course other build tools apart from <code class="literal">bjam</code>.
-      </p>
-<p>
-        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
-        that 90% of the "I can't build Boost.Python" problems come from
-        people who had to use a different tool.
-      </p>
-</td></tr>
+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
+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 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>.<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
+    that 90% of the "I can't build Boost.Python" problems come from people
+    who had to use a different tool.
+</td></tr></tbody>
 </table></div>
 <p>
-      We will skip over the details. Our objective will be to simply create the hello
-      world module and run it in Python. For a complete reference to building Boost.Python,
-      check out: <a href="../../../../building.html" target="_top">building.html</a>. After
-      this brief <span class="emphasis"><em>bjam</em></span> tutorial, we should have built the DLLs
-      and run a python program using the extension.
-    </p>
-<p>
-      The tutorial example can be found in the directory: <code class="literal">libs/python/example/tutorial</code>.
-      There, you can find:
-    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-          hello.cpp
-        </li>
-<li class="listitem">
-          hello.py
-        </li>
-<li class="listitem">
-          Jamroot
-        </li>
+We shall skip over the details. Our objective will be to simply create the
+hello world module and run it in Python. For a complete reference to
+building Boost.Python, check out: <a href="../../../../building.html" target="_top">building.html</a>.
+After this brief <span class="emphasis"><em>bjam</em></span> tutorial, we should have built two DLLs:</p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+boost_python.dll
+</li>
+<li>
+hello.pyd
+</li>
 </ul></div>
 <p>
-      The <code class="literal">hello.cpp</code> file is our C++ hello world example. The
-      <code class="literal">Jamroot</code> is a minimalist <span class="emphasis"><em>bjam</em></span> script
-      that builds the DLLs for us. Finally, <code class="literal">hello.py</code> is our Python
-      program that uses the extension in <code class="literal">hello.cpp</code>.
-    </p>
+if you are on Windows, and</p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+libboost_python.so
+</li>
+<li>
+hello.so
+</li>
+</ul></div>
 <p>
-      Before anything else, you should have the bjam executable in your boost directory
-      or somewhere in your path such that <code class="literal">bjam</code> can be executed
-      in the command line. Pre-built Boost.Jam executables are available for most
-      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>
-<h3>
-<a name="hello.let_s_jam_"></a>
-      Let's Jam!
-    </h3>
+if you are on Unix.</p>
 <p>
-      <span class="inlinemediaobject"><img src="../images/jam.png" alt="jam"></span>
-    </p>
+The tutorial example can be found in the directory:
+<tt class="literal">libs/python/example/tutorial</tt>. There, you can find:</p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+hello.cpp
+</li>
+<li>
+Jamfile
+</li>
+</ul></div>
 <p>
-      <a href="../../../../../example/tutorial/Jamroot" target="_top">Here</a> is our minimalist
-      Jamroot file. Simply copy the file and tweak <code class="literal">use-project boost</code>
-      to where your boost root directory is and your OK.
-    </p>
+The <tt class="literal">hello.cpp</tt> file is our C++ hello world example. The <tt class="literal">Jamfile</tt> is a
+minimalist <span class="emphasis"><em>bjam</em></span> script that builds the DLLs for us.</p>
 <p>
-      The comments contained in the Jamrules file above should be sufficient to get
-      you going.
-    </p>
-<h3>
-<a name="hello.running_bjam"></a>
-      Running bjam
-    </h3>
+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
+<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="id372653"></a>Let's Jam!</h2>
+<p><span class="inlinemediaobject"><img src="../images/jam.png"></span></p>
 <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>
-      A file called user-config.jam in your home directory is used to configure your
-      tools. In Windows, your home directory can be found by typing:
-    </p>
-<pre class="programlisting">ECHO %HOMEDRIVE%%HOMEPATH%
-</pre>
-<p>
-      into a command prompt window. Your file should at least have the rules for
-      your compiler and your python installation. A specific example of this on Windows
-      would be:
-    </p>
-<pre class="programlisting">#  MSVC configuration
-using msvc : 8.0 ;
+Here is our minimalist Jamfile:</p>
+<pre class="programlisting"><tt class="literal"># This is the top of our own project tree
+project-root ;
 
-#  Python configuration
-using python : 2.4 : C:<span class="emphasis"><em>dev/tools/Python</em></span> ;
-</pre>
+import python ;
+
+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 first rule tells Bjam to use the MSVC 8.0 compiler and associated tools.
-      The second rule provides information on Python, its version and where it is
-      located. The above assumes that the Python installation is in <code class="literal">C:<span class="emphasis"><em>dev/tools\/Python</em></span></code>.
-      If you have one fairly "standard" python installation for your platform,
-      you might not need to do this.
-    </p>
+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>
-      Now we are ready... Be sure to <code class="literal">cd</code> to <code class="literal">libs/python/example/tutorial</code>
-      where the tutorial <code class="literal">"hello.cpp"</code> and the <code class="literal">"Jamroot"</code>
-      is situated.
-    </p>
+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>
-      Finally:
-    </p>
-<pre class="programlisting"><span class="identifier">bjam</span>
-</pre>
+Then we will import the definitions needed by Python modules:</p>
+<pre class="programlisting"><tt class="literal">import python ;
+</tt></pre>
 <p>
-      It should be building now:
-    </p>
-<pre class="programlisting">cd C:\dev\boost\libs\python\example\tutorial
-bjam
+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
+
+    # 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="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">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">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 these
+appropriately.</p>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<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">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 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 1101 targets...
-...updating 35 targets...
-</pre>
+...found 1703 targets...
+...updating 40 targets...
+</tt></pre>
 <p>
-      And so on... Finally:
-    </p>
-<pre class="programlisting">Creating library <span class="emphasis"><em>path-to-boost_python.dll</em></span>
-   Creating library /path-to-hello_ext.exp/
-**passed** ... hello.test
-...updated 35 targets...
-</pre>
+And so on... Finally:</p>
+<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>
-      Or something similar. If all is well, you should now have built the DLLs and
-      run the Python program.
-    </p>
-<div class="blockquote"><blockquote class="blockquote"><p>
-        <span class="bold"><strong>There you go... Have fun!</strong></span>
-      </p></blockquote></div>
+If all is well, you should now have:</p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+boost_python.dll
+</li>
+<li>
+hello.pyd
+</li>
+</ul></div>
+<p>
+if you are on Windows, and</p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+libboost_python.so
+</li>
+<li>
+hello.so
+</li>
+</ul></div>
+<p>
+if you are on Unix.</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>
+<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"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
-      de Guzman, David Abrahams<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
-        http://www.boost.org/LICENSE_1_0.txt </a>)
-      </p>
-</div></td>
+<td align="right"><small>Copyright © 2002-2005 Joel de Guzman, David Abrahams</small></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../index.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<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>
 </body>
 </html>

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

@@ -1,187 +1,133 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Iterators</title>
-<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
 <link rel="prev" href="embedding.html" title="Embedding">
-<link rel="next" href="exception.html" title="Exception Translation">
+<link rel="next" href="exception.html" title=" Exception Translation">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<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="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</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>
-</tr></table>
+</table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="embedding.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exception.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<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">
+<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>
 <p>
-      In C++, and STL in particular, we see iterators everywhere. Python also has
-      iterators, but these are two very different beasts.
-    </p>
-<p>
-      <span class="bold"><strong>C++ iterators:</strong></span>
-    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-          C++ has 5 type categories (random-access, bidirectional, forward, input,
-          output)
-        </li>
-<li class="listitem">
-          There are 2 Operation categories: reposition, access
-        </li>
-<li class="listitem">
-          A pair of iterators is needed to represent a (first/last) range.
-        </li>
+In C++, and STL in particular, we see iterators everywhere. Python also has
+iterators, but these are two very different beasts.</p>
+<p><span class="bold"><b>C++ iterators:</b></span></p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+C++ has 5 type categories (random-access, bidirectional, forward, input, output)
+</li>
+<li>
+There are 2 Operation categories: reposition, access
+</li>
+<li>
+A pair of iterators is needed to represent a (first/last) range.
+</li>
+</ul></div>
+<p><span class="bold"><b>Python Iterators:</b></span></p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+1 category (forward)
+</li>
+<li>
+1 operation category (next())
+</li>
+<li>
+Raises StopIteration exception at end
+</li>
 </ul></div>
 <p>
-      <span class="bold"><strong>Python Iterators:</strong></span>
-    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-          1 category (forward)
-        </li>
-<li class="listitem">
-          1 operation category (next())
-        </li>
-<li class="listitem">
-          Raises StopIteration exception at end
-        </li>
+The typical Python iteration protocol: <tt class="literal"><span class="bold"><b>for y in x...</b></span></tt> is as follows:</p>
+<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="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 <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>
+<p>
+Or for use in class_&lt;&gt;:</p>
+<pre class="programlisting"><tt class="literal"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"__iter__"</span><span class="special">,</span><span class="identifier"> iterator</span><span class="special">&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></tt></pre>
+<p><span class="bold"><b>range</b></span></p>
+<p>
+We can create a Python savvy iterator using the range function:</p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+range(start, finish)
+</li>
+<li>
+range&lt;Policies,Target&gt;(start, finish)
+</li>
 </ul></div>
 <p>
-      The typical Python iteration protocol: <code class="literal"><span class="bold"><strong>for y
-      in x...</strong></span></code> is as follows:
-    </p>
-<pre class="programlisting"><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="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>
-</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 <code class="computeroutput"><span class="identifier">__iter__</span></code> function from C++ iterators that
-      is compatible with the Python iteration protocol. For example:
-    </p>
-<pre class="programlisting"><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>
-</pre>
-<p>
-      Or for use in class_&lt;&gt;:
-    </p>
-<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"__iter__"</span><span class="special">,</span> <span class="identifier">iterator</span><span class="special">&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>
-</pre>
-<p>
-      <span class="bold"><strong>range</strong></span>
-    </p>
-<p>
-      We can create a Python savvy iterator using the range function:
-    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-          range(start, finish)
-        </li>
-<li class="listitem">
-          range&lt;Policies,Target&gt;(start, finish)
-        </li>
+Here, start/finish may be one of:</p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+member data pointers
+</li>
+<li>
+member function pointers
+</li>
+<li>
+adaptable function object (use Target parameter)
+</li>
 </ul></div>
+<p><span class="bold"><b>iterator</b></span></p>
+<div class="itemizedlist"><ul type="disc"><li>
+iterator&lt;T, Policies&gt;()
+</li></ul></div>
 <p>
-      Here, start/finish may be one of:
-    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-          member data pointers
-        </li>
-<li class="listitem">
-          member function pointers
-        </li>
-<li class="listitem">
-          adaptable function object (use Target parameter)
-        </li>
-</ul></div>
+Given a container <tt class="literal">T</tt>, iterator is a shortcut that simply calls <tt class="literal">range</tt>
+with &amp;T::begin, &amp;T::end.</p>
 <p>
-      <span class="bold"><strong>iterator</strong></span>
-    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
-          iterator&lt;T, Policies&gt;()
-        </li></ul></div>
+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="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="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>
-      Given a container <code class="literal">T</code>, iterator is a shortcut that simply
-      calls <code class="literal">range</code> 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>
-<pre class="programlisting"><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="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="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>
-</pre>
-<p>
-      Now, our C++ Wrapper:
-    </p>
-<pre class="programlisting"><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>
-</pre>
-<p>
-      <span class="bold"><strong>stl_input_iterator</strong></span>
-    </p>
-<p>
-      So far, we have seen how to expose C++ iterators and ranges to Python. Sometimes
-      we wish to go the other way, though: we'd like to pass a Python sequence to
-      an STL algorithm or use it to initialize an STL container. We need to make
-      a Python iterator look like an STL iterator. For that, we use <code class="computeroutput"><span class="identifier">stl_input_iterator</span><span class="special">&lt;&gt;</span></code>.
-      Consider how we might implement a function that exposes <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">assign</span><span class="special">()</span></code> to Python:
-    </p>
-<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">void</span> <span class="identifier">list_assign</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">l</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">o</span><span class="special">)</span> <span class="special">{</span>
-    <span class="comment">// Turn a Python sequence into an STL input range</span>
-    <span class="identifier">stl_input_iterator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">begin</span><span class="special">(</span><span class="identifier">o</span><span class="special">),</span> <span class="identifier">end</span><span class="special">;</span>
-    <span class="identifier">l</span><span class="special">.</span><span class="identifier">assign</span><span class="special">(</span><span class="identifier">begin</span><span class="special">,</span> <span class="identifier">end</span><span class="special">);</span>
-<span class="special">}</span>
-
-<span class="comment">// Part of the wrapper for list&lt;int&gt;</span>
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="string">"list_int"</span><span class="special">)</span>
-    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"assign"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">list_assign</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;)</span>
-    <span class="comment">// ...</span>
-    <span class="special">;</span>
-</pre>
-<p>
-      Now in Python, we can assign any integer sequence to <code class="computeroutput"><span class="identifier">list_int</span></code>
-      objects:
-    </p>
-<pre class="programlisting"><span class="identifier">x</span> <span class="special">=</span> <span class="identifier">list_int</span><span class="special">();</span>
-<span class="identifier">x</span><span class="special">.</span><span class="identifier">assign</span><span class="special">([</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">])</span>
-</pre>
+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"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
-      de Guzman, David Abrahams<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
-        http://www.boost.org/LICENSE_1_0.txt </a>)
-      </p>
-</div></td>
+<td align="right"><small>Copyright © 2002-2005 Joel de Guzman, David Abrahams</small></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="embedding.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exception.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<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>
 </body>
 </html>

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

@@ -1,360 +1,269 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Object Interface</title>
-<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<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.66.1">
+<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
 <link rel="prev" href="functions.html" title="Functions">
 <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%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<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="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</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>
-</tr></table>
+</table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<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">
+<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>
+<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>
 <dt><span class="section"><a href="object.html#python.extracting_c___objects">Extracting C++ objects</a></span></dt>
 <dt><span class="section"><a href="object.html#python.enums">Enums</a></span></dt>
-<dt><span class="section"><a href="object.html#python.creating_python_object">Creating <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">object</span></code> from <code class="computeroutput"><span class="identifier">PyObject</span><span class="special">*</span></code></a></span></dt>
 </dl></div>
 <p>
-      Python is dynamically typed, unlike C++ which is statically typed. Python variables
-      may hold an integer, a float, list, dict, tuple, str, long etc., among other
-      things. In the viewpoint of Boost.Python and C++, these Pythonic variables
-      are just instances of class <code class="literal">object</code>. We will see in this
-      chapter how to deal with Python objects.
-    </p>
+Python is dynamically typed, unlike C++ which is statically typed. Python
+variables may hold an integer, a float, list, dict, tuple, str, long etc.,
+among other things. In the viewpoint of Boost.Python and C++, these
+Pythonic variables are just instances of class <tt class="literal">object</tt>. We shall see in
+this chapter how to deal with Python objects.</p>
 <p>
-      As mentioned, one of the goals of Boost.Python is to provide a bidirectional
-      mapping between C++ and Python while maintaining the Python feel. Boost.Python
-      C++ <code class="literal">object</code>s are as close as possible to Python. This should
-      minimize the learning curve significantly.
-    </p>
-<p>
-      <span class="inlinemediaobject"><img src="../images/python.png" alt="python"></span>
-    </p>
-<div class="section">
+As mentioned, one of the goals of Boost.Python is to provide a
+bidirectional mapping between C++ and Python while maintaining the Python
+feel. Boost.Python C++ <tt class="literal">object</tt>s are as close as possible to Python. This
+should 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>
 <p>
-        Class <code class="literal">object</code> wraps <code class="literal">PyObject*</code>. All the
-        intricacies of dealing with <code class="literal">PyObject</code>s such as managing
-        reference counting are handled by the <code class="literal">object</code> class. C++
-        object interoperability is seamless. Boost.Python C++ <code class="literal">object</code>s
-        can in fact be explicitly constructed from any C++ object.
-      </p>
+Class <tt class="literal">object</tt> wraps <tt class="literal">PyObject*</tt>. All the intricacies of dealing with
+<tt class="literal">PyObject</tt>s such as managing reference counting are handled by the
+<tt class="literal">object</tt> class. C++ object interoperability is seamless. Boost.Python C++
+<tt class="literal">object</tt>s can in fact be explicitly constructed from any C++ object.</p>
 <p>
-        To illustrate, this Python code snippet:
-      </p>
-<pre class="programlisting"><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>
+To illustrate, this Python code snippet:</p>
+<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="keyword">
 
-<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>
-</pre>
+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>
-<pre class="programlisting"><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">else</span>
-         <span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"items"</span><span class="special">)</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="special">;</span>
-<span class="special">}</span>
-<span class="identifier">object</span> <span class="identifier">getfunc</span><span class="special">()</span> <span class="special">{</span>
-    <span class="keyword">return</span> <span class="identifier">object</span><span class="special">(</span><span class="identifier">f</span><span class="special">);</span>
-<span class="special">}</span>
-</pre>
+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">
+     else</span><span class="identifier">
+         x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"items"</span><span class="special">)</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="special">;</span><span class="special">
+}</span><span class="identifier">
+object</span><span class="identifier"> getfunc</span><span class="special">()</span><span class="special"> {</span><span class="keyword">
+    return</span><span class="identifier"> object</span><span class="special">(</span><span class="identifier">f</span><span class="special">);</span><span class="special">
+}</span></tt></pre>
 <p>
-        Apart from cosmetic differences due to the fact that we are writing the code
-        in C++, the look and feel should be immediately apparent to the Python coder.
-      </p>
+Apart from cosmetic differences due to the fact that we are writing the
+code in C++, the look and feel should be immediately apparent to the Python
+coder.</p>
 </div>
-<div class="section">
+<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>
 <p>
-        Boost.Python comes with a set of derived <code class="literal">object</code> types
-        corresponding to that of Python's:
-      </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-            list
-          </li>
-<li class="listitem">
-            dict
-          </li>
-<li class="listitem">
-            tuple
-          </li>
-<li class="listitem">
-            str
-          </li>
-<li class="listitem">
-            long_
-          </li>
-<li class="listitem">
-            enum
-          </li>
+Boost.Python comes with a set of derived <tt class="literal">object</tt> types corresponding to
+that of Python's:</p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+list
+</li>
+<li>
+dict
+</li>
+<li>
+tuple
+</li>
+<li>
+str
+</li>
+<li>
+long_
+</li>
+<li>
+enum
+</li>
 </ul></div>
 <p>
-        These derived <code class="literal">object</code> types act like real Python types.
-        For instance:
-      </p>
-<pre class="programlisting"><span class="identifier">str</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">==&gt;</span> <span class="string">"1"</span>
-</pre>
+These derived <tt class="literal">object</tt> types act like real Python types. For instance:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">str</span><span class="special">(</span><span class="number">1</span><span class="special">)</span><span class="special"> ==&gt;</span><span class="string"> "1"</span></tt></pre>
 <p>
-        Wherever appropriate, a particular derived <code class="literal">object</code> has
-        corresponding Python type's methods. For instance, <code class="literal">dict</code>
-        has a <code class="literal">keys()</code> method:
-      </p>
-<pre class="programlisting"><span class="identifier">d</span><span class="special">.</span><span class="identifier">keys</span><span class="special">()</span>
-</pre>
+Wherever appropriate, a particular derived <tt class="literal">object</tt> has corresponding
+Python type's methods. For instance, <tt class="literal">dict</tt> has a <tt class="literal">keys()</tt> method:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">d</span><span class="special">.</span><span class="identifier">keys</span><span class="special">()</span></tt></pre>
+<p><tt class="literal">make_tuple</tt> is provided for declaring <span class="emphasis"><em>tuple literals</em></span>. Example:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">make_tuple</span><span class="special">(</span><span class="number">123</span><span class="special">,</span><span class="char"> 'D'</span><span class="special">,</span><span class="string"> "Hello, World"</span><span class="special">,</span><span class="number"> 0.0</span><span class="special">);</span></tt></pre>
 <p>
-        <code class="literal">make_tuple</code> is provided for declaring <span class="emphasis"><em>tuple literals</em></span>.
-        Example:
-      </p>
-<pre class="programlisting"><span class="identifier">make_tuple</span><span class="special">(</span><span class="number">123</span><span class="special">,</span> <span class="char">'D'</span><span class="special">,</span> <span class="string">"Hello, World"</span><span class="special">,</span> <span class="number">0.0</span><span class="special">);</span>
-</pre>
+In C++, when Boost.Python <tt class="literal">object</tt>s are used as arguments to functions,
+subtype matching is required. For example, when a function <tt class="literal">f</tt>, as
+declared below, is wrapped, it will only accept instances of Python's
+<tt class="literal">str</tt> type and subtypes.</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">void</span><span class="identifier"> f</span><span class="special">(</span><span class="identifier">str</span><span class="identifier"> name</span><span class="special">)</span><span class="special">
+{</span><span class="identifier">
+    object</span><span class="identifier"> n2</span><span class="special"> =</span><span class="identifier"> name</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"upper"</span><span class="special">)();</span><span class="comment">   // NAME = name.upper()
+</span><span class="identifier">    str</span><span class="identifier"> NAME</span><span class="special"> =</span><span class="identifier"> name</span><span class="special">.</span><span class="identifier">upper</span><span class="special">();</span><span class="comment">            // better
+</span><span class="identifier">    object</span><span class="identifier"> msg</span><span class="special"> =</span><span class="string"> "%s is bigger than %s"</span><span class="special"> %</span><span class="identifier"> make_tuple</span><span class="special">(</span><span class="identifier">NAME</span><span class="special">,</span><span class="identifier">name</span><span class="special">);</span><span class="special">
+}</span></tt></pre>
 <p>
-        In C++, when Boost.Python <code class="literal">object</code>s are used as arguments
-        to functions, subtype matching is required. For example, when a function
-        <code class="literal">f</code>, as declared below, is wrapped, it will only accept
-        instances of Python's <code class="literal">str</code> type and subtypes.
-      </p>
-<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
-<span class="special">{</span>
-    <span class="identifier">object</span> <span class="identifier">n2</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"upper"</span><span class="special">)();</span>   <span class="comment">// NAME = name.upper()</span>
-    <span class="identifier">str</span> <span class="identifier">NAME</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">upper</span><span class="special">();</span>            <span class="comment">// better</span>
-    <span class="identifier">object</span> <span class="identifier">msg</span> <span class="special">=</span> <span class="string">"%s is bigger than %s"</span> <span class="special">%</span> <span class="identifier">make_tuple</span><span class="special">(</span><span class="identifier">NAME</span><span class="special">,</span><span class="identifier">name</span><span class="special">);</span>
-<span class="special">}</span>
-</pre>
+In finer detail:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">str</span><span class="identifier"> NAME</span><span class="special"> =</span><span class="identifier"> name</span><span class="special">.</span><span class="identifier">upper</span><span class="special">();</span></tt></pre>
 <p>
-        In finer detail:
-      </p>
-<pre class="programlisting"><span class="identifier">str</span> <span class="identifier">NAME</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">upper</span><span class="special">();</span>
-</pre>
+Illustrates that we provide versions of the str type's methods as C++
+member functions.</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">object</span><span class="identifier"> msg</span><span class="special"> =</span><span class="string"> "%s is bigger than %s"</span><span class="special"> %</span><span class="identifier"> make_tuple</span><span class="special">(</span><span class="identifier">NAME</span><span class="special">,</span><span class="identifier">name</span><span class="special">);</span></tt></pre>
 <p>
-        Illustrates that we provide versions of the str type's methods as C++ member
-        functions.
-      </p>
-<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">msg</span> <span class="special">=</span> <span class="string">"%s is bigger than %s"</span> <span class="special">%</span> <span class="identifier">make_tuple</span><span class="special">(</span><span class="identifier">NAME</span><span class="special">,</span><span class="identifier">name</span><span class="special">);</span>
-</pre>
+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>
+<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>
-        Demonstrates that you can write the C++ equivalent of <code class="literal">"format"
-        % x,y,z</code> in Python, which is useful since there's no easy way to
-        do that in std C++.
-      </p>
-<div class="sidebar">
-<div class="titlepage"></div>
+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>
-        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><strong>Beware</strong></span> the common pitfall
-        of forgetting that the constructors of most of Python's mutable types make
-        copies, just as in Python.
-      </p>
-</div>
+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="id454735"></a>class_&lt;T&gt; as objects</h2>
 <p>
-        Python:
-      </p>
-<pre class="programlisting"><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="special">=</span> <span class="number">3</span>        <span class="comment"># modifies the copy</span>
-</pre>
+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
+(type) object.</p>
 <p>
-        C++:
-      </p>
-<pre class="programlisting"><span class="identifier">dict</span> <span class="identifier">d</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>  <span class="comment">// copies x.__dict__</span>
-<span class="identifier">d</span><span class="special">[</span><span class="char">'whatever'</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>           <span class="comment">// modifies the copy</span>
-</pre>
-<h3>
-<a name="derived_object_types.class__lt_t_gt__as_objects"></a>
-        class_&lt;T&gt; as objects
-      </h3>
-<p>
-        Due to the dynamic nature of Boost.Python objects, any <code class="literal">class_&lt;T&gt;</code>
-        may also be one of these types! The following code snippet wraps the class
-        (type) object.
-      </p>
-<p>
-        We can use this to create wrapped instances. Example:
-      </p>
-<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">vec345</span> <span class="special">=</span> <span class="special">(</span>
-    <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&gt;(</span><span class="string">"Vec2"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;())</span>
-        <span class="special">.</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"length"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Point</span><span class="special">::</span><span class="identifier">length</span><span class="special">)</span>
-        <span class="special">.</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"angle"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Point</span><span class="special">::</span><span class="identifier">angle</span><span class="special">)</span>
-    <span class="special">)(</span><span class="number">3.0</span><span class="special">,</span> <span class="number">4.0</span><span class="special">);</span>
+We can use this to create wrapped instances. Example:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">object</span><span class="identifier"> vec345</span><span class="special"> =</span><span class="special"> (</span><span class="identifier">
+    class_</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&gt;(</span><span class="string">"Vec2"</span><span class="special">,</span><span class="identifier"> init</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span><span class="keyword"> double</span><span class="special">&gt;())</span><span class="special">
+        .</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"length"</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">Point</span><span class="special">::</span><span class="identifier">length</span><span class="special">)</span><span class="special">
+        .</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"angle"</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">Point</span><span class="special">::</span><span class="identifier">angle</span><span class="special">)</span><span class="special">
+    )(</span><span class="number">3.0</span><span class="special">,</span><span class="number"> 4.0</span><span class="special">);</span><span class="identifier">
 
-<span class="identifier">assert</span><span class="special">(</span><span class="identifier">vec345</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">)</span> <span class="special">==</span> <span class="number">5.0</span><span class="special">);</span>
-</pre>
+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">
+<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>
 <p>
-        At some point, we will need to get C++ values out of object instances. This
-        can be achieved with the <code class="literal">extract&lt;T&gt;</code> function. Consider
-        the following:
-      </p>
-<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">);</span> <span class="comment">// compile error</span>
-</pre>
+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>
+<pre class="programlisting"><tt class="literal"><span class="keyword">double</span><span class="identifier"> x</span><span class="special"> =</span><span class="identifier"> o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">);</span><span class="comment"> // compile error
+</span></tt></pre>
 <p>
-        In the code above, we got a compiler error because Boost.Python <code class="literal">object</code>
-        can't be implicitly converted to <code class="literal">double</code>s. Instead, what
-        we wanted to do above can be achieved by writing:
-      </p>
-<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">l</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;(</span><span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">));</span>
-<span class="identifier">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>
-</pre>
+In the code above, we got a compiler error because Boost.Python
+<tt class="literal">object</tt> can't be implicitly converted to <tt class="literal">double</tt>s. Instead, what
+we wanted to do above can be achieved by writing:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">double</span><span class="identifier"> l</span><span class="special"> =</span><span class="identifier"> extract</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;(</span><span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">));</span><span class="identifier">
+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 <code class="literal">object</code>. The second line attempts to <span class="emphasis"><em>extract</em></span>
-        the <code class="literal">Vec2</code> object from held by the Boost.Python <code class="literal">object</code>.
-      </p>
+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
-        <code class="literal">object</code> does not really hold a <code class="literal">Vec2</code>
-        type? This is certainly a possibility considering the dynamic nature of Python
-        <code class="literal">object</code>s. To be on the safe side, if the C++ type can't
-        be extracted, an appropriate exception is thrown. To avoid an exception,
-        we need to test for extractibility:
-      </p>
-<pre class="programlisting"><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>
-</pre>
-<p>
-        <span class="inlinemediaobject"><img src="../images/tip.png" alt="tip"></span> The astute reader might have noticed that the <code class="literal">extract&lt;T&gt;</code>
-        facility in fact solves the mutable copying problem:
-      </p>
-<pre class="programlisting"><span class="identifier">dict</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">dict</span><span class="special">&gt;(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>
-<span class="identifier">d</span><span class="special">[</span><span class="string">"whatever"</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>          <span class="comment">// modifies x.__dict__ !</span>
-</pre>
+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>
+<p><span class="inlinemediaobject"><img src="../images/tip.png"></span> The astute reader might have noticed that the <tt class="literal">extract&lt;T&gt;</tt>
+facility in fact solves the mutable copying problem:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">dict</span><span class="identifier"> d</span><span class="special"> =</span><span class="identifier"> extract</span><span class="special">&lt;</span><span class="identifier">dict</span><span class="special">&gt;(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span><span class="identifier">
+d</span><span class="special">[</span><span class="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">
+<div class="section" lang="en">
 <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 <code class="literal">enum</code> type, we'll often want to expose our C++ enums
-        to Python as an <code class="literal">int</code>. Boost.Python's enum facility makes
-        this easy while taking care of the proper conversions from Python's dynamic
-        typing to C++'s strong static typing (in C++, ints cannot be implicitly converted
-        to enums). To illustrate, given a C++ enum:
-      </p>
-<pre class="programlisting"><span class="keyword">enum</span> <span class="identifier">choice</span> <span class="special">{</span> <span class="identifier">red</span><span class="special">,</span> <span class="identifier">blue</span> <span class="special">};</span>
-</pre>
+Boost.Python has a nifty facility to capture and wrap C++ enums. While
+Python has no <tt class="literal">enum</tt> type, we'll often want to expose our C++ enums to
+Python as an <tt class="literal">int</tt>. Boost.Python's enum facility makes this easy while
+taking care of the proper conversions from Python's dynamic typing to C++'s
+strong static typing (in C++, ints cannot be implicitly converted to
+enums). To illustrate, given a C++ enum:</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">enum</span><span class="identifier"> choice</span><span class="special"> {</span><span class="identifier"> red</span><span class="special">,</span><span class="identifier"> blue</span><span class="special"> };</span></tt></pre>
 <p>
-        the construct:
-      </p>
-<pre class="programlisting"><span class="identifier">enum_</span><span class="special">&lt;</span><span class="identifier">choice</span><span class="special">&gt;(</span><span class="string">"choice"</span><span class="special">)</span>
-    <span class="special">.</span><span class="identifier">value</span><span class="special">(</span><span class="string">"red"</span><span class="special">,</span> <span class="identifier">red</span><span class="special">)</span>
-    <span class="special">.</span><span class="identifier">value</span><span class="special">(</span><span class="string">"blue"</span><span class="special">,</span> <span class="identifier">blue</span><span class="special">)</span>
-    <span class="special">;</span>
-</pre>
+the construct:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">enum_</span><span class="special">&lt;</span><span class="identifier">choice</span><span class="special">&gt;(</span><span class="string">"choice"</span><span class="special">)</span><span class="special">
+    .</span><span class="identifier">value</span><span class="special">(</span><span class="string">"red"</span><span class="special">,</span><span class="identifier"> red</span><span class="special">)</span><span class="special">
+    .</span><span class="identifier">value</span><span class="special">(</span><span class="string">"blue"</span><span class="special">,</span><span class="identifier"> blue</span><span class="special">)</span><span class="special">
+    ;</span></tt></pre>
 <p>
-        can be used to expose to Python. The new enum type is created in the current
-        <code class="literal">scope()</code>, which is usually the current module. The snippet
-        above creates a Python class derived from Python's <code class="literal">int</code>
-        type which is associated with the C++ type passed as its first parameter.
-      </p>
-<div class="note"><table border="0" summary="Note">
-<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
-<th align="left">Note</th>
-</tr>
-<tr><td align="left" valign="top">
-<p>
-          <span class="bold"><strong>what is a scope?</strong></span>
-        </p>
-<p>
-          The scope is a class that has an associated global Python object which
-          controls the Python namespace in which new extension classes and wrapped
-          functions will be defined as attributes. Details can be found <a href="../../../../v2/scope.html" target="_top">here</a>.
-        </p>
-</td></tr>
+can be used to expose to Python. The new enum type is created in the
+current <tt class="literal">scope()</tt>, which is usually the current module. The snippet above
+creates a Python class derived from Python's <tt class="literal">int</tt> type which is
+associated with the C++ type passed as its first parameter.</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>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
+attributes. Details can be found <a href="../../../../v2/scope.html" target="_top">here</a>.</td></tr></tbody>
 </table></div>
 <p>
-        You can access those values in Python as
-      </p>
-<pre class="programlisting"><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>
-</pre>
+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>
-<pre class="programlisting"><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">;</span>
+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">
+            ;</span><span class="comment">
 
-<span class="comment">// Expose X::nested as X.nested</span>
-<span class="identifier">enum_</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">nested</span><span class="special">&gt;(</span><span class="string">"nested"</span><span class="special">)</span>
-    <span class="special">.</span><span class="identifier">value</span><span class="special">(</span><span class="string">"red"</span><span class="special">,</span> <span class="identifier">red</span><span class="special">)</span>
-    <span class="special">.</span><span class="identifier">value</span><span class="special">(</span><span class="string">"blue"</span><span class="special">,</span> <span class="identifier">blue</span><span class="special">)</span>
-    <span class="special">;</span>
-</pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="python.creating_python_object"></a>Creating <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">object</span></code> from <code class="computeroutput"><span class="identifier">PyObject</span><span class="special">*</span></code>
-</h3></div></div></div>
-<p>
-        When you want a <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">object</span></code> to manage a pointer to <code class="computeroutput"><span class="identifier">PyObject</span><span class="special">*</span></code>
-        pyobj one does:
-      </p>
-<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">object</span> <span class="identifier">o</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">handle</span><span class="special">&lt;&gt;(</span><span class="identifier">pyobj</span><span class="special">));</span>
-</pre>
-<p>
-        In this case, the <code class="computeroutput"><span class="identifier">o</span></code> object,
-        manages the <code class="computeroutput"><span class="identifier">pyobj</span></code>, it won&#8217;t
-        increase the reference count on construction.
-      </p>
-<p>
-        Otherwise, to use a borrowed reference:
-      </p>
-<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">object</span> <span class="identifier">o</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">handle</span><span class="special">&lt;&gt;(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">borrowed</span><span class="special">(</span><span class="identifier">pyobj</span><span class="special">)));</span>
-</pre>
-<p>
-        In this case, <code class="computeroutput"><span class="identifier">Py_INCREF</span></code> is
-        called, so <code class="computeroutput"><span class="identifier">pyobj</span></code> is not destructed
-        when object o goes out of scope.
-      </p>
+// Expose X::nested as X.nested
+</span><span class="identifier">enum_</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">nested</span><span class="special">&gt;(</span><span class="string">"nested"</span><span class="special">)</span><span class="special">
+    .</span><span class="identifier">value</span><span class="special">(</span><span class="string">"red"</span><span class="special">,</span><span class="identifier"> red</span><span class="special">)</span><span class="special">
+    .</span><span class="identifier">value</span><span class="special">(</span><span class="string">"blue"</span><span class="special">,</span><span class="identifier"> blue</span><span class="special">)</span><span class="special">
+    ;</span></tt></pre>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
-      de Guzman, David Abrahams<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
-        http://www.boost.org/LICENSE_1_0.txt </a>)
-      </p>
-</div></td>
+<td align="right"><small>Copyright © 2002-2005 Joel de Guzman, David Abrahams</small></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<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>
 </body>
 </html>

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

@@ -1,440 +1,366 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>General Techniques</title>
-<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="prev" href="exception.html" title="Exception Translation">
+<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.66.1">
+<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="prev" href="exception.html" title=" Exception Translation">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<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="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</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>
-</tr></table>
+</table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="exception.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a>
+<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">
+<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>
+<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>
 <dt><span class="section"><a href="techniques.html#python.reducing_compiling_time">Reducing Compiling Time</a></span></dt>
 </dl></div>
 <p>
-      Here are presented some useful techniques that you can use while wrapping code
-      with Boost.Python.
-    </p>
-<div class="section">
+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>
 <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 introduction
-        to them is provided in the <a href="http://www.python.org/doc/current/tut/node8.html" target="_top">Python
-        Tutorial</a>.
-      </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
+introduction to them is provided in the
+<a href="http://www.python.org/doc/current/tut/node8.html" target="_top">Python Tutorial</a>.</p>
 <p>
-        But we are wrapping C++ code, using Boost.Python. How can we provide a nice
-        package interface to our users? To better explain some concepts, let's work
-        with an example.
-      </p>
+But we are wrapping C++ code, using Boost.Python. How can we provide a nice
+package interface to our users? To better explain some concepts, let's work
+with an example.</p>
 <p>
-        We have a C++ library that works with sounds: reading and writing various
-        formats, applying filters to the sound data, etc. It is named (conveniently)
-        <code class="literal">sounds</code>. Our library already has a neat C++ namespace hierarchy,
-        like so:
-      </p>
-<pre class="programlisting"><span class="identifier">sounds</span><span class="special">::</span><span class="identifier">core</span>
-<span class="identifier">sounds</span><span class="special">::</span><span class="identifier">io</span>
-<span class="identifier">sounds</span><span class="special">::</span><span class="identifier">filters</span>
-</pre>
+We have a C++ library that works with sounds: reading and writing various
+formats, applying filters to the sound data, etc. It is named (conveniently)
+<tt class="literal">sounds</tt>.  Our library already has a neat C++ namespace hierarchy, like so:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">sounds</span><span class="special">::</span><span class="identifier">core</span><span class="identifier">
+sounds</span><span class="special">::</span><span class="identifier">io</span><span class="identifier">
+sounds</span><span class="special">::</span><span class="identifier">filters</span></tt></pre>
 <p>
-        We would like to present this same hierarchy to the Python user, allowing
-        him to write code like this:
-      </p>
-<pre class="programlisting"><span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</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="comment"># echo is a C++ function</span>
-</pre>
+We would like to present this same hierarchy to the Python user, allowing him
+to write code like this:</p>
+<pre class="programlisting"><tt class="literal"><span class="identifier">import</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">filters</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"> echo</span><span class="identifier"> is</span><span class="identifier"> a</span><span class="identifier"> C</span><span class="special">++</span><span class="identifier"> function</span></tt></pre>
 <p>
-        The first step is to write the wrapping code. We have to export each module
-        separately with Boost.Python, like this:
-      </p>
-<pre class="programlisting"><span class="special">/*</span> <span class="identifier">file</span> <span class="identifier">core</span><span class="special">.</span><span class="identifier">cpp</span> <span class="special">*/</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">/*</span> <span class="identifier">export</span> <span class="identifier">everything</span> <span class="keyword">in</span> <span class="identifier">the</span> <span class="identifier">sounds</span><span class="special">::</span><span class="identifier">core</span> <span class="identifier">namespace</span> <span class="special">*/</span>
-    <span class="special">...</span>
-<span class="special">}</span>
+The first step is to write the wrapping code. We have to export each module
+separately with Boost.Python, like this:</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="comment">
+    /* export everything in the sounds::core namespace */</span><span class="special">
+    ...</span><span class="special">
+}</span><span class="comment">
 
-<span class="special">/*</span> <span class="identifier">file</span> <span class="identifier">io</span><span class="special">.</span><span class="identifier">cpp</span> <span class="special">*/</span>
-<span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">io</span><span class="special">)</span>
-<span class="special">{</span>
-    <span class="special">/*</span> <span class="identifier">export</span> <span class="identifier">everything</span> <span class="keyword">in</span> <span class="identifier">the</span> <span class="identifier">sounds</span><span class="special">::</span><span class="identifier">io</span> <span class="identifier">namespace</span> <span class="special">*/</span>
-    <span class="special">...</span>
-<span class="special">}</span>
+/* file io.cpp */</span><span class="identifier">
+BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">io</span><span class="special">)</span><span class="special">
+{</span><span class="comment">
+    /* export everything in the sounds::io namespace */</span><span class="special">
+    ...</span><span class="special">
+}</span><span class="comment">
 
-<span class="special">/*</span> <span class="identifier">file</span> <span class="identifier">filters</span><span class="special">.</span><span class="identifier">cpp</span> <span class="special">*/</span>
-<span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">filters</span><span class="special">)</span>
-<span class="special">{</span>
-    <span class="special">/*</span> <span class="identifier">export</span> <span class="identifier">everything</span> <span class="keyword">in</span> <span class="identifier">the</span> <span class="identifier">sounds</span><span class="special">::</span><span class="identifier">filters</span> <span class="identifier">namespace</span> <span class="special">*/</span>
-    <span class="special">...</span>
-<span class="special">}</span>
-</pre>
+/* file filters.cpp */</span><span class="identifier">
+BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">filters</span><span class="special">)</span><span class="special">
+{</span><span class="comment">
+    /* export everything in the sounds::filters namespace */</span><span class="special">
+    ...</span><span class="special">
+}</span></tt></pre>
 <p>
-        Compiling these files will generate the following Python extensions: <code class="literal">core.pyd</code>,
-        <code class="literal">io.pyd</code> and <code class="literal">filters.pyd</code>.
-      </p>
-<div class="note"><table border="0" summary="Note">
-<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
-<th align="left">Note</th>
-</tr>
-<tr><td align="left" valign="top"><p>
-          The extension <code class="literal">.pyd</code> is used for python extension modules,
-          which are just shared libraries. Using the default for your system, like
-          <code class="literal">.so</code> for Unix and <code class="literal">.dll</code> for Windows,
-          works just as well.
-        </p></td></tr>
+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 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">sounds/
+Now, we create this directory structure for our Python package:</p>
+<pre class="programlisting"><tt class="literal">sounds/
     __init__.py
     core.pyd
     filters.pyd
     io.pyd
-</pre>
+</tt></pre>
 <p>
-        The file <code class="literal">__init__.py</code> is what tells Python that the directory
-        <code class="literal">sounds/</code> is actually a Python package. It can be a empty
-        file, but can also perform some magic, that will be shown later.
-      </p>
+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 <code class="literal">sounds</code>
-        into his <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"><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>
-</pre>
+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>
+and fire up the interpreter:</p>
+<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>
+Nice heh?</p>
 <p>
-        This is the simplest way to create hierarchies of packages, but it is not
-        very flexible. What if we want to add a <span class="emphasis"><em>pure</em></span> Python
-        function to the filters package, for instance, one that applies 3 filters
-        in a sound object at once? Sure, you can do this in C++ and export it, but
-        why not do so in Python? You don't have to recompile the extension modules,
-        plus it will be easier to write it.
-      </p>
+This is the simplest way to create hierarchies of packages, but it is not very
+flexible. What if we want to add a <span class="emphasis"><em>pure</em></span> Python function to the filters
+package, for instance, one that applies 3 filters in a sound object at once?
+Sure, you can do this in C++ and export it, but why not do so in Python? You
+don't have to recompile the extension modules, plus it will be easier to write
+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>
-<pre class="programlisting"><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">...</span>
-    <span class="comment">/* export everything in the sounds::core namespace */</span>
-<span class="special">}</span>
-</pre>
+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">
+    ...</span><span class="comment">
+    /* export everything in the sounds::core namespace */</span><span class="special">
+}</span></tt></pre>
 <p>
-        Note that we added an underscore to the module name. The filename will have
-        to be changed to <code class="literal">_core.pyd</code> as well, and we do the same
-        to the other extension modules. Now, we change our package hierarchy like
-        so:
-      </p>
-<pre class="programlisting">sounds/
+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/
     __init__.py
     core/
         __init__.py
-        <span class="underline">core.pyd
+        _core.pyd
     filters/
-        \</span>_init__.py
-        <span class="underline">filters.pyd
+        __init__.py
+        _filters.pyd
     io/
-        \</span>_init__.py
+        __init__.py
         _io.pyd
-</pre>
+</tt></pre>
 <p>
-        Note that we created a directory for each extension module, and added a __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"><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>
-</pre>
+Note that we created a directory for each extension module, and added a
+__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>
+<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 <code class="literal">__init__.py</code>
-        magic: everything that is brought to the <code class="literal">__init__.py</code> namespace
-        can be accessed directly by the user. So, all we have to do is bring the
-        entire namespace from <code class="literal">_core.pyd</code> to <code class="literal">core/__init__.py</code>.
-        So add this line of code to <code class="literal">sounds/core/__init__.py</code>:
-      </p>
-<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">_core</span> <span class="keyword">import</span> <span class="special">*</span>
-</pre>
+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/__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"><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>
-</pre>
+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="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 any module, in a way that the user can't tell the difference between a
-        C++ function and a Python function. Let's add a <span class="emphasis"><em>pure</em></span>
-        Python function, <code class="literal">echo_noise</code>, to the <code class="literal">filters</code>
-        package. This function applies both the <code class="literal">echo</code> and <code class="literal">noise</code>
-        filters in sequence in the given <code class="literal">sound</code> object. We create
-        a file named <code class="literal">sounds/filters/echo_noise.py</code> and code our
-        function:
-      </p>
-<pre class="programlisting"><span class="keyword">import</span> <span class="identifier">_filters</span>
-<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>
-</pre>
+with the additional benefit that we can easily add pure Python functions to
+any module, in a way that the user can't tell the difference between a C++
+function and a Python function. Let's add a <span class="emphasis"><em>pure</em></span> Python function,
+<tt class="literal">echo_noise</tt>, to the <tt class="literal">filters</tt> package. This function applies both the
+<tt class="literal">echo</tt> and <tt class="literal">noise</tt> filters in sequence in the given <tt class="literal">sound</tt> object. We
+create a file named <tt class="literal">sounds/filters/echo_noise.py</tt> and code our function:</p>
+<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 <code class="literal">sounds/filters/__init__.py</code>:
-      </p>
-<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">echo_noise</span> <span class="keyword">import</span> <span class="identifier">echo_noise</span>
-</pre>
+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 <code class="literal">filters</code> package:
-      </p>
-<pre class="programlisting"><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>
-</pre>
+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="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">
+<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>
 <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"><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="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="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="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>
-</pre>
+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="keyword"> pass</span><span class="special">
+&gt;&gt;&gt;</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="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="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>
 <p>
-        Yes, Python rox. <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span>
-      </p>
+Yes, Python rox. <span class="inlinemediaobject"><img src="../images/smiley.png"></span></p>
 <p>
-        We can do the same with classes that were wrapped with Boost.Python. Suppose
-        we have a class <code class="literal">point</code> in C++:
-      </p>
-<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">point</span> <span class="special">{...};</span>
+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">
 
-<span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_geom</span><span class="special">)</span>
-<span class="special">{</span>
-    <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">point</span><span class="special">&gt;(</span><span class="string">"point"</span><span class="special">)...;</span>
-<span class="special">}</span>
-</pre>
+BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_geom</span><span class="special">)</span><span class="special">
+{</span><span class="identifier">
+    class_</span><span class="special">&lt;</span><span class="identifier">point</span><span class="special">&gt;(</span><span class="string">"point"</span><span class="special">)...;</span><span class="special">
+}</span></tt></pre>
 <p>
-        If we are using the technique from the previous session, <a class="link" href="techniques.html#python.creating_packages" title="Creating Packages">Creating
-        Packages</a>, we can code directly into <code class="literal">geom/__init__.py</code>:
-      </p>
-<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">_geom</span> <span class="keyword">import</span> <span class="special">*</span>
+If we are using the technique from the previous session,
+<a href="techniques.html#python.creating_packages" title="Creating Packages">Creating Packages</a>, we can code directly
+into <tt class="literal">geom/__init__.py</tt>:</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="comment"># 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>
+# 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="comment"># 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>
-</pre>
-<p>
-        <span class="bold"><strong>All</strong></span> point instances created from C++ will
-        also have this member function! This technique has several advantages:
-      </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-            Cut down compile times to zero for these additional functions
-          </li>
-<li class="listitem">
-            Reduce the memory footprint to virtually zero
-          </li>
-<li class="listitem">
-            Minimize the need to recompile
-          </li>
-<li class="listitem">
-            Rapid prototyping (you can move the code to C++ if required without changing
-            the interface)
-          </li>
+# 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">
+<li>
+Cut down compile times to zero for these additional functions
+</li>
+<li>
+Reduce the memory footprint to virtually zero
+</li>
+<li>
+Minimize the need to recompile
+</li>
+<li>
+Rapid prototyping (you can move the code to C++ if required without changing the interface)
+</li>
 </ul></div>
 <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"><span class="comment"># The one Boost.Python uses for all wrapped classes.</span>
-<span class="comment"># 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>
+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="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">
 
-<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="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="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>
+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="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="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><span class="comment">
 
-<span class="comment"># 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="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>
-</pre>
+# 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="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"><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>
-</pre>
+Now let's see how it got:</p>
+<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"><span class="identifier">_point</span> <span class="special">=</span> <span class="identifier">point</span>
+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="keyword">
 
-<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>
-</pre>
+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>
 <p>
-        In this simple case there is not much gained, but for constructurs with many
-        overloads and/or arguments this is often a great simplification, again with
-        virtually zero memory footprint and zero compile-time overhead for the keyword
-        support.
-      </p>
+In this simple case there is not much gained, but for constructurs with
+many overloads and/or arguments this is often a great simplification, again
+with virtually zero memory footprint and zero compile-time overhead for
+the keyword support.</p>
 </div>
-<div class="section">
+<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>
 <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>
-<pre class="programlisting"><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>
+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">
 
-<span class="keyword">void</span> <span class="identifier">export_point</span><span class="special">()</span>
-<span class="special">{</span>
-    <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">point</span><span class="special">&gt;(</span><span class="string">"point"</span><span class="special">)...;</span>
-<span class="special">}</span>
+void</span><span class="identifier"> export_point</span><span class="special">()</span><span class="special">
+{</span><span class="identifier">
+    class_</span><span class="special">&lt;</span><span class="identifier">point</span><span class="special">&gt;(</span><span class="string">"point"</span><span class="special">)...;</span><span class="special">
+}</span><span class="comment">
 
-<span class="comment">/* file triangle.cpp */</span>
-<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">triangle</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>
+/* file triangle.cpp */</span><span class="preprocessor">
+#include</span><span class="special"> &lt;</span><span class="identifier">triangle</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">
 
-<span class="keyword">void</span> <span class="identifier">export_triangle</span><span class="special">()</span>
-<span class="special">{</span>
-    <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">triangle</span><span class="special">&gt;(</span><span class="string">"triangle"</span><span class="special">)...;</span>
-<span class="special">}</span>
-</pre>
+void</span><span class="identifier"> export_triangle</span><span class="special">()</span><span class="special">
+{</span><span class="identifier">
+    class_</span><span class="special">&lt;</span><span class="identifier">triangle</span><span class="special">&gt;(</span><span class="string">"triangle"</span><span class="special">)...;</span><span class="special">
+}</span></tt></pre>
 <p>
-        Now you create a file <code class="literal">main.cpp</code>, which contains the <code class="literal">BOOST_PYTHON_MODULE</code>
-        macro, and call the various export functions inside it.
-      </p>
-<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">export_point</span><span class="special">();</span>
-<span class="keyword">void</span> <span class="identifier">export_triangle</span><span class="special">();</span>
+Now you create a file <tt class="literal">main.cpp</tt>, which contains the <tt class="literal">BOOST_PYTHON_MODULE</tt>
+macro, and call the various export functions inside it.</p>
+<pre class="programlisting"><tt class="literal"><span class="keyword">void</span><span class="identifier"> export_point</span><span class="special">();</span><span class="keyword">
+void</span><span class="identifier"> export_triangle</span><span class="special">();</span><span class="identifier">
 
-<span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_geom</span><span class="special">)</span>
-<span class="special">{</span>
-    <span class="identifier">export_point</span><span class="special">();</span>
-    <span class="identifier">export_triangle</span><span class="special">();</span>
-<span class="special">}</span>
-</pre>
+BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_geom</span><span class="special">)</span><span class="special">
+{</span><span class="identifier">
+    export_point</span><span class="special">();</span><span class="identifier">
+    export_triangle</span><span class="special">();</span><span class="special">
+}</span></tt></pre>
 <p>
-        Compiling and linking together all this files produces the same result as
-        the usual approach:
-      </p>
-<pre class="programlisting"><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="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">triangle</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>
+Compiling and linking together all this files produces the same result as the
+usual approach:</p>
+<pre class="programlisting"><tt class="literal"><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="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">triangle</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span><span class="identifier">
 
-<span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_geom</span><span class="special">)</span>
-<span class="special">{</span>
-    <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">point</span><span class="special">&gt;(</span><span class="string">"point"</span><span class="special">)...;</span>
-    <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">triangle</span><span class="special">&gt;(</span><span class="string">"triangle"</span><span class="special">)...;</span>
-<span class="special">}</span>
-</pre>
+BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_geom</span><span class="special">)</span><span class="special">
+{</span><span class="identifier">
+    class_</span><span class="special">&lt;</span><span class="identifier">point</span><span class="special">&gt;(</span><span class="string">"point"</span><span class="special">)...;</span><span class="identifier">
+    class_</span><span class="special">&lt;</span><span class="identifier">triangle</span><span class="special">&gt;(</span><span class="string">"triangle"</span><span class="special">)...;</span><span class="special">
+}</span></tt></pre>
 <p>
-        but the memory is kept under control.
-      </p>
+but the memory is kept under control.</p>
 <p>
-        This method is recommended too if you are developing the C++ library and
-        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="note"><table border="0" summary="Note">
-<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
-<th align="left">Note</th>
-</tr>
-<tr><td align="left" valign="top"><p>
-          If you're exporting your classes with <a href="../../../../../pyste/index.html" target="_top">Pyste</a>,
-          take a look at the <code class="literal">--multiple</code> option, that generates
-          the wrappers in various files as demonstrated here.
-        </p></td></tr>
+This method is recommended too if you are developing the C++ library and
+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 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="note"><table border="0" summary="Note">
-<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
-<th align="left">Note</th>
-</tr>
-<tr><td align="left" valign="top"><p>
-          This method is useful too if you are getting the error message <span class="emphasis"><em>"fatal
-          error C1204:Compiler limit:internal structure overflow"</em></span>
-          when compiling a large source file, as explained in the <a href="../../../../v2/faq.html#c1204" target="_top">FAQ</a>.
-        </p></td></tr>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<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>
 </table></div>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
-      de Guzman, David Abrahams<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
-        http://www.boost.org/LICENSE_1_0.txt </a>)
-      </p>
-</div></td>
+<td align="right"><small>Copyright © 2002-2005 Joel de Guzman, David Abrahams</small></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="exception.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a>
+<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>
 </body>
 </html>

doc/tutorial/doc/tutorial.qbk

@@ -1,5 +1,5 @@
 [library python
-    [version 2.0]
+    [version 1.0]
     [authors [de Guzman, Joel], [Abrahams, David]]
     [copyright 2002 2003 2004 2005 Joel de Guzman, David Abrahams]
     [category inter-language support]
@@ -49,10 +49,10 @@ Function:
 can be exposed to Python by writing a Boost.Python wrapper:
 
     #include <boost/python.hpp>
+    using namespace boost::python;
 
-    BOOST_PYTHON_MODULE(hello_ext)
+    BOOST_PYTHON_MODULE(hello)
     {
-        using namespace boost::python;
         def("greet", greet);
     }
 
@@ -61,8 +61,8 @@ resulting DLL is now visible to Python. Here's a sample Python session:
 
 [python]
 
-    >>> import hello_ext
-    >>> print hello_ext.greet()
+    >>> import hello
+    >>> print hello.greet()
     hello, world
 
 [c++]
@@ -75,39 +75,43 @@ resulting DLL is now visible to Python. Here's a sample Python session:
 [h2 From Start To Finish]
 
 Now the first thing you'd want to do is to build the Hello World module and
-try it for yourself in Python. In this section, we will outline the steps
-necessary to achieve that. We will use the build tool that comes bundled
+try it for yourself in Python. In this section, we shall outline the steps
+necessary to achieve that. We shall use the build tool that comes bundled
 with every boost distribution: [*bjam].
 
-[note [*Building without bjam]
-
-Besides bjam, there are of course other ways to get your module built.
-What's written here should not be taken as "the one and only way".
-There are of course other build tools apart from [^bjam].
-
-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
-that 90% of the "I can't build Boost.Python" problems come from people
-who had to use a different tool.
+[blurb __note__ [*Building without bjam]\n\n
+    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 [^bjam].\n\n
+    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
+    that 90% of the "I can't build Boost.Python" problems come from people
+    who had to use a different tool.
 ]
 
-We will skip over the details. Our objective will be to simply create
-the hello world module and run it in Python. For a complete reference to
-building Boost.Python, check out: [@../../../building.html
-building.html]. After this brief ['bjam] tutorial, we should have built
-the DLLs and run a python program using the extension.
+We shall skip over the details. Our objective will be to simply create the
+hello world module and run it in Python. For a complete reference to
+building Boost.Python, check out: [@../../../building.html building.html].
+After this brief ['bjam] tutorial, we should have built two DLLs:
+
+* boost_python.dll
+* hello.pyd
+
+if you are on Windows, and
+
+* libboost_python.so
+* hello.so
+
+if you are on Unix.
 
 The tutorial example can be found in the directory:
 [^libs/python/example/tutorial]. There, you can find:
 
 * hello.cpp
-* hello.py
-* Jamroot
+* Jamfile
 
-The [^hello.cpp] file is our C++ hello world example. The [^Jamroot] is
-a minimalist ['bjam] script that builds the DLLs for us. Finally,
-[^hello.py] is our Python program that uses the extension in
-[^hello.cpp].
+The [^hello.cpp] file is our C++ hello world example. The [^Jamfile] is a
+minimalist ['bjam] script that builds the DLLs for us.
 
 Before anything else, you should have the bjam executable in your boost
 directory or somewhere in your path such that [^bjam] can be executed in
@@ -118,12 +122,51 @@ platforms. The complete list of Bjam executables can be found
 [h2 Let's Jam!]
 __jam__
 
-[@../../../../example/tutorial/Jamroot Here] is our minimalist Jamroot
-file. Simply copy the file and tweak [^use-project boost] to where your
-boost root directory is and your OK.
+Here is our minimalist Jamfile:
 
-The comments contained in the Jamrules file above should be sufficient
-to get you going.
+[pre
+# This is the top of our own project tree
+project-root ;
+
+import python ;
+
+extension hello                     # Declare a Python extension called hello
+:   hello.cpp                       # source
+    # requirements and dependencies for Boost.Python extensions
+    <template>@boost/libs/python/build/extension
+    ;
+]
+
+First, we need to specify our location. You may place your project anywhere.
+[^project-root] allows you to do that.
+
+[pre
+project-root ;
+]
+
+By doing so, you'll need a Jamrules file. Simply copy the one in the 
+[@../../../../example/tutorial/Jamrules example/tutorial directory] and tweak 
+the [^path-global BOOST_ROOT] to where your boost root directory is. The file
+has [@../../../../example/tutorial/Jamrules detailed instructions] you can follow.
+
+Then we will import the definitions needed by Python modules:
+
+[pre
+import python ;
+]
+
+Finally we declare our [^hello] extension:
+
+[pre
+extension hello                     # Declare a Python extension called hello
+:   hello.cpp                       # source
+
+    # requirements and dependencies for Boost.Python extensions
+    <template>@boost/libs/python/build/extension
+    ;
+]
+
+The last part tells BJam that we are depending on the Boost Python Library.
 
 [h2 Running bjam]
 
@@ -131,60 +174,97 @@ to get you going.
 
 [:Start it up.]
 
-A file called user-config.jam in your home directory is used to
-configure your tools. In Windows, your home directory can be found by
-typing:
+Make sure that the environment is set so that we can invoke the C++
+compiler. With MSVC, that would mean running the [^Vcvars32.bat] batch
+file. For instance:
 
 [pre
-ECHO %HOMEDRIVE%%HOMEPATH%
+C:\Program Files\Microsoft Visual Studio .NET 2003\Common7\Tools\vsvars32.bat
 ]
 
-into a command prompt window. Your file should at least have the rules
-for your compiler and your python installation. A specific example of
-this on Windows would be:
+Some environment variables will have to be setup for proper building of our
+Python modules. Example:
 
 [pre
-#  MSVC configuration
-using msvc : 8.0 ;
-
-#  Python configuration
-using python : 2.4 : C:/dev/tools/Python/ ;
+set PYTHON_ROOT=c:/dev/tools/python
+set PYTHON_VERSION=2.2
 ]
 
-The first rule tells Bjam to use the MSVC 8.0 compiler and associated
-tools. The second rule provides information on Python, its version and
-where it is located. The above assumes that the Python installation is
-in [^C:/dev/tools\/Python/]. If you have one fairly "standard" python
-installation for your platform, you might not need to do this.
+The above assumes that the Python installation is in [^c:/dev/tools/python]
+and that we are using Python version 2.2. You'll have to tweak these
+appropriately.
+
+[blurb __tip__ Be sure not to include a third number, e.g. [*not]  "2.2.1",
+even if that's the version you have.]
+
+Take note that you may also do that through the Jamrules file we put in
+our project as detailed above. The file
+has [@../../../../example/tutorial/Jamrules detailed instructions] you 
+can follow.
 
 Now we are ready... Be sure to [^cd] to [^libs/python/example/tutorial]
-where the tutorial [^"hello.cpp"] and the [^"Jamroot"] is situated.
+where the tutorial [^"hello.cpp"] and the [^"Jamfile"] is situated.
 
 Finally:
 
-    bjam
+    bjam -sTOOLS=vc-7_1
+
+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
+[@../../../../../../tools/build/index.html Building Boost Libraries] for
+further details.
 
 It should be building now:
 
 [pre
 cd C:\dev\boost\libs\python\example\tutorial
-bjam
+bjam -sTOOLS=msvc
 ...patience...
-...found 1101 targets...
-...updating 35 targets...
+...found 1703 targets...
+...updating 40 targets...
 ]
 
 And so on... Finally:
 
 [pre
-   Creating library /path-to-boost_python.dll/
-   Creating library /path-to-'''hello_ext'''.exp/
-'''**passed**''' ... hello.test
-...updated 35 targets...
+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...
 ]
 
-Or something similar. If all is well, you should now have built the DLLs and
-run the Python program.
+If all is well, you should now have:
+
+* boost_python.dll
+* hello.pyd
+
+if you are on Windows, and
+
+* libboost_python.so
+* hello.so
+
+if you are on Unix.
+
+[^boost_python.dll] and [^hello.pyd] can be found somewhere in your project's
+[^bin] 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.
+
+You may now fire up Python and run our hello module:
+
+[python]
+
+    >>> import hello
+    >>> print hello.greet()
+    hello, world
+
+[c++]
 
 [:[*There you go... Have fun!]]
 
@@ -414,7 +494,7 @@ Doing so, we get some things for free:
   Python via a pointer or reference to [^Base] can be passed where a pointer
   or reference to [^Derived] is expected.
 
-Now, we will expose the C++ free functions [^b] and [^d] and [^factory]:
+Now, we shall expose the C++ free functions [^b] and [^d] and [^factory]:
 
     def("b", b);
     def("d", d);
@@ -424,7 +504,7 @@ Note that free function [^factory] is being used to generate new
 instances of class [^Derived]. In such cases, we use
 [^return_value_policy<manage_new_object>] to instruct Python to adopt
 the pointer to [^Base] and hold the instance in a new Python [^Base]
-object until the the Python object is destroyed. We will see more of
+object until the the Python object is destroyed. We shall see more of
 Boost.Python [link python.call_policies call policies] later.
 
     // Tell Python to take ownership of factory's result
@@ -435,7 +515,7 @@ Boost.Python [link python.call_policies call policies] later.
 
 [section Class Virtual Functions]
 
-In this section, we will learn how to make functions behave polymorphically
+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 [^Base] class:
 
@@ -445,13 +525,13 @@ to our [^Base] class:
         virtual int f() = 0;
     };
 
-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
-`Base`. Yet, when you have a virtual function that's going to be overridden in
-Python and called polymorphically *from C++*, we'll need to add some
-scaffoldings to make things work properly. What we'll do is write a class
-wrapper that derives from `Base` that will unintrusively hook into the virtual
+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 
+`Base`. Yet, when you have a virtual function that's going to be overridden in 
+Python and called polymorphically *from C++*, we'll need to add some 
+scaffoldings to make things work properly. What we'll do is write a class 
+wrapper that derives from `Base` that will unintrusively hook into the virtual 
 functions so that a Python override may be called:
 
     struct BaseWrap : Base, wrapper<Base>
@@ -467,10 +547,8 @@ inherited `wrapper<Base>` (See [@../../../v2/wrapper.html Wrapper]). The
 `wrapper` template makes the job of wrapping classes that are meant to
 overridden in Python, easier.
 
-[blurb __alert__ [*MSVC6/7 Workaround]
-
-If you are using Microsoft Visual C++ 6 or 7, you have to write `f` as:
-
+[blurb __alert__ [*MSVC6/7 Workaround]\n\n 
+If you are using Microsoft Visual C++ 6 or 7, you have to write `f` as:\n\n
 `return call<int>(this->get_override("f").ptr());`.]
 
 BaseWrap's overridden virtual member function `f` in effect calls the
@@ -482,25 +560,24 @@ Finally, exposing `Base`:
         .def("f", pure_virtual(&Base::f))
         ;
 
-`pure_virtual` signals Boost.Python that the function `f` is a pure virtual
+`pure_virtual` signals Boost.Python that the function `f` is a pure virtual 
 function.
 
-[note [*member function and methods]
-
-Python, like many object oriented languages uses the term [*methods].
-Methods correspond roughly to C++'s [*member functions]]
+[blurb __note__ [*member function and methods]\n\n Python, like
+many object oriented languages uses the term [*methods].  Methods
+correspond roughly to C++'s [*member functions]]
 
 [endsect]
 
 [section Virtual Functions with Default Implementations]
 
-We've seen in the previous section how classes with pure virtual functions are
+We've seen in the previous section how classes with pure virtual functions are 
 wrapped using Boost.Python's [@../../../v2/wrapper.html class wrapper]
-facilities. If we wish to wrap [*non]-pure-virtual functions instead, the
+facilities. If we wish to wrap [*non]-pure-virtual functions instead, the 
 mechanism is a bit different.
 
-Recall that in the [link python.class_virtual_functions previous section], we
-wrapped a class with a pure virtual function that we then implemented in C++, or
+Recall that in the [link python.class_virtual_functions previous section], we 
+wrapped a class with a pure virtual function that we then implemented in C++, or 
 Python classes derived from it. Our base class:
 
     struct Base
@@ -518,7 +595,7 @@ not declared as pure virtual:
     };
 
 We wrap it this way:
-
+    
     struct BaseWrap : Base, wrapper<Base>
     {
         int f()
@@ -530,26 +607,24 @@ We wrap it this way:
 
         int default_f() { return this->Base::f(); }
     };
-
-Notice how we implemented `BaseWrap::f`. Now, we have to check if there is an
+    
+Notice how we implemented `BaseWrap::f`. Now, we have to check if there is an 
 override for `f`. If none, then we call `Base::f()`.
 
-[blurb __alert__ [*MSVC6/7 Workaround]
-
+[blurb __alert__ [*MSVC6/7 Workaround]\n\n 
 If you are using Microsoft Visual C++ 6 or 7, you have to rewrite the line
-with the `*note*` as:
-
+with the `*note*` as:\n\n
 `return call<char const*>(f.ptr());`.]
 
 Finally, exposing:
-
+    
     class_<BaseWrap, boost::noncopyable>("Base")
         .def("f", &Base::f, &BaseWrap::default_f)
         ;
 
-Take note that we expose both `&Base::f` and `&BaseWrap::default_f`.
-Boost.Python needs to keep track of 1) the dispatch function [^f] and 2) the
-forwarding function to its default implementation [^default_f]. There's a
+Take note that we expose both `&Base::f` and `&BaseWrap::default_f`. 
+Boost.Python needs to keep track of 1) the dispatch function [^f] and 2) the 
+forwarding function to its default implementation [^default_f]. There's a 
 special [^def] function for this purpose.
 
 In Python, the results would be as expected:
@@ -639,7 +714,7 @@ that correspond to these Python ['special functions]. Example:
 
 Need we say more?
 
-[note What is the business of `operator<<`?
+[blurb __note__ What is the business of `operator<<`?
 Well, the method `str` requires the `operator<<` to do its work (i.e.
 `operator<<` is used by the method defined by `def(str(self))`.]
 
@@ -649,9 +724,9 @@ Well, the method `str` requires the `operator<<` to do its work (i.e.
 [section Functions]
 
 In this chapter, we'll look at Boost.Python powered functions in closer
-detail. We will see some facilities to make exposing C++ functions to
+detail. We shall see some facilities to make exposing C++ functions to
 Python safe from potential pifalls such as dangling pointers and
-references. We will also see facilities that will make it even easier for
+references. We shall also see facilities that will make it even easier for
 us to expose C++ functions that take advantage of C++ features such as
 overloading and default arguments.
 
@@ -814,21 +889,18 @@ or more policies can be composed by chaining. Here's the general syntax:
 Here is the list of predefined call policies. A complete reference detailing
 these can be found [@../../../v2/reference.html#models_of_call_policies here].
 
-* [*with_custodian_and_ward]:  Ties lifetimes of the arguments
-* [*with_custodian_and_ward_postcall]:  Ties lifetimes of the arguments and results
-* [*return_internal_reference]:  Ties lifetime of one argument to that of result
-* [*return_value_policy<T> with T one of:]
-    * [*reference_existing_object]: naive (dangerous) approach
-    * [*copy_const_reference]: Boost.Python v1 approach
-    * [*copy_non_const_reference]:
-    * [*manage_new_object]: Adopt a pointer and hold the instance
+* [*with_custodian_and_ward]\n Ties lifetimes of the arguments
+* [*with_custodian_and_ward_postcall]\n Ties lifetimes of the arguments and results
+* [*return_internal_reference]\n Ties lifetime of one argument to that of result
+* [*return_value_policy<T> with T one of:]\n
+* [*reference_existing_object]\nnaive (dangerous) approach
+* [*copy_const_reference]\nBoost.Python v1 approach
+* [*copy_non_const_reference]\n
+* [*manage_new_object]\n Adopt a pointer and hold the instance
 
-[blurb :-) [*Remember the Zen, Luke:]
-
-"Explicit is better than implicit"
-
-"In the face of ambiguity, refuse the temptation to guess"
-]
+[blurb :-) [*Remember the Zen, Luke:]\n\n
+"Explicit is better than implicit"\n
+"In the face of ambiguity, refuse the temptation to guess"\n]
 
 [endsect]
 [section Overloading]
@@ -862,7 +934,7 @@ We have here our C++ class:
         };
     };
 
-Class X has 4 overloaded functions. We will start by introducing some
+Class X has 4 overloaded functions. We shall start by introducing some
 member function pointer variables:
 
     bool    (X::*fx1)(int)              = &X::f;
@@ -901,8 +973,8 @@ wrapping as outlined in the [link python.overloading previous section], or
 writing thin wrappers:
 
     // write "thin wrappers"
-    int f1(int x) { return f(x); }
-    int f2(int x, double y) { return f(x,y); }
+    int f1(int x) { f(x); }
+    int f2(int x, double y) { f(x,y); }
 
     /*...*/
 
@@ -1027,7 +1099,7 @@ overloaded functions in one-shot:
 
 Then...
 
-    .def("foo", (void(*)(bool, int, char))0, foo_overloads());
+    .def("foo", foo, foo_overloads());
 
 Notice though that we have a situation now where we have a minimum of zero
 (0) arguments and a maximum of 3 arguments.
@@ -1068,7 +1140,7 @@ Then...
 Python is dynamically typed, unlike C++ which is statically typed. Python
 variables may hold an integer, a float, list, dict, tuple, str, long etc.,
 among other things. In the viewpoint of Boost.Python and C++, these
-Pythonic variables are just instances of class [^object]. We will see in
+Pythonic variables are just instances of class [^object]. We shall see in
 this chapter how to deal with Python objects.
 
 As mentioned, one of the goals of Boost.Python is to provide a
@@ -1177,7 +1249,7 @@ Python:
 [python]
 
     >>> d = dict(x.__dict__)     # copies x.__dict__
-    >>> d['whatever'] = 3        # modifies the copy
+    >>> d['whatever']            # modifies the copy
 
 C++:
 [c++]
@@ -1217,14 +1289,14 @@ we wanted to do above can be achieved by writing:
     Vec2& v = extract<Vec2&>(o);
     assert(l == v.length());
 
-The first line attempts to extract the "length" attribute of the Boost.Python
-[^object]. The second line attempts to ['extract] the [^Vec2] object from held
+The first line attempts to extract the "length" attribute of the Boost.Python 
+[^object]. The second line attempts to ['extract] the [^Vec2] object from held 
 by the Boost.Python [^object].
 
-Take note that we said "attempt to" above. What if the Boost.Python [^object]
-does not really hold a [^Vec2] type? This is certainly a possibility considering
-the dynamic nature of Python [^object]s. To be on the safe side, if the C++ type
-can't be extracted, an appropriate exception is thrown. To avoid an exception,
+Take note that we said "attempt to" above. What if the Boost.Python [^object] 
+does not really hold a [^Vec2] type? This is certainly a possibility considering 
+the dynamic nature of Python [^object]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:
 
     extract<Vec2&> x(o);
@@ -1235,7 +1307,7 @@ __tip__ The astute reader might have noticed that the [^extract<T>]
 facility in fact solves the mutable copying problem:
 
     dict d = extract<dict>(x.attr("__dict__"));
-    d["whatever"] = 3;          // modifies x.__dict__ !
+    d['whatever'] = 3;          # modifies x.__dict__ !
 
 
 [endsect]
@@ -1262,12 +1334,10 @@ current [^scope()], which is usually the current module. The snippet above
 creates a Python class derived from Python's [^int] type which is
 associated with the C++ type passed as its first parameter.
 
-[note [*what is a scope?]
-
-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 attributes. Details can be found
-[@../../../v2/scope.html here].]
+[blurb __note__ [*what is a scope?]\n\n 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
+attributes. Details can be found [@../../../v2/scope.html here].]
 
 You can access those values in Python as
 
@@ -1294,6 +1364,11 @@ create a new scope around a class:
 
 [def Py_Initialize          [@http://www.python.org/doc/current/api/initialization.html#l2h-652  Py_Initialize]]
 [def Py_Finalize            [@http://www.python.org/doc/current/api/initialization.html#l2h-656  Py_Finalize]]
+[def PyRun_String           [@http://www.python.org/doc/current/api/veryhigh.html#l2h-55         PyRun_String]]
+[def PyRun_File             [@http://www.python.org/doc/current/api/veryhigh.html#l2h-56         PyRun_File]]
+[def Py_eval_input          [@http://www.python.org/doc/current/api/veryhigh.html#l2h-58         Py_eval_input]]
+[def Py_file_input          [@http://www.python.org/doc/current/api/veryhigh.html#l2h-59         Py_file_input]]
+[def Py_single_input        [@http://www.python.org/doc/current/api/veryhigh.html#l2h-60         Py_single_input]]
 [def Py_XINCREF             [@http://www.python.org/doc/current/api/countingRefs.html#l2h-65     Py_XINCREF]]
 [def Py_XDECREF             [@http://www.python.org/doc/current/api/countingRefs.html#l2h-67     Py_XDECREF]]
 [def PyImport_AppendInittab [@http://www.python.org/doc/current/api/importing.html#l2h-137       PyImport_AppendInittab]]
@@ -1302,23 +1377,6 @@ create a new scope around a class:
 [def PyModule_GetDict       [@http://www.python.org/doc/current/api/moduleObjects.html#l2h-594   PyModule_GetDict]]
 
 [endsect]
-
-[section:creating_python_object Creating `boost::python::object` from `PyObject*`]
-
-When you want a `boost::python::object` to manage a pointer to `PyObject*` pyobj one does:
-
-    boost::python::object o(boost::python::handle<>(pyobj));
-
-In this case, the `o` object, manages the `pyobj`, it won’t increase the reference count on construction.
-
-Otherwise, to use a borrowed reference:
-
-    boost::python::object o(boost::python::handle<>(boost::python::borrowed(pyobj)));
-
-In this case, `Py_INCREF` is called, so `pyobj` is not destructed when object o goes out of scope.
-
-[endsect] [/ creating_python_object ]
-
 [endsect] [/ Object Interface]
 
 [section Embedding]
@@ -1337,17 +1395,17 @@ all. So stay tuned... :-)
 
 [h2 Building embedded programs]
 
-To be able to embed python into your programs, you have to link to
-both Boost.Python's as well as Python's own runtime library.
+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.
 
-Boost.Python's library comes in two variants. Both are located
+Boost.Python's static link library comes in two variants. Both are located
 in Boost's [^/libs/python/build/bin-stage] subdirectory. On Windows, the
 variants are called [^boost_python.lib] (for release builds) and
 [^boost_python_debug.lib] (for debugging). If you can't find the libraries,
 you probably haven't built Boost.Python yet. See
 [@../../../building.html Building and Testing] on how to do this.
 
-Python's library can be found in the [^/libs] subdirectory of
+Python's static link library can be found in the [^/libs] subdirectory of
 your Python directory. On Windows it is called pythonXY.lib where X.Y is
 your major Python version number.
 
@@ -1379,17 +1437,13 @@ 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:
 
-# '''#include''' [^<boost/python.hpp>]
+# '''#include''' [^<boost/python.hpp>]\n\n
 
-# Call Py_Initialize() to start the interpreter and create the [^__main__] module.
+# Call Py_Initialize() to start the interpreter and create the [^__main__] module.\n\n
 
-# Call other Python C API routines to use the interpreter.
+# Call other Python C API routines to use the interpreter.\n\n
 
-[/ # Call Py_Finalize() to stop the interpreter and release its resources.]
-
-[note [*Note that at this time you must not call Py_Finalize() to stop the
-interpreter. This may be fixed in a future version of boost.python.]
-]
+# Call Py_Finalize() to stop the interpreter and release its resources.
 
 (Of course, there can be other C++ code between all of these steps.)
 
@@ -1398,84 +1452,179 @@ interpreter. This may be fixed in a future version of boost.python.]
 [section Using the interpreter]
 
 As you probably already know, objects in Python are reference-counted.
-Naturally, the [^PyObject]s of the Python C API are also reference-counted.
+Naturally, the [^PyObject]s of the Python/C API are also reference-counted.
 There is a difference however. While the reference-counting is fully
-automatic in Python, the Python C API requires you to do it
-[@http://www.python.org/doc/current/c-api/refcounting.html by hand]. This is
+automatic in Python, the Python/C API requires you to do it
+[@http://www.python.org/doc/current/api/refcounts.html by hand]. This is
 messy and especially hard to get right in the presence of C++ exceptions.
 Fortunately Boost.Python provides the [@../../../v2/handle.html handle] and
 [@../../../v2/object.html object] class templates to automate the process.
 
+[h2 Reference-counting handles and objects]
+
+There are two ways in which a function in the Python/C API can return a
+[^PyObject*]: as a ['borrowed reference] or as a ['new reference]. Which of
+these a function uses, is listed in that function's documentation. The two
+require slightely different approaches to reference-counting but both can
+be 'handled' by Boost.Python.
+
+For a function returning a ['borrowed reference] we'll have to tell the
+[^handle] that the [^PyObject*] is borrowed with the aptly named
+[@../../../v2/handle.html#borrowed-spec borrowed] function. Two functions
+returning borrowed references are PyImport_AddModule and PyModule_GetDict.
+The former returns a reference to an already imported module, the latter
+retrieves a module's namespace dictionary. Let's use them to retrieve the
+namespace of the [^__main__] module:
+
+    object main_module((
+        handle<>(borrowed(PyImport_AddModule("__main__")))));
+
+    object main_namespace = main_module.attr("__dict__");
+
+For a function returning a ['new reference] we can just create a [^handle]
+out of the raw [^PyObject*] without wrapping it in a call to borrowed. One
+such function that returns a new reference is PyRun_String which we'll
+discuss in the next section.
+
+[blurb __note__ [*Handle is a class ['template], so why haven't we been using any template parameters?]\n
+\n
+[^handle] has a single template parameter specifying the type of the managed object. This type is [^PyObject] 99% of the time, so the parameter was defaulted to [^PyObject] for convenience. Therefore we can use the shorthand [^handle<>] instead of the longer, but equivalent, [^handle<PyObject>].
+]
+
 [h2 Running Python code]
 
-Boost.python provides three related functions to run Python code from C++.
+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
+functions [@http://www.python.org/doc/current/api/veryhigh.html here]. They
+all work similarly so we will look at only one of them, namely:
 
-    object eval(str expression, object globals = object(), object locals = object())
-    object exec(str code, object globals = object(), object locals = object())
-    object exec_file(str filename, object globals = object(), object locals = object())
+    PyObject* PyRun_String(char *str, int start, PyObject *globals, PyObject *locals)
 
-eval evaluates the given expression and returns the resulting value.
-exec executes the given code (typically a set of statements) returning the result,
-and exec_file executes the code contained in the given file.
+PyRun_String takes the code to execute as a null-terminated (C-style)
+string in its [^str] parameter. The function returns a new reference to a
+Python object. Which object is returned depends on the [^start] paramater.
 
-The [^globals] and [^locals] parameters are Python dictionaries
+The [^start] parameter is the start symbol from the Python grammar to use
+for interpreting the code. The possible values are:
+
+[table Start symbols
+
+    [[Py_eval_input]   [for interpreting isolated expressions]]
+    [[Py_file_input]   [for interpreting sequences of statements]]
+    [[Py_single_input] [for interpreting a single statement]]
+]
+
+When using Py_eval_input, the input string must contain a single expression
+and its result is returned. When using Py_file_input, the string can
+contain an abitrary number of statements and None is returned.
+Py_single_input works in the same way as Py_file_input but only accepts a
+single statement.
+
+Lastly, the [^globals] and [^locals] parameters are Python dictionaries
 containing the globals and locals of the context in which to run the code.
 For most intents and purposes you can use the namespace dictionary of the
 [^__main__] module for both parameters.
 
-Boost.python provides a function to import a module:
+We have already seen how to get the [^__main__] module's namespace so let's
+run some Python code in it:
 
-    object import(str name)
+    object main_module((
+        handle<>(borrowed(PyImport_AddModule("__main__")))));
 
-import imports a python module (potentially loading it into the running process
-first), and returns it.
-
-Let's import the [^__main__] module and run some Python code in its namespace:
-
-    object main_module = import("__main__");
     object main_namespace = main_module.attr("__dict__");
 
-    object ignored = exec("hello = file('hello.txt', 'w')\n"
-                          "hello.write('Hello world!')\n"
-                          "hello.close()",
-                          main_namespace);
+    handle<> ignored((PyRun_String(
+
+        "hello = file('hello.txt', 'w')\n"
+        "hello.write('Hello world!')\n"
+        "hello.close()"
+
+      , Py_file_input
+      , main_namespace.ptr()
+      , main_namespace.ptr())
+    ));
+
+Because the Python/C API doesn't know anything about [^object]s, we used
+the object's [^ptr] member function to retrieve the [^PyObject*].
 
 This should create a file called 'hello.txt' in the current directory
 containing a phrase that is well-known in programming circles.
 
-[h2 Manipulating Python objects]
+[blurb
+    __note__ [*Note] that we wrap the return value of PyRun_String in a
+    (nameless) [^handle] 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 [^PyObject*]s in [^handle]s.
+]
 
-Often we'd like to have a class to manipulate Python objects.
-But we have already seen such a class above, and in the
-[@python/object.html previous section]: the aptly named [^object] class
-and its derivatives. We've already seen that they can be constructed from
-a [^handle]. The following examples should further illustrate this fact:
+[h2 Beyond handles]
+
+It's nice that [^handle] 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
+class to manipulate Python objects. But we have already seen such a class
+above, and in the [@python/object.html previous section]: the aptly
+named [^object] class and it's derivatives. We've already seen that they
+can be constructed from a [^handle]. The following examples should further
+illustrate this fact:
+
+    object main_module((
+         handle<>(borrowed(PyImport_AddModule("__main__")))));
 
-    object main_module = import("__main__");
     object main_namespace = main_module.attr("__dict__");
-    object ignored = exec("result = 5 ** 2", main_namespace);
+
+    handle<> ignored((PyRun_String(
+
+        "result = 5 ** 2"
+
+        , Py_file_input
+        , main_namespace.ptr()
+        , main_namespace.ptr())
+    ));
+
     int five_squared = extract<int>(main_namespace["result"]);
 
 Here we create a dictionary object for the [^__main__] module's namespace.
 Then we assign 5 squared to the result variable and read this variable from
-the dictionary. Another way to achieve the same result is to use eval instead,
-which returns the result directly:
+the dictionary. Another way to achieve the same result is to let
+PyRun_String return the result directly with Py_eval_input:
+
+    object result((handle<>(
+        PyRun_String("5 ** 2"
+            , Py_eval_input
+            , main_namespace.ptr()
+            , main_namespace.ptr()))
+    ));
 
-    object result = eval("5 ** 2");
     int five_squared = extract<int>(result);
 
+[blurb
+    __note__ [*Note] that [^object]'s member function to return the wrapped
+    [^PyObject*] is called [^ptr] instead of [^get]. This makes sense if you
+    take into account the different functions that [^object] and [^handle]
+    perform.
+]
+
 [h2 Exception handling]
 
-If an exception occurs in the evaluation of the python expression,
-[@../../../v2/errors.html#error_already_set-spec error_already_set] is thrown:
+If an exception occurs in the execution of some Python code, the PyRun_String
+function returns a null pointer. Constructing a [^handle] out of this null
+pointer throws [@../../../v2/errors.html#error_already_set-spec error_already_set],
+so basically, the Python exception is automatically translated into a
+C++ exception when using [^handle]:
 
     try
     {
-        object result = eval("5/0");
+        object result((handle<>(PyRun_String(
+            "5/0"
+          , Py_eval_input
+          , main_namespace.ptr()
+          , main_namespace.ptr()))
+        ));
+
         // execution will never get here:
         int five_divided_by_zero = extract<int>(result);
     }
-    catch(error_already_set const &)
+    catch(error_already_set)
     {
         // handle the exception in some way
     }
@@ -1483,13 +1632,13 @@ If an exception occurs in the evaluation of the python expression,
 The [^error_already_set] exception class doesn't carry any information in itself.
 To find out more about the Python exception that occurred, you need to use the
 [@http://www.python.org/doc/api/exceptionHandling.html exception handling functions]
-of the Python C API in your catch-statement. This can be as simple as calling
+of the Python/C API in your catch-statement. This can be as simple as calling
 [@http://www.python.org/doc/api/exceptionHandling.html#l2h-70 PyErr_Print()] to
 print the exception's traceback to the console, or comparing the type of the
 exception with those of the [@http://www.python.org/doc/api/standardExceptions.html
 standard exceptions]:
 
-    catch(error_already_set const &)
+    catch(error_already_set)
     {
         if (PyErr_ExceptionMatches(PyExc_ZeroDivisionError))
         {
@@ -1505,6 +1654,21 @@ standard exceptions]:
 (To retrieve even more information from the exception you can use some of the other
 exception handling functions listed [@http://www.python.org/doc/api/exceptionHandling.html here].)
 
+If you'd rather not have [^handle] throw a C++ exception when it is constructed, you
+can use the [@../../../v2/handle.html#allow_null-spec allow_null] function in the same
+way you'd use borrowed:
+
+    handle<> result((allow_null(PyRun_String(
+        "5/0"
+       , Py_eval_input
+       , main_namespace.ptr()
+       , main_namespace.ptr()))));
+
+    if (!result)
+        // Python exception occurred
+    else
+        // everything went okay, it's safe to use the result
+
 [endsect]
 [endsect] [/ Embedding]
 
@@ -1590,38 +1754,6 @@ Now, our C++ Wrapper:
         .property("pions", range(&F::p_begin, &F::p_end))
         .property("bogons", range(&F::b_begin, &F::b_end));
 
-[*stl_input_iterator]
-
-So far, we have seen how to expose C++ iterators and ranges to Python.
-Sometimes we wish to go the other way, though: we'd like to pass a
-Python sequence to an STL algorithm or use it to initialize an STL
-container. We need to make a Python iterator look like an STL iterator.
-For that, we use `stl_input_iterator<>`. Consider how we might
-implement a function that exposes `std::list<int>::assign()` to
-Python:
-
-[c++]
-
-    template<typename T>
-    void list_assign(std::list<T>& l, object o) {
-        // Turn a Python sequence into an STL input range
-        stl_input_iterator<T> begin(o), end;
-        l.assign(begin, end);
-    }
-
-    // Part of the wrapper for list<int>
-    class_<std::list<int> >("list_int")
-        .def("assign", &list_assign<int>)
-        // ...
-        ;
-
-Now in Python, we can assign any integer sequence to `list_int` objects:
-
-[python]
-
-    x = list_int();
-    x.assign([1,2,3,4,5])
-
 [endsect]
 [section:exception Exception Translation]
 
@@ -1700,7 +1832,7 @@ separately with Boost.Python, like this:
 Compiling these files will generate the following Python extensions:
 [^core.pyd], [^io.pyd] and [^filters.pyd].
 
-[note The extension [^.pyd] is used for python extension modules, which
+[blurb __note__ The extension [^.pyd] is used for python extension modules, which
 are just shared libraries.  Using the default for your system, like [^.so] for
 Unix and [^.dll] for Windows, works just as well.]
 
@@ -1971,11 +2103,11 @@ This method is recommended too if you are developing the C++ library and
 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.
 
-[note If you're exporting your classes with [@../../../../pyste/index.html Pyste],
+[blurb __note__ If you're exporting your classes with [@../../../../pyste/index.html Pyste],
 take a look at the [^--multiple] option, that generates the wrappers in
 various files as demonstrated here.]
 
-[note This method is useful too if you are getting the error message
+[blurb __note__ This method is useful too if you are getting the error message
 ['"fatal error C1204:Compiler limit:internal structure overflow"] when compiling
 a large source file, as explained in the [@../../../v2/faq.html#c1204 FAQ].]
 

doc/tutorial/index.html

@@ -1,18 +1,10 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta http-equiv="refresh" content="0; URL=doc/html/index.html">
   </head>
   <body>
     Automatic redirection failed, click this 
-    <a href="doc/html/index.html">link</a> &nbsp;<hr>
-    <p>© Copyright Beman Dawes, 2001</p>
-    <p>Distributed under the Boost Software License, Version 1.0. (See 
-    accompanying file <a href="../../../../LICENSE_1_0.txt">
-    LICENSE_1_0.txt</a> or copy at
-    <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
+    <a href="doc/html/index.html">link</a>
   </body>
 </html>

doc/v2/Apr2002.html

@@ -1,6 +1,3 @@
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
@@ -160,7 +157,7 @@ documentation).
   13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-<p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
   2002. </i></p>
 </body>
 </html>

doc/v2/CallPolicies.html

@@ -1,14 +1,11 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <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 - CallPolicies Concept</title>
   </head>
@@ -60,7 +57,6 @@
 
       <li><code>postcall</code> - Python argument tuple and result management
       after the wrapped object is invoked</li>
-      <li><code>extract_return_type</code> - metafunction for extracting the return type from a given signature type sequence</li>
     </ol>
 
     <h2><a name="composition"></a>CallPolicies Composition</h2>
@@ -133,16 +129,7 @@
         reference count must be decremented; if another existing object is
         returned, its reference count must be incremented.</td>
       </tr>
-      <tr>
-        <td valign="top"><code>P::extract_return_type</code></td>
-
-        <td>A model of <a href=
-          "../../../mpl/doc/refmanual/metafunction.html">Metafunction</a>.</td>
-
-        <td>An MPL unary <a href=
-          "../../../mpl/doc/refmanual/metafunction.html">Metafunction</a> used extract the return type from a given signature. By default it is derived from mpl::front.</td>
-      </tr>
-  </table>
+    </table>
     Models of CallPolicies are required to be <a href=
     "../../../utility/CopyConstructible.html">CopyConstructible</a>. 
     <hr>
@@ -154,7 +141,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</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

@@ -1,10 +1,7 @@
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
 <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 - Dereferenceable Concept</title>
 </head>
 <body link="#0000ff" vlink="#800080">
@@ -63,7 +60,7 @@ type <code>T</code>.  In addition, all pointers are Dereferenceable.
   18 December, 2003
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
     Abrahams</a> 2002-2003. </i>
 
 <p>Permission to copy, use, modify, sell

doc/v2/Extractor.html

@@ -1,10 +1,7 @@
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
 <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 - Extractor Concept</title>
 </head>
 <body link="#0000ff" vlink="#800080">
@@ -85,7 +82,7 @@ are layout-compatible with PyObject.
   13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
     Abrahams</a> 2002. </i>
 
 <p>Permission to copy, use, modify, sell

doc/v2/HolderGenerator.html

@@ -1,10 +1,7 @@
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
 <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 - Holder Concept</title>
 </head>
 <body link="#0000ff" vlink="#800080">
@@ -63,7 +60,7 @@ type.
   13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
     Abrahams</a> 2002. </i>
 
 <p>Permission to copy, use, modify, sell

doc/v2/Jun2002.html

@@ -1,6 +1,3 @@
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
@@ -223,7 +220,7 @@ you'll just have to wait till next month (hopefully the beginning).
   13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-<p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
   2002. </i></p>
 </body>
 </html>

doc/v2/Mar2002.html

@@ -1,6 +1,3 @@
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
@@ -231,7 +228,7 @@ worth doing anything about it.
   13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-<p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
   2002. </i></p>
 </body>
 </html>

doc/v2/May2002.html

@@ -1,6 +1,3 @@
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
@@ -305,7 +302,7 @@ to these issues will probably have to be formalized before long.
   13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-<p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
   2002. </i></p>
 </body>
 </html>

doc/v2/ObjectWrapper.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -147,7 +144,7 @@ instances of the associated Python type will be considered a match.
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/ResultConverter.html

@@ -1,12 +1,7 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
 <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 - ResultConverter Concept</title>
 </head>
 <body link="#0000ff" vlink="#800080">
@@ -26,12 +21,10 @@
 <dl class="page-index"> 
   <dt><a href="#introduction">Introduction</a></dt>
   <dt><a href="#concept-requirements">Concept Requirements</a></dt>
-  <dd>
-    <dl class="page-index"> 
-      <dt><a href="#ResultConverter-concept">ResultConverter Concept</a></dt>
-      <dt><a href="#ResultConverterGenerator-concept">ResultConverterGenerator Concept</a></dt>
-    </dl>
-  </dd>
+  <dl class="page-index"> 
+    <dt><a href="#ResultConverter-concept">ResultConverter Concept</a></dt>
+    <dt><a href="#ResultConverterGenerator-concept">ResultConverterGenerator Concept</a></dt>
+  </dl>
 </dl>
 
 <h2><a name="introduction"></a>Introduction</h2>
@@ -83,13 +76,6 @@ denotes an object of type <code><b>R</b></code>.
     href="http://www.python.org/doc/current/api/exceptionHandling.html#l2h-71">PyErr_Occurred</a>
     should return non-zero.</td>
   </tr>
-  <tr> 
-    <td valign="top"><code>c.get_pytype()</code></td>
-    <td><code>PyTypeObject const*</code></td>
-    <td>A pointer to a Python Type object corresponding to result of the conversion,
-    or <code>0</code>. Used for documentation generation. If <code>0</code> is returned
-    the generated type in the documentation will be <b>object</b> .</td>
-  </tr>
 </table>
 
 <h3><a name="ResultConverterGenerator-concept"></a>ResultConverterGenerator Concept</h3>
@@ -113,7 +99,7 @@ C++ function return type.
   09 May, 2002    <!--Luann's birthday! -->
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
     Abrahams</a> 2002. </i>
 
 <p>Permission to copy, use, modify, sell

doc/v2/acknowledgments.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -31,7 +28,7 @@
     </table>
     <hr>
 
-    <p><a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> is
+    <p><a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> is
     the architect, designer, and implementor of <b>Boost.Python</b>.</p>
 
     <p><a href="mailto:brett.calcott@paradise.net.nz">Brett Calcott</a>
@@ -47,7 +44,7 @@
     argument support</a> and wrote the excellent <a href=
     "../tutorial/index.html">tutorial documentation</a>.</p>
 
-    <p><a href="http://www.boost.org/people/ralf_w_grosse_kunstleve.htm">Ralf W.
+    <p><a href="../../../../people/ralf_w_grosse_kunstleve.htm">Ralf W.
     Grosse-Kunstleve</a> implemented the <a href="pickle.html">pickle
     support</a>, and has enthusiastically supported the library since its
     birth, contributing to design decisions and providing invaluable
@@ -59,15 +56,15 @@
     C++ and Python for solving the problems of large-scale software
     construction.</p>
 
-    <p><a href="http://www.boost.org/people/aleksey_gurtovoy.htm">Aleksey Gurtovoy</a>
+    <p><a href="../../../../people/aleksey_gurtovoy.htm">Aleksey Gurtovoy</a>
     wrote an incredible C++ <a href="http://www.mywikinet.com/mpl">Template
     Metaprogramming Library</a> which allows Boost.Python to perform much of
     its compile-time magic. In addition, Aleksey very generously contributed
     his time and deep knowledge of the quirks of various buggy compilers to
     help us get around problems at crucial moments.</p>
 
-    <p><a href="http://www.boost.org/people/paul_mensonides.htm">Paul Mensonides</a>,
-    building on the work <a href="http://www.boost.org/people/vesa_karvonen.htm">Vesa
+    <p><a href="../../../../people/paul_mensonides.htm">Paul Mensonides</a>,
+    building on the work <a href="../../../../people/vesa_karvonen.htm">Vesa
     Karvonen</a>, wrote a similarly amazing <a href=
     "../../../preprocessor/doc/index.html">Preprocessor Metaprogramming
     Library</a>, and generously contributed the time and expertise to get it
@@ -129,7 +126,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/args.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -101,7 +98,7 @@ namespace boost { namespace python
         struct arg 
         {
           template &lt;class T&gt;
-                  arg &amp;operator = (T const &amp;value);
+                  arg &amp;perator = (T const &amp;value);
           explicit arg (char const *name){elements[0].name = name;}
         };
 
@@ -193,7 +190,7 @@ BOOST_PYTHON_MODULE(xxx)
     <p>Revised 01 August, 2003</p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002-2003.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002-2003.</i></p>
   </body>
 </html>
 

doc/v2/call.html

@@ -1,6 +1,3 @@
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
@@ -79,7 +76,7 @@ double apply2(PyObject* func, double x, double y)
   9 May, 2002 <!-- Luann's birthday! -->
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-<p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
   2002. </i></p>
 </body>
 </html>

doc/v2/call_method.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -155,7 +152,7 @@ BOOST_PYTHON_MODULE(my_module)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/callbacks.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -248,7 +245,7 @@ void apply(PyObject* callable, X&amp; x)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/callbacks.txt

@@ -1,7 +1,3 @@
-.. Copyright David Abrahams 2006. Distributed under the Boost
-.. Software License, Version 1.0. (See accompanying
-.. file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
 Here's the plan:
 
 I aim to provide an interface similar to that of Boost.Python v1's

doc/v2/class.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
   <meta name="generator" content=
@@ -784,7 +781,7 @@ class_&lt;Derived, bases&lt;Base&gt; &gt;("Derived");
 <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
    1 November, 2005 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
-  <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
+  <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
   Abrahams</a> 2002.</i></p>
 </body>
 </html>

doc/v2/configuration.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -106,33 +103,6 @@
         function from being treated as an exported symbol on platforms which
         support that distinction in-code</td>
       </tr>
-
-      <tr>
-        <td valign="top"><code>BOOST_PYTHON_ENABLE_CDECL</code></td>
-
-        <td valign="top" align="center"><i>not&nbsp;defined</i></td>
-
-        <td valign="top">If defined, allows functions using the <code>__cdecl
-        </code> calling convention to be wrapped.</td>
-      </tr>
-
-      <tr>
-        <td valign="top"><code>BOOST_PYTHON_ENABLE_STDCALL</code></td>
-
-        <td valign="top" align="center"><i>not&nbsp;defined</i></td>
-
-        <td valign="top">If defined, allows functions using the <code>__stdcall
-        </code> calling convention to be wrapped.</td>
-      </tr>
-
-      <tr>
-        <td valign="top"><code>BOOST_PYTHON_ENABLE_FASTCALL</code></td>
-
-        <td valign="top" align="center"><i>not&nbsp;defined</i></td>
-
-        <td valign="top">If defined, allows functions using the <code>__fastcall
-        </code> calling convention to be wrapped.</td>
-      </tr>
     </table>
 
     <h2><a name="lib-defined-impl"></a>Library Defined Implementation
@@ -166,41 +136,6 @@
         compares <code>typeid(T).name()</code> instead of using and comparing
         the <code>std::type_info</code> objects directly.</td>
       </tr>
-      <tr>
-        <td valign="top"><code>BOOST_PYTHON_NO_PY_SIGNATURES</code></td>
-
-        <td valign="top" align="center"><i>not&nbsp;defined</i></td>
-
-        <td valign="top">If defined for a module no pythonic signatures are generated 
-        for the docstrings of the module functions, and no python type is associated with any
-        of the converters registered by the module. This also reduces the binary size of the 
-        module by about 14% (gcc compiled).<br>
-        If defined for the boost_python runtime library, the default for the 
-        <code>docstring_options.enable_py_signatures()</code> is set to <code>false</code>.
-        </td>
-
-      </tr>
-      <tr>
-        <td valign="top"><code>BOOST_PYTHON_SUPPORTS_PY_SIGNATURES</code></td>
-
-        <td valign="top" align="center"><i>defined if <code>BOOST_PYTHON_NO_PY_SIGNATURES</code> is undefined</i></td>
-
-        <td valign="top">This macro is defined to enable a smooth transition from older Boost.Python versions
-        which do not support pythonic signatures. For example usage see 
-        <a href="pytype_function.html#examples">here</a>.
-        </td>
-
-      </tr>
-      <tr>
-        <td valign="top"><code>BOOST_PYTHON_PY_SIGNATURES_PROPER_INIT_SELF_TYPE</code></td>
-
-        <td valign="top" align="center"><i>not&nbsp;defined</i></td>
-
-        <td valign="top">If defined the python type of <code>__init__</code> method "self" parameters
-        is properly generated, otherwise <code><b>object</b></code> is used. It is undefined
-        by default because it increases the binary size of the module by about 14% (gcc compiled).</td>
-
-      </tr>
     </table>
     <hr>
 
@@ -211,7 +146,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/copy_const_reference.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -143,7 +140,7 @@ BOOST_PYTHON_MODULE(my_module)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/copy_non_const_reference.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -143,7 +140,7 @@ BOOST_PYTHON_MODULE(my_module)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/data_members.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -223,7 +220,7 @@ BOOST_PYTHON_MODULE_INIT(data_members_example)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/def.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -185,7 +182,7 @@ BOOST_PYTHON_MODULE(def_test)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/def_visitor.html

@@ -132,6 +132,4 @@ BOOST_PYTHON_MODULE(my_ext)
   </p>
 
 
-    <p><i>&copy; Copyright Joel de Guzman 2003. </i> Distributed under the Boost
-   Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 
+    <p><i>&copy; Copyright Joel de Guzman 2003. </i>

doc/v2/default_call_policies.html

@@ -82,7 +82,6 @@ namespace boost { namespace python
         static PyObject* postcall(PyObject*, PyObject* result);
         typedef <a href=
 "#default_result_converter-spec">default_result_converter</a> result_converter;
-        template &lt;class Sig&gt; struct extract_return_type : mpl::front&lt;Sig&gt;{};
     };
 }}
 </pre>
@@ -162,12 +161,10 @@ struct return_value_policy : Base
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  11 June, 2007
+  13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
-  <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
-  Abrahams</a> 2002.</i> Distributed under the Boost Software License,
-  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-  http://www.boost.org/LICENSE_1_0.txt)</p>
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. </i>
 

doc/v2/definitions.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -96,7 +93,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/dict.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -146,7 +143,7 @@ dict swap_object_dict(object target, dict d)
     <p>Revised 30 September, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/docstring_options.html

@@ -1,386 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
-<html>
-<head>
-  <meta name="generator" content=
-  "HTML Tidy for Linux/x86 (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 -
-  &lt;boost/python/docstring_options.hpp&gt;</title>
-</head>
-
-<body>
-  <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">Header
-        &lt;boost/python/docstring_options.hpp&gt;</h2>
-      </td>
-    </tr>
-  </table>
-  <hr>
-
-  <h2>Contents</h2>
-
-  <dl class="page-index">
-    <dt><a href="#introduction">Introduction</a></dt>
-
-    <dt><a href="#classes">Classes</a></dt>
-
-    <dd>
-      <dl class="page-index">
-        <dt><a href="#docstring_options-spec">Class
-        <code>docstring_options</code></a></dt>
-
-        <dd>
-          <dl class="page-index">
-            <dt><a href="#docstring_options-spec-synopsis">Class
-            <code>docstring_options</code> synopsis</a></dt>
-
-            <dt><a href="#docstring_options-spec-ctors">Class
-            <code>docstring_options</code> constructors</a></dt>
-
-            <dt><a href="#docstring_options-spec-dtors">Class
-            <code>docstring_options</code> destructors</a></dt>
-
-            <dt><a href="#docstring_options-spec-modifiers">Class
-            <code>docstring_options</code> modifiers</a></dt>
-          </dl>
-        </dd>
-      </dl>
-    </dd>
-
-    <dt><a href="#examples">Examples</a></dt>
-  </dl>
-  <hr>
-
-  <h2><a name="introduction" id=
-  "introduction"></a>Introduction</h2>
-
-  <p>Boost.Python supports user-defined docstrings with automatic
-  appending of C++ signatures. These features are enabled by
-  default. The <code>class docstring_options</code> is available to
-  selectively suppress the user-defined docstrings, signatures, or
-  both.</p>
-
-  <h2><a name="classes" id="classes"></a>Classes</h2>
-
-  <h3><a name="docstring_options-spec" id=
-  "docstring_options-spec"></a>Class
-  <code>docstring_options</code></h3>
-
-  <p>Controls the appearance of docstrings of wrapped functions and
-  member functions for the life-time of the instance. The instances
-  are noncopyable to eliminate the possibility of surprising side
-  effects.</p>
-
-  <h4><a name="docstring_options-spec-synopsis" id=
-  "docstring_options-spec-synopsis"></a>Class
-  <code>docstring_options</code> synopsis</h4>
-  <pre>
-namespace boost { namespace python {
-
-    class docstring_options : boost::noncopyable
-    {
-      public:
-          docstring_options(bool show_all=true);
-
-          docstring_options(bool show_user_defined, bool show_signatures);
-
-          docstring_options(bool show_user_defined, bool show_py_signatures, bool show_cpp_signatures);
-
-          ~docstring_options();
-
-          void
-          disable_user_defined();
-
-          void
-          enable_user_defined();
-
-          void
-          disable_signatures();
-
-          void
-          enable_signatures();
-
-          void
-          disable_py_signatures();
-
-          void
-          enable_py_signatures();
-
-          void
-          disable_cpp_signatures();
-
-          void
-          enable_cpp_signatures();
-
-          void
-          disable_all();
-
-          void
-          enable_all();
-    };
-
-}}
-</pre>
-
-  <h4><a name="docstring_options-spec-ctors" id=
-  "docstring_options-spec-ctors"></a>Class
-  <code>docstring_options</code> constructors</h4>
-  <pre>
-docstring_options(bool show_all=true);
-</pre>
-
-  <dl class="function-semantics">
-    <dt><b>Effects:</b> Constructs a <code>docstring_options</code>
-    object which controls the appearance of function and
-    member-function docstrings defined in the code that follows. If
-    <code>show_all</code> is <code>true</code>, both the
-    user-defined docstrings and the automatically generated Python and C++
-    signatures are shown. If <code>show_all</code> is
-    <code>false</code> the <code>__doc__</code> attributes are
-    <code>None</code>.</dt>
-  </dl>
-  <pre>
-docstring_options(bool show_user_defined, bool show_signatures);
-</pre>
-
-  <dl class="function-semantics">
-    <dt><b>Effects:</b> Constructs a <code>docstring_options</code>
-    object which controls the appearance of function and
-    member-function docstrings defined in the code that follows.
-    Iff <code>show_user_defined</code> is <code>true</code>, the
-    user-defined docstrings are shown. Iff
-    <code>show_signatures</code> is <code>true</code>, Python and C++
-    signatures are automatically added. If both
-    <code>show_user_defined</code> and <code>show_signatures</code>
-    are <code>false</code>, the <code>__doc__</code> attributes are
-    <code>None</code>.</dt>
-  </dl>
-  <pre>
-docstring_options(bool show_user_defined, bool show_py_signatures, bool show_cpp_signatures);
-</pre>
-
-  <dl class="function-semantics">
-    <dt><b>Effects:</b> Constructs a <code>docstring_options</code>
-    object which controls the appearance of function and
-    member-function docstrings defined in the code that follows.
-    Iff <code>show_user_defined</code> is <code>true</code>, the
-    user-defined docstrings are shown. Iff
-    <code>show_py_signatures</code> is <code>true</code>, Python 
-    signatures are automatically added. Iff 
-    <code>show_cpp_signatures</code> is <code>true</code>, C++ 
-    signatures are automatically added. If all parameters are
-    <code>false</code>, the <code>__doc__</code> attributes are
-    <code>None</code>.</dt>
-  </dl>
-
-  <h4><a name="docstring_options-spec-dtors" id=
-  "docstring_options-spec-dtors"></a>Class
-  <code>docstring_options</code> destructors</h4>
-  <pre>
-~docstring_options();
-</pre>
-
-  <dl class="function-semantics">
-    <dt><b>Effects:</b> Restores the previous state of the
-    docstring options. In particular, if
-    <code>docstring_options</code> instances are in nested C++
-    scopes the settings effective in the enclosing scope are
-    restored. If the last <code>docstring_options</code> instance
-    goes out of scope the default "all on" settings are
-    restored.</dt>
-  </dl>
-
-  <h4><a name="docstring_options-spec-modifiers" id=
-  "docstring_options-spec-modifiers"></a>Class
-  <code>docstring_options</code> modifier functions</h4>
-  <pre>
-void disable_user_defined();
-void enable_user_defined();
-void disable_signatures();
-void enable_signatures();
-void disable_py_signatures();
-void enable_py_signatures();
-void disable_cpp_signatures();
-void enable_cpp_signatures();
-void disable_all();
-void enable_all();
-</pre>
-
-  <dl class="function-semantics">
-    <dt>These member functions dynamically change the appearance of
-    docstrings in the code that follows. The
-    <code>*_user_defined()</code> and <code>*_signatures()</code>
-    member functions are provided for fine-grained control. The
-    <code>*_all()</code> member functions are convenient shortcuts
-    to manipulate all settings simultaneously.</dt>
-  </dl>
-
-  <h2><a name="examples" id="examples"></a>Examples</h2>
-
-  <h4>Docstring options defined at compile time</h4>
-  <pre>
-#include &lt;boost/python/module.hpp&gt;
-#include &lt;boost/python/def.hpp&gt;
-#include &lt;boost/python/docstring_options.hpp&gt;
-
-void foo() {}
-
-BOOST_PYTHON_MODULE(demo)
-{
-    using namespace boost::python;
-    docstring_options doc_options(DEMO_DOCSTRING_SHOW_ALL);
-    def("foo", foo, "foo doc");
-}
-</pre>If compiled with <code>-DDEMO_DOCSTRING_SHOW_ALL=true</code>:
-  <pre>
-&gt;&gt;&gt; import demo
-&gt;&gt;&gt; print demo.foo.__doc__
-foo() -&gt; None : foo doc
-C++ signature:
-    foo(void) -&gt; void
-</pre>If compiled with
-<code>-DDEMO_DOCSTRING_SHOW_ALL=false</code>:
-  <pre>
-&gt;&gt;&gt; import demo
-&gt;&gt;&gt; print demo.foo.__doc__
-None
-</pre>
-
-  <h4>Selective suppressions</h4>
-  <pre>
-#include &lt;boost/python/module.hpp&gt;
-#include &lt;boost/python/def.hpp&gt;
-#include &lt;boost/python/args.hpp&gt;
-#include &lt;boost/python/docstring_options.hpp&gt;
-
-int foo1(int i) { return i; }
-int foo2(long l) { return static_cast&lt;int&gt;(l); }
-int foo3(float f) { return static_cast&lt;int&gt;(f); }
-int foo4(double d) { return static_cast&lt;int&gt;(d); }
-
-BOOST_PYTHON_MODULE(demo)
-{
-    using namespace boost::python;
-    docstring_options doc_options;
-    def("foo1", foo1, arg("i"), "foo1 doc");
-    doc_options.disable_user_defined();
-    def("foo2", foo2, arg("l"), "foo2 doc");
-    doc_options.disable_signatures();
-    def("foo3", foo3, arg("f"), "foo3 doc");
-    doc_options.enable_user_defined();
-    def("foo4", foo4, arg("d"), "foo4 doc");
-    doc_options.enable_py_signatures();
-    def("foo5", foo4, arg("d"), "foo5 doc");
-    doc_options.disable_py_signatures();
-    doc_options.enable_cpp_signatures();
-    def("foo6", foo4, arg("d"), "foo6 doc");
-}
-</pre>Python code:
-  <pre>
-&gt;&gt;&gt; import demo
-&gt;&gt;&gt; print demo.foo1.__doc__
-foo1( (int)i) -&gt; int : foo1 doc
-C++ signature:
-    foo1(int i) -&gt; int
-&gt;&gt;&gt; print demo.foo2.__doc__
-foo2( (int)l) -&gt; int : 
-C++ signature:
-    foo2(long l) -&gt; int
-&gt;&gt;&gt; print demo.foo3.__doc__
-None
-&gt;&gt;&gt; print demo.foo4.__doc__
-foo4 doc
-&gt;&gt;&gt; print demo.foo5.__doc__
-foo5( (float)d) -&gt; int : foo5 doc
-&gt;&gt;&gt; print demo.foo6.__doc__
-foo6 doc
-C++ signature:
-    foo6(double d) -&gt; int
-</pre>
-
-  <h4>Wrapping from multiple C++ scopes</h4>
-  <pre>
-#include &lt;boost/python/module.hpp&gt;
-#include &lt;boost/python/def.hpp&gt;
-#include &lt;boost/python/args.hpp&gt;
-#include &lt;boost/python/docstring_options.hpp&gt;
-
-int foo1(int i) { return i; }
-int foo2(long l) { return static_cast&lt;int&gt;(l); }
-
-int bar1(int i) { return i; }
-int bar2(long l) { return static_cast&lt;int&gt;(l); }
-
-namespace {
-
-    void wrap_foos()
-    {
-        using namespace boost::python;
-        // no docstring_options here
-        //   -&gt; settings from outer C++ scope are in effect
-        def("foo1", foo1, arg("i"), "foo1 doc");
-        def("foo2", foo2, arg("l"), "foo2 doc");
-    }
-
-    void wrap_bars()
-    {
-        using namespace boost::python;
-        bool show_user_defined = true;
-        bool show_signatures = false;
-        docstring_options doc_options(show_user_defined, show_signatures);
-        def("bar1", bar1, arg("i"), "bar1 doc");
-        def("bar2", bar2, arg("l"), "bar2 doc");
-    }
-}
-
-BOOST_PYTHON_MODULE(demo)
-{
-    boost::python::docstring_options doc_options(false);
-    wrap_foos();
-    wrap_bars();
-}
-</pre>Python code:
-  <pre>
-&gt;&gt;&gt; import demo
-&gt;&gt;&gt; print demo.foo1.__doc__
-None
-&gt;&gt;&gt; print demo.foo2.__doc__
-None
-&gt;&gt;&gt; print demo.bar1.__doc__
-bar1 doc
-&gt;&gt;&gt; print demo.bar2.__doc__
-bar2 doc
-</pre>
-
-  <h4>See also: <code>boost/libs/python/test/docstring.cpp</code>
-  and <code>docstring.py</code></h4>
-
-  <p>Revised 
-  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-   16 January, 2006 
-  <!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
-
-  <p><i>&copy; Copyright <a href=
-  "http://www.boost.org/people/ralf_w_grosse_kunstleve.htm">Ralf W.
-  Grosse-Kunstleve</a> 2006.</i></p>
-</body>
-</html>

doc/v2/enum.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -89,7 +86,7 @@ namespace boost { namespace python
   template &lt;class T&gt;
   class enum_ : public <a href="object.html#object-spec">object</a>
   {
-    enum_(char const* name, char const* doc = 0);
+    enum_(char const* name);
     enum_&lt;T&gt;&amp; value(char const* name, T);
     enum_&lt;T&gt;&amp; export_values();
   };
@@ -99,7 +96,7 @@ namespace boost { namespace python
     <h4><a name="enum_-spec-ctors"></a>Class template <code>enum_</code>
     constructors</h4>
 <pre>
-enum_(char const* name, char const* doc=0);
+enum_(char const* name);
 </pre>
 
     <dl class="function-semantics">
@@ -131,7 +128,7 @@ inline enum_&lt;T&gt;&amp; value(char const* name, T x);
 
       <dt><b>Effects:</b> adds an instance of the wrapped enumeration
       type with value <code>x</code> to the type's dictionary as the
-      <code>name</code>d attribute.</dt>
+      <code>name</code>d attribute</dt>.
 
       <dt><b>Returns:</b> <code>*this</code></dt>
 
@@ -146,7 +143,7 @@ inline enum_&lt;T&gt;&amp; export_values();
       <dt><b>Effects:</b> sets attributes in the current <a
         href="scope.html#scope-spec"><code>scope</code></a> with the
         same names and values as all enumeration values exposed so far
-        by calling <code>value()</code>.</dt>
+        by calling <code>value()</code></dt>.
 
       <dt><b>Returns:</b> <code>*this</code></dt>
 
@@ -228,7 +225,7 @@ TypeError: bad argument type for built-in operation
      
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/errors.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -283,7 +280,7 @@ same_name2(PyObject* args, PyObject* keywords)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/exception_translator.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -144,7 +141,7 @@ BOOST_PYTHON_MODULE(exception_translator_ext)
     <p>Revised 03 October, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/exec.html

@@ -1,163 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
-<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 - &lt;boost/python/exec.hpp&gt;</title>
-  </head>
-
-  <body>
-    <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">Header &lt;boost/python/exec.hpp&gt;</h2>
-        </td>
-      </tr>
-    </table>
-    <hr>
-
-    <h2>Contents</h2>
-
-    <dl class="page-index">
-      <dt><a href="#introduction">Introduction</a></dt>
-
-      <dt><a href="#functions">Functions</a></dt>
-
-      <dd>
-        <dl class="page-index">
-          <dt><a href="#eval-spec"><code>eval</code></a></dt>
-          <dt><a href="#exec-spec"><code>exec</code></a></dt>
-          <dt><a href="#exec_file-spec"><code>exec_file</code></a></dt>
-        </dl>
-      </dd>
-      <dt><a href="#examples">Examples</a></dt>
-    </dl>
-    <hr>
-
-    <h2><a name="introduction"></a>Introduction</h2>
-
-    <p>Exposes a mechanism for embedding the python interpreter into C++ code.</p>
-
-    <h2><a name="functions"></a>Functions</h2>
-
-    <h3><a name="eval-spec"></a><code>eval</code></h3>
-    <pre>
-object eval(str expression,
-            object globals = object(),
-            object locals = object());
-    </pre>
-    <dl class="function-semantics">
-      <dt><b>Effects:</b>
-        Evaluate Python expression from <code>expression</code> in the context 
-        specified by the dictionaries <code>globals</code> and <code>locals</code>.
-      </dt>
-      <dt><b>Returns:</b>
-        An instance of <a href="object.html#object-spec">object</a> 
-        which holds the value of the expression.
-      </dt>
-    </dl>
-
-    <h3><a name="exec-spec"></a><code>exec</code></h3>
-    <pre>
-object exec(str code,
-            object globals = object(),
-            object locals = object());
-    </pre>
-    <dl class="function-semantics">
-      <dt><b>Effects:</b>
-        Execute Python source code from <code>code</code> in the context 
-        specified by the dictionaries <code>globals</code> and <code>locals</code>.
-      </dt>
-      <dt><b>Returns:</b>
-        An instance of <a href="object.html#object-spec">object</a> 
-        which holds the result of executing the code.
-      </dt>
-    </dl>
-
-    <h3><a name="exec_file-spec"></a><code>exec_file</code></h3>
-    <pre>
-object exec_file(str filename,
-                 object globals = object(),
-                 object locals = object());
-    </pre>
-    <dl class="function-semantics">
-      <dt><b>Effects:</b>
-        Execute Python source code from the file named by <code>filename</code>
-        in the context specified by the  dictionaries <code>globals</code> and 
-        <code>locals</code>.
-      </dt>
-      <dt><b>Returns:</b>
-        An instance of <a href="object.html#object-spec">object</a> 
-        which holds the result of executing the code.
-      </dt>
-    </dl>
-
-    <h2><a name="examples"></a>Examples</h2>
-
-    <para>The following example demonstrates the use of <function>import</function>
-      and <function>exec</function> to define a function in python, and later call
-      it from within C++.</para>
-
-<pre>
-#include &lt;iostream&gt;
-#include &lt;string&gt;
-
-using namespace boost::python;
-
-void greet()
-{ 
-  // Retrieve the main module.
-  object main = import("__main__");
-  
-  // Retrieve the main module's namespace
-  object global(main.attr("__dict__"));
-
-  // Define greet function in Python.
-  object result = exec(
-    "def greet():                   \n"
-    "   return 'Hello from Python!' \n",
-    global, global);
-
-  // Create a reference to it.
-  object greet = global["greet"];
-
-  // Call it.
-  std::string message = extract&lt;std::string&gt;(greet());
-  std::cout &lt;&lt; message &lt;&lt; std::endl;
-}
-</pre>
-
-    <para>Instead of embedding the python script into a string,
-      we could also store it in an a file...</para>
-
-<pre>
-def greet():
-   return 'Hello from Python!'
-</pre>
-    <para>... and execute that instead.</para>
-<pre>
-  // ...
-  // Load the greet function from a file.
-  object result = exec_file(script, global, global);
-  // ...
-}
-</pre>
-    <p>Revised 01 November, 2005</p>
-
-    <p><i>&copy; Copyright Stefan Seefeld 2005.</i></p>
-  </body>
-</html>
-

doc/v2/extract.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -226,7 +223,7 @@ BOOST_PYTHON_MODULE(extract_ext)
     <p>Revised 15 November, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/faq.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -70,6 +67,8 @@
       >error C2064: term does not evaluate to a function taking 2 arguments</a>
       </dt>
 
+      <dt><a href="#voidptr">How do I handle <tt>void *</tt> conversion?</a></dt>
+
       <dt><a href="#custom_string"
       >How can I automatically convert my custom string type to
        and from a Python string?</a></dt>
@@ -569,7 +568,7 @@ handle&lt;&gt; f_wrap()
 ...
 
 def("f", f_wrap());
-class_&lt;X,X_wrap,boost::noncopyable&gt;("X", init&lt;int&gt;())
+class_&lt;X,X_wrap&gt;("X", init&lt;int&gt;())
    ...
    ;
 </pre>
@@ -694,6 +693,29 @@ void Export_FXThread()
         .def("setAutoDelete", (bool (FXThread::*)(bool)) &amp;FXThread::setAutoDelete)</pre>
     <p>(The bug has been reported to Microsoft.)</p>
 
+    <hr>
+    <h2><a name="voidptr"></a>How do I handle <tt>void *</tt> conversion?</h2>
+    <font size="-1"><i>Niall Douglas provides these notes:</i></font><p>
+    For several reasons Boost.Python does not support <tt>void *</tt> as
+    an argument or as a return value. However, it is possible to wrap
+    functions with <tt>void *</tt> arguments or return values using
+    thin wrappers and the <i>opaque pointer</i> facility. E.g.:
+    <pre>// Declare the following in each translation unit
+struct void_ {};
+BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID(void_);
+
+void *foo(int par1, void *par2);
+
+void_ *foo_wrapper(int par1, void_ *par2)
+{
+    return (void_ *) foo(par1, par2);
+}
+...
+BOOST_PYTHON_MODULE(bar)
+{
+    def("foo", &amp;foo_wrapper);
+}</pre>
+
     <hr>
     <h2><a name="custom_string"></a>How can I automatically
     convert my custom string type to and from a Python string?</h2>
@@ -851,11 +873,11 @@ BOOST_PYTHON_MODULE(custom_string)
 
     <p>Revised
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     12 March, 2006
+     28 January, 2004
     <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002-2006.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002-2003.</i></p>
   </body>
 </html>

doc/v2/feb2002.html

@@ -360,8 +360,7 @@
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
-  <p class="c3">&copy; Copyright <a href=
-  "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002. Distributed
-  under the Boost Software License, Version 1.0. (See accompanying file
-  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)</p>
+    <p class="c3">&copy; Copyright <a href= 
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a>
+    2002. 
 

doc/v2/function_doc_signature.html

@@ -1,216 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<!-- Copyright Nikolay Mladenov	 2007. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
-<html>
-<head>
-  <meta http-equiv="Content-Type" content=
-  "text/html; charset=us-ascii">
-  <link rel="stylesheet" type="text/css" href="../boost.css">
-
-  <title>Boost.Python -
-  &lt;boost/python/doobject/function_doc_signature.hpp&gt;</title>
-</head>
-
-<body>
-  <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">Header
-        &lt;boost/python/object/function_doc_signature.hpp&gt;</h2>
-      </td>
-    </tr>
-  </table>
-  <hr>
-
-  <h2>Contents</h2>
-
-  <dl class="page-index">
-    <dt><a href="#introduction">Introduction</a></dt>
-
-    <dt><a href="#classes">Classes</a></dt>
-
-    <dd>
-      <dl class="page-index">
-        <dt><a href="#function_doc_signature_generator-spec">Class
-        <code>function_doc_signature_generator</code></a></dt>
-
-        <dd>
-          <dl class="page-index">
-            <dt><a href="#function_doc_signature_generator-spec-synopsis">Class
-            <code>function_doc_signature_generator</code> synopsis</a></dt>
-
-          </dl>
-        </dd>
-      </dl>
-    </dd>
-
-    <dt><a href="#examples">Examples</a></dt>
-  </dl>
-  <hr>
-
-  <h2><a name="introduction" id=
-  "introduction"></a>Introduction</h2>
-
-  <p>Boost.Python supports docstrings with automatic
-  appending of Pythonic and C++ signatures. This feature is implemented 
-  by <code>class function_doc_signature_generator</code>
-  The class uses all of the overloads, supplied arg names and default values, as well as 
-  the user-defined docstrings, to generate documentation for a given function.</p>
-
-  <h2><a name="classes" id="classes"></a>Classes</h2>
-
-  <h3><a name="function_doc_signature_generator-spec" id=
-  "function_doc_signature_generator-spec"></a>Class
-  <code>function_doc_signature_generator</code></h3>
-
-  <p>
-   The class has only one public function which returns a list of strings documenting the
-   overloads of a function.
-  </p>
-
-  <h4><a name="function_doc_signature_generator-spec-synopsis" id=
-  "function_doc_signature_generator-spec-synopsis"></a>Class
-  <code>function_doc_signature_generator</code> synopsis</h4>
-  <pre>
-namespace boost { namespace python { namespace objects {
-
-    class function_doc_signature_generator 
-    {
-      public:
-          static list function_doc_signatures(function const *f);
-    };
-
-}}}
-</pre>
-
-
-  <h2><a name="examples" id="examples"></a>Examples</h2>
-
-  <h4>Docstrings generated with <code>function_doc_signature_generator</code></h4>
-  <pre>
-#include &lt;boost/python/module.hpp&gt;
-#include &lt;boost/python/def.hpp&gt;
-#include &lt;boost/python/args.hpp&gt;
-#include &lt;boost/python/tuple.hpp&gt;
-#include &lt;boost/python/class.hpp&gt;
-#include &lt;boost/python/overloads.hpp&gt;
-#include &lt;boost/python/raw_function.hpp&gt;
-
-using namespace boost::python;
-
-tuple f(int x = 1, double y = 4.25, char const* z = "wow")
-{
-    return make_tuple(x, y, z);
-}
-
-BOOST_PYTHON_FUNCTION_OVERLOADS(f_overloads, f, 0, 3)
-
-
-struct X
-{
-    tuple f(int x = 1, double y = 4.25, char const* z = "wow")
-    {
-        return make_tuple(x, y, z);
-    }
-};
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(X_f_overloads, X::f, 0, 3)
-
-tuple raw_func(tuple args, dict kw)
-{
-    return make_tuple(args, kw);
-}
-
-BOOST_PYTHON_MODULE(args_ext)
-{
-    def("f", f, (arg("x")=1, arg("y")=4.25, arg("z")="wow")
-        , "This is f's docstring"
-        );
-
-    def("raw", raw_function(raw_func));
-
-    def("f1", f, f_overloads("f1's docstring", args("x", "y", "z")));
-
-
-    class_&lt;X&gt;("X", "This is X's docstring", init&lt;&gt;(args("self")))
-        .def("f", &amp;X::f
-             , "This is X.f's docstring"
-             , args("self","x", "y", "z"))
-
-        ;
-
-}
-
-</pre>
-Python code:
-  <pre>
-&gt;&gt;&gt; import args_ext
-&gt;&gt;&gt; help(args_ext)
-Help on module args_ext:
-
-NAME
-    args_ext
-
-FILE
-    args_ext.pyd
-
-CLASSES
-    Boost.Python.instance(__builtin__.object)
-        X
-
-    class X(Boost.Python.instance)
-     |  This is X's docstring
-     |
-     |  Method resolution order:
-     |      X
-     |      Boost.Python.instance
-     |      __builtin__.object
-     |
-     |  Methods defined here:
-     |
-     |  __init__(...)
-     |      __init__( (object)self) -> None :
-     |       C++ signature:
-     |           void __init__(struct _object *)
-     |
-     |  f(...)
-     |      f( (X)self, (int)x, (float)y, (str)z) -> tuple : This is X.f's docstring
-     |      C++ signature:
-     |          class boost::python::tuple f(struct X {lvalue},int,double,char const *)
-     |
-     |    .................
-     |
-FUNCTIONS
-    f(...)
-        f([ (int)x=1 [, (float)y=4.25 [, (str)z='wow']]]) -> tuple : This is f's docstring
-        C++ signature:
-            class boost::python::tuple f([ int=1 [,double=4.25 [,char const *='wow']]])
-
-    f1(...)
-        f1([ (int)x [, (float)y [, (str)z]]]) -> tuple : f1's docstring
-        C++ signature:
-            class boost::python::tuple f1([ int [,double [,char const *]]])
-
-    raw(...)
-        object raw(tuple args, dict kwds) :
-        C++ signature:
-            object raw(tuple args, dict kwds)
-
-
-</pre>
-
-  <p><i>&copy; Copyright <a href="mailto:nickm at sitius dot com">Nikolay Mladenov</a> 2007.</i></p>
-</body>
-</html>

doc/v2/handle.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -329,7 +326,7 @@ null_ok&lt;T&gt;* allow_null(T* p)
     </p>
 
     <p class="c4">&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002
 .</p>
   </body>
 </html>

doc/v2/has_back_reference.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -218,7 +215,7 @@ BOOST_PYTHON_MODULE(back_references)
     </p>
 
     <p class="c3">&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002
 .</p>
   </body>
 </html>

doc/v2/implicit.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -113,7 +110,7 @@ using namespace boost::python;
 struct X
 {
     X(int x) : v(x) {}
-    operator int() const { return v; }
+    operator int() { return v; }
     int v;
 };
 
@@ -157,7 +154,7 @@ BOOST_PYTHON_MODULE(implicit_ext)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/import.html

@@ -1,90 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
-<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 - &lt;boost/python/import.hpp&gt;</title>
-  </head>
-
-  <body>
-    <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">Header &lt;boost/python/import.hpp&gt;</h2>
-        </td>
-      </tr>
-    </table>
-    <hr>
-
-    <h2>Contents</h2>
-
-    <dl class="page-index">
-      <dt><a href="#introduction">Introduction</a></dt>
-
-      <dt><a href="#functions">Functions</a></dt>
-
-      <dd>
-        <dl class="page-index">
-          <dt><a href="#import-spec"><code>import</code></a></dt>
-        </dl>
-      </dd>
-      <dt><a href="#examples">Examples</a></dt>
-    </dl>
-    <hr>
-
-    <h2><a name="introduction"></a>Introduction</h2>
-
-    <p>Exposes a mechanism for importing python modules.</p>
-
-    <h2><a name="functions"></a>Functions</h2>
-
-    <h3><a name="import-spec"></a><code>import</code></h3>
-    <pre>
-object import(str name);
-    </pre>
-    <dl class="function-semantics">
-      <dt><b>Effects:</b> Imports the module named by <code>name</code>.</dt>
-      <dt><b>Returns:</b> An instance of <a href="object.html#object-spec">object</a> 
-       which holds a reference to the imported module.</dt>
-    </dl>
-
-    <h2><a name="examples"></a>Examples</h2>
-
-    <para>The following example demonstrates the use of <function>import</function>
-      to access a function in python, and later call it from within C++.</para>
-
-<pre>
-#include &lt;iostream&gt;
-#include &lt;string&gt;
-
-using namespace boost::python;
-
-void print_python_version()
-{ 
-  // Load the sys module.
-  object sys = import("sys");
-
-  // Extract the python version.
-  std::string version = extract&lt;std::string&gt;(sys.attr("version"));
-  std::cout &lt;&lt; version &lt;&lt; std::endl;
-}
-</pre>
-    <p>Revised 01 November, 2005</p>
-
-    <p><i>&copy; Copyright Stefan Seefeld 2005.</i></p>
-  </body>
-</html>
-

doc/v2/index.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=

doc/v2/indexing.html

@@ -1,7 +1,4 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -69,8 +66,8 @@
       </dt>
       <dt>
         <a href="#vector_indexing_suite_class">vector_indexing_suite
-        class<br>
-        </a><a href="#map_indexing_suite_class">map_indexing_suite class</a> </dt>
+        class</a>
+      </dt>
     </dl>
     <hr>
     <h2>
@@ -144,7 +141,7 @@
 <h3> <a name="indexing_suite"></a>indexing_suite [ Header &lt;boost/python/indexing/indexing_suite.hpp&gt; 
   ]</h3>
     <p>
-      The <tt>indexing_suite</tt> class is the base  class for the
+      The <tt>indexing_suite</tt> class is the base protocol class for the
       management of C++ containers intended to be integrated to Python. The
       objective is make a C++ container look and feel and behave exactly as
       we'd expect a Python container. The class automatically wraps these
@@ -278,7 +275,8 @@
       The <tt>vector_indexing_suite</tt> class is a predefined
       <tt>indexing_suite</tt> derived class designed to wrap
       <tt>std::vector</tt> (and <tt>std::vector</tt> like [i.e. a class with
-      std::vector interface]) classes. It provides all the policies required by the
+      std::vector interface]) classes (currently, this is the only predefined
+      suite available). It provides all the policies required by the
       <tt>indexing_suite</tt>.
   </p>
     <p>
@@ -297,32 +295,22 @@
          <a href="../../test/vector_indexing_suite.cpp">example in full</a>,
          along with its <a href="../../test/vector_indexing_suite.py">python
          test</a>).
-</p>
-    <h3><a name="map_indexing_suite" id="map_indexing_suite"></a>map_indexing_suite [ Header &lt;boost/python/indexing/map_indexing_suite.hpp&gt; ] </h3>
-    <p> The <tt>map_indexing_suite</tt> class is a predefined <tt>indexing_suite</tt> derived class designed to wrap <tt>std::map</tt> (and <tt>std::map</tt> like [i.e. a class with std::map interface]) classes. It provides all the policies required by the <tt>indexing_suite</tt>. </p>
-    <p> Example usage: </p>
-    <pre>
-    class X {...};
-    ...
-
-    class_&lt;std::map&lt;X&gt; &gt;("XMap")
-        .def(map_indexing_suite&lt;std::map&lt;X&gt; &gt;())
-    ;
-</pre>
-    <p> By default indexed elements are returned by proxy. This can be disabled by supplying <tt>true</tt> in the NoProxy template parameter. <tt>XMap</tt> is now a full-fledged Python container (see the <a href="../../test/map_indexing_suite.cpp">example in full</a>, along with its <a href="../../test/map_indexing_suite.py">python test</a>).</p>
+    </p>
     <hr>
     <h2>
-      <a name="indexing_suite_class"></a>indexing_suite class    </h2>
-    <h2>  <tt>indexing_suite&lt;<br>
-    </tt><tt>class Container<br>
+      <a name="indexing_suite_class"></a>indexing_suite class
+    </h2>
+  <h3>
+<br>
+      <tt>indexing_suite&lt;<br>
+      class Container<br>
        , class DerivedPolicies<font color="#007F00"><br>
        </font></tt> <tt>,
-          bool NoProxy<br>
-       ,
-  bool NoSlice<br>
-       </tt><tt>, class Data<br>
-      , class Index<br>
-    </tt><tt>, class Key</tt></h2>
+      bool NoProxy<br>
+       , class Element<br>
+       , class Key<br>
+       , class Index</tt>
+    </h3>
     <table width="100%" border="1">
       <tr>
         <td>
@@ -367,45 +355,36 @@
           
         </td>
       </tr>
-      <tr>
-        <td> <font color="#007F00"><tt>NoProxy</tt></font> </td>
-        <td> A boolean </td>
-        <td> By default indexed elements have Python reference semantics and are returned by proxy. This can be disabled by supplying <strong>true</strong> in the <tt>NoProxy</tt> template parameter. </td>
-        <td> false </td>
-      </tr>
       <tr>
         <td>
-          <font color="#007F00"><tt>NoSlice</tt></font>
+          <font color="#007F00"><tt>NoProxy</tt></font>
         </td>
         <td>
           A boolean
         </td>
         <td>
-          Do not allow slicing. </td>
+          By default indexed elements have Python reference semantics and are
+          returned by proxy. This can be disabled by supplying
+          <strong>true</strong> in the <tt>NoProxy</tt> template parameter.
+        </td>
         <td>
           false
         </td>
       </tr>
       <tr>
         <td>
-          <font color="#007F00"><tt>Data</tt></font>
+          <font color="#007F00"><tt>Element</tt></font>
         </td>
         <td>&nbsp;
           
         </td>
         <td>
-          The container's data type.
+          The container's element type.
         </td>
         <td>
           <tt>Container::value_type</tt>
         </td>
       </tr>
-      <tr>
-        <td> <font color="#007F00"><tt>Index</tt></font> </td>
-        <td>&nbsp; </td>
-        <td> The container's index type. </td>
-        <td> <tt>Container::size_type</tt> </td>
-      </tr>
       <tr>
         <td>
           <font color="#007F00"><tt>Key</tt></font>
@@ -420,14 +399,28 @@
           <tt>Container::value_type</tt>
         </td>
       </tr>
-  </table>
+      <tr>
+        <td>
+          <font color="#007F00"><tt>Index</tt></font>
+        </td>
+        <td>&nbsp;
+          
+        </td>
+        <td>
+          The container's index type.
+        </td>
+        <td>
+          <tt>Container::size_type</tt>
+        </td>
+      </tr>
+    </table>
     <pre>
     template &lt;<br>          class Container
         , class DerivedPolicies
-        , bool NoProxy = false<br>        , bool NoSlice = false
-        , class Data = typename Container::value_type
-        , class Index = typename Container::size_type
+        , bool NoProxy = false
+        , class Element = typename Container::value_type
         , class Key = typename Container::value_type
+        , class Index = typename Container::size_type
     &gt;<br>    class indexing_suite
         : unspecified
     {
@@ -442,22 +435,23 @@
     <dl>
       <dd>
         Derived classes provide the hooks needed by
-        the <tt>indexing_suite:</tt>
+        the<tt>indexing_suite:</tt>
       </dd>
     </dl>
-    <pre>        data_type&amp;
+    <pre>
+        static element_type&amp;
         get_item(Container&amp; container, index_type i);
 
         static object
         get_slice(Container&amp; container, index_type from, index_type to);
 
         static void
-        set_item(Container&amp; container, index_type i, data_type const&amp; v);
+        set_item(Container&amp; container, index_type i, element_type const&amp; v);
 
         static void
         set_slice(
             Container&amp; container, index_type from,
-            index_type to, data_type const&amp; v
+            index_type to, element_type const&amp; v
         );
 
         template &lt;class Iter&gt;
@@ -599,16 +593,16 @@
         </tr>
       </table>
       <pre>
-    template &lt;<br>        class Container,<br>        bool NoProxy = false,<br>        class DerivedPolicies = unspecified_default<br>    class vector_indexing_suite : unspecified_base<br>    {<br>    public:<br><br>        typedef typename Container::value_type data_type;<br>        typedef typename Container::value_type key_type;<br>        typedef typename Container::size_type index_type;<br>        typedef typename Container::size_type size_type;<br>        typedef typename Container::difference_type difference_type;<br>    <br>        data_type&amp;<br>        get_item(Container&amp; container, index_type i);
+    template &lt;<br>        class Container,<br>        bool NoProxy = false,<br>        class DerivedPolicies = unspecified_default<br>    class vector_indexing_suite<br>        : public indexing_suite&lt;Container, DerivedPolicies, NoProxy&gt;<br>    {<br>    public:<br><br>        typedef typename Container::value_type element_type;<br>        typedef typename Container::value_type key_type;<br>        typedef typename Container::size_type index_type;<br>        typedef typename Container::size_type size_type;<br>        typedef typename Container::difference_type difference_type;<br>    <br>        static element_type&amp;<br>        get_item(Container&amp; container, index_type i);
 
         static object
         get_slice(Container&amp; container, index_type from, index_type to);
 
-        static void<br>        set_item(Container&amp; container, index_type i, data_type const&amp; v);
+        static void<br>        set_item(Container&amp; container, index_type i, element_type const&amp; v);
 
         static void
         set_slice(Container&amp; container, index_type from, 
-            index_type to, data_type const&amp; v);
+            index_type to, element_type const&amp; v);
 
         template &lt;class Iter&gt;<br>        static void<br>        set_slice(Container&amp; container, index_type from,<br>            index_type to, Iter first, Iter last);
 
@@ -630,60 +624,7 @@
         adjust_index(index_type current, index_type from, 
             index_type to, size_type len);
     };
-
-</pre>
-      <h2><a name="vector_indexing_suite_class"></a>map_indexing_suite class </h2>
-      <h3> Class template <tt><br>
-  map_indexing_suite&lt;<br>
-  class <font color="#007F00">Container</font><br>
-  , bool <font color="#007F00">NoProxy</font><br>
-  , class <font color="#007F00">DerivedPolicies</font>&gt;</tt> </h3>
-      <table width="100%" border="1">
-        <tr>
-          <td> <strong>Template Parameter</strong><br>
-          </td>
-          <td> <strong>Requirements</strong> </td>
-          <td> <strong>Semantics</strong> </td>
-          <td> <strong>Default</strong> </td>
-        </tr>
-        <tr>
-          <td> <font color="#007F00"><tt>Container</tt></font> </td>
-          <td> A class type </td>
-          <td> The container type to be wrapped to Python. </td>
-          <td>&nbsp; </td>
-        </tr>
-        <tr>
-          <td> <font color="#007F00"><tt>NoProxy</tt></font> </td>
-          <td> A boolean </td>
-          <td> By default indexed elements have Python reference semantics and are returned by proxy. This can be disabled by supplying <strong>true</strong> in the <tt>NoProxy</tt> template parameter. </td>
-          <td> false </td>
-        </tr>
-        <tr>
-          <td> <font color="#007F00"><tt>DerivedPolicies</tt></font> </td>
-          <td> A subclass of indexing_suite </td>
-          <td> The <tt>vector_indexing_suite</tt> may still be derived to further tweak any of the predefined policies. Static polymorphism through CRTP (James Coplien. "Curiously Recurring Template Pattern". C++ Report, Feb. 1995) enables the base <tt>indexing_suite</tt> class to call policy function of the most derived class </td>
-          <td>&nbsp; </td>
-        </tr>
-      </table>
-      <pre>
-    template &lt;<br>        class Container,<br>        bool NoProxy = false,<br>        class DerivedPolicies = unspecified_default<br>    class map_indexing_suite : unspecified_base<br>    {<br>    public:<br><br>        typedef typename Container::value_type value_type;<br>        typedef typename Container::value_type::second_type data_type;<br>        typedef typename Container::key_type key_type;<br>        typedef typename Container::key_type index_type;<br>        typedef typename Container::size_type size_type;<br>        typedef typename Container::difference_type difference_type;<br><br>        static data_type&amp;<br>        get_item(Container&amp; container, index_type i);
-
-        static void<br>        set_item(Container&amp; container, index_type i, data_type const&amp; v);
-
-        static void 
-        delete_item(Container&amp; container, index_type i);<br>     
-        static size_t
-        size(Container&amp; container);
-     
-        static bool
-        contains(Container&amp; container, key_type const&amp; key);
-     
-        static bool<br>        compare_index(Container&amp; container, index_type a, index_type b);
-<br>        static index_type
-        convert_index(Container&amp; container, PyObject* i);
-    };
-
-</pre>
+      </pre>
       <hr>
       &copy; Copyright Joel de Guzman 2003. Permission to copy, use, modify,
       sell and distribute this document is granted provided this copyright

doc/v2/init.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -245,7 +242,7 @@ class_&lt;X&gt;("X", "This is X's docstring.",
      
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/instance_holder.html

@@ -1,9 +1,6 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content="HTML Tidy, see www.w3.org">
@@ -213,7 +210,7 @@ struct pointer_holder : instance_holder
 
 
     <p class="c4">&copy; Copyright <a href= 
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002. 
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. 
 
   </body>
 </html>

doc/v2/iterator.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -392,7 +389,7 @@ BOOST_PYTHON_MODULE(demo)
         </p>
 
         <p><i>&copy; Copyright <a href=
-        "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+        "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/list.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -136,7 +133,7 @@ long zeroes(list l)
     <p>Revised 1 October, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/long.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -113,7 +110,7 @@ python::long_ fact(long n)
     <p>Revised 1 October, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/lvalue_from_pytype.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -295,7 +292,7 @@ BOOST_PYTHON_MODULE(noddy_cache)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/make_function.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -96,10 +93,10 @@ template &lt;class F, class Policies, class Keywords, class Signature&gt;
       to <code>f</code>. <ul>
 <li>        If <code>policies</code> are supplied, it
       will be applied to the function as described <a href=
-      "CallPolicies.html">here</a>.
+      "CallPolicies.html">here</a>. 
 <li>If <code>keywords</code> are
       supplied, the keywords will be applied in order to the final
-      arguments of the resulting function.
+      arguments of the resulting function.  
 <li>If <code>Signature</code>
       is supplied, it should be an instance of an <a
       href="../../../mpl/doc/refmanual/front-extensible-sequence.html">MPL front-extensible
@@ -125,33 +122,36 @@ template &lt;class F, class Policies, class Keywords, class Signature&gt;
     </dl>
 
 <pre>
-<a name="make_constructor-spec">template &lt;class F&gt;</a>
-<a href="object.html#object-spec">object</a> make_constructor(F f)
-
-template &lt;class F, class Policies&gt;
+<a name=
+"make_constructor-spec"></a>template &lt;class T, class ArgList, class Generator&gt;
+<a href="object.html#object-spec">object</a> make_constructor();
+ 
+template &lt;class ArgList, class Generator, class Policies&gt;
 <a href=
-"object.html#object-spec">object</a> make_constructor(F f, Policies const&amp; policies)
-
-template &lt;class F, class Policies, class KeywordsOrSignature&gt;
-<a href=
-"object.html#object-spec">object</a> make_constructor(F f, Policies const&amp; policies, KeywordsOrSignature const&amp; ks)
-
-template &lt;class F, class Policies, class Keywords, class Signature&gt;
-<a href=
-"object.html#object-spec">object</a> make_constructor(F f, Policies const&amp; policies, Keywords const&amp; kw, Signature const&amp; sig)
+"object.html#object-spec">object</a> make_constructor(Policies const&amp; policies)
 </pre>
 
     <dl class="function-semantics">
-      <dt><b>Requires:</b> <code>F</code> is a
-      function pointer type. If <code>policies</code> are supplied, it must
-      be a model of <a href="CallPolicies.html">CallPolicies</a>. If
-      <code>kewords</code> are supplied, it must be the result of a <a href=
-      "args.html#keyword-expression"><em>keyword-expression</em></a>
-      specifying no more arguments than the <a href=
-      "definitions.html#arity">arity</a> of <code>f</code>.</dt>
+      <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/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
+      Generator::apply&lt;T&gt;::type(a1,&nbsp;a2</code>...&nbsp;<code>aN</code>)
+      is valid. Generator is a model of <a href=
+      "HolderGenerator.html">HolderGenerator</a>.</dt>
 
       <dt><b>Effects:</b> Creates a Python callable object which, when called
-      from Python, converts its arguments to C++ and calls <code>f</code>.</dt>
+      from Python, expects its first argument to be a Boost.Python extension
+      class object. It converts its remaining its arguments to C++ and passes
+      them to the constructor of a dynamically-allocated
+      <code>Generator::apply&lt;T&gt;::type</code> object, which is then
+      installed in the extension class object. In the second form, the
+      <code>policies</code> are applied to the arguments and result (<a href=
+      "http://www.python.org/doc/current/lib/bltin-null-object.html">None</a>)
+      of the Python callable object</dt>
 
       <dt><b>Returns:</b> An instance of <a href=
       "object.html#object-spec">object</a> which holds the new Python
@@ -183,7 +183,7 @@ BOOST_PYTHON_MODULE(make_function_test)
     def("choose_function", choose_function);
 }
 </pre>
-    It can be used this way in Python:
+    It can be used this way in Python: 
 <pre>
 &gt;&gt;&gt; from make_function_test import *
 &gt;&gt;&gt; f = choose_function(1)
@@ -201,7 +201,7 @@ BOOST_PYTHON_MODULE(make_function_test)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/manage_new_object.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -139,7 +136,7 @@ BOOST_PYTHON_MODULE(my_module)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/module.html

@@ -103,8 +103,6 @@ RuntimeError: Unidentifiable C++ Exception
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
-    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. </i> Distributed
-  under the Boost Software License, Version 1.0. (See accompanying file
-  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)</p>
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. </i>
 

doc/v2/numeric.html

@@ -1,105 +1,102 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 
 <html>
-<head>
-  <meta name="generator" content=
-  "HTML Tidy for Linux/x86 (vers 1 September 2005), see www.w3.org">
-  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
-  <link rel="stylesheet" type="text/css" href="../boost.css">
+  <head>
+    <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">
 
-  <title>Boost.Python - &lt;boost/python/numeric.hpp&gt;</title>
-</head>
+    <title>Boost.Python - &lt;boost/python/numeric.hpp&gt;</title>
+  </head>
 
-<body>
-  <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>
+    <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">Header &lt;boost/python/numeric.hpp&gt;</h2>
-      </td>
-    </tr>
-  </table>
-  <hr>
+          <h2 align="center">Header &lt;boost/python/numeric.hpp&gt;</h2>
+        </td>
+      </tr>
+    </table>
+    <hr>
 
-  <h2>Contents</h2>
+    <h2>Contents</h2>
 
-  <dl class="page-index">
-    <dt><a href="#introduction">Introduction</a></dt>
+    <dl class="page-index">
+      <dt><a href="#introduction">Introduction</a></dt>
 
-    <dt><a href="#classes">Classes</a></dt>
+      <dt><a href="#classes">Classes</a></dt>
 
-    <dd>
-      <dl class="page-index">
-        <dt><a href="#array-spec">Class <code>array</code></a></dt>
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#array-spec">Class <code>array</code></a></dt>
 
-        <dd>
-          <dl class="page-index">
-            <dt><a href="#array-spec-synopsis">Class <code>array</code>
-            synopsis</a></dt>
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#array-spec-synopsis">Class <code>array</code>
+              synopsis</a></dt>
 
-            <dt><a href="#array-spec-observers">Class <code>array</code>
-            observer functions</a></dt>
+              <dt><a href="#array-spec-observers">Class <code>array</code>
+              observer functions</a></dt>
 
-            <dt><a href="#array-spec-statics">Class <code>array</code> static
-            functions</a></dt>
-          </dl>
-        </dd>
-      </dl>
-    </dd>
+              <dt><a href="#array-spec-statics">Class <code>array</code>
+              static functions</a></dt>
+            </dl>
+          </dd>
+        </dl>
+      </dd>
 
-    <dt><a href="#examples">Example(s)</a></dt>
-  </dl>
-  <hr>
+      <dt><a href="#examples">Example(s)</a></dt>
+    </dl>
+    <hr>
 
-  <h2><a name="introduction" id="introduction"></a>Introduction</h2>
+    <h2><a name="introduction"></a>Introduction</h2>
 
-  <p>Exposes a <a href=
-  "ObjectWrapper.html#TypeWrapper-concept">TypeWrapper</a> for the Python
-  <a href=
-  "http://www.python.org/dev/doc/devel/lib/typesmapping.html">array</a>
-  type.</p>
+    <p>Exposes a <a href=
+    "ObjectWrapper.html#TypeWrapper-concept">TypeWrapper</a> for the Python
+    <a href=
+    "http://www.python.org/dev/doc/devel/lib/typesmapping.html">array</a>
+    type.</p>
 
-  <h2><a name="classes" id="classes"></a>Classes</h2>
+    <h2><a name="classes"></a>Classes</h2>
 
-  <h3><a name="array-spec" id="array-spec"></a>Class <code>array</code></h3>
+    <h3><a name="array-spec"></a>Class <code>array</code></h3>
 
-  <p>Provides access to the array types of <a href=
-  "http://www.pfdubois.com/numpy/">Numerical Python</a>'s <a href=
-  "http://www.pfdubois.com/numpy/#Numeric">Numeric</a> and <a href=
-  "http://stsdas.stsci.edu/numarray/index.html">NumArray</a> modules. With
-  the exception of the functions documented <a href=
-  "#array-spec-observers">below</a>, the semantics of the constructors and
-  member functions defined below can be fully understood by reading the
-  <a href="ObjectWrapper.html#TypeWrapper-concept">TypeWrapper</a> concept
-  definition. Since <code>array</code> is publicly derived from
-  <code><a href="object.html#object-spec">object</a></code>, the public
-  object interface applies to <code>array</code> instances as well.</p>
+    <p>Provides access to the array types of <a href=
+    "http://www.pfdubois.com/numpy/">Numerical Python</a>'s <a href=
+    "http://www.pfdubois.com/numpy/#Numeric">Numeric</a> and <a href=
+    "http://stsdas.stsci.edu/numarray/index.html">NumArray</a> modules. With
+    the exception of the functions documented <a href=
+    "#array-spec-observers">below</a>, the semantics of the constructors and
+    member functions defined below can be fully understood by reading the <a
+    href="ObjectWrapper.html#TypeWrapper-concept">TypeWrapper</a> concept
+    definition. Since <code>array</code> is publicly derived from <code><a
+    href="object.html#object-spec">object</a></code>, the public object
+    interface applies to <code>array</code> instances as well.</p>
 
-  <p><a name="default_search" id="default_search"></a>The default behavior is
-  to use <code>numarray.NDArray</code> as the associated Python type if the
-  <code>numarray</code> module is installed in the default location.
-  Otherwise it falls back to use <code>Numeric.ArrayType</code>. If neither
-  extension module is installed, overloads of wrapped C++ functions with
-  <code>numeric::array</code> parameters will never be matched, and other
-  attempted uses of <code>numeric::array</code> will <a href=
-  "definitions.html#raise">raise</a> an appropriate Python exception. The
-  associated Python type can be set manually using the <code><a href=
-  "#array-spec-statics">set_module_and_type</a>(...)</code> static
-  function.</p>
+    <p><a name="default_search"></a>The default behavior is to use
+    <code>numarray.NDArray</code> as the associated Python type if the
+    <code>numarray</code> module is installed in the default location.
+    Otherwise it falls back to use <code>Numeric.ArrayType</code>. If neither
+    extension module is installed, conversions to arguments of type
+    <code>numeric::array</code> will cause overload resolution to reject the
+    overload, and other attempted uses of <code>numeric::array</code> will <a
+    href="definitions.html#raise">raise</a> an appropriate Python exception.
+    The associated Python type can be set manually using the <code><a href=
+    "#array-spec-statics">set_module_and_type</a>(...)</code> static
+    function.</p>
 
-  <h4><a name="array-spec-synopsis" id="array-spec-synopsis"></a>Class
-  <code>array</code> synopsis</h4>
-  <pre>
+    <h4><a name="array-spec-synopsis"></a>Class <code>array</code>
+    synopsis</h4>
+<pre>
 namespace boost { namespace python { namespace numeric
 {
    class array : public object
@@ -110,7 +107,7 @@ namespace boost { namespace python { namespace numeric
       object astype(Type const&amp; type_);
 
       template &lt;class Type&gt;
-      array new_(Type const&amp; type_) const;
+      object new_(Type const&amp; type_) const;
 
       template &lt;class Sequence&gt; 
       void resize(Sequence const&amp; x);
@@ -136,14 +133,14 @@ namespace boost { namespace python { namespace numeric
       void tofile(File const&amp; f) const;
 
       object factory();
-      template &lt;class Sequence&gt;
-      object factory(Sequence const&amp;);
-      template &lt;class Sequence, class Typecode&gt;
-      object factory(Sequence const&amp;, Typecode const&amp;, bool copy = true, bool savespace = false);
-      template &lt;class Sequence, class Typecode, class Type&gt;
-      object factory(Sequence const&amp;, Typecode const&amp;, bool copy, bool savespace, Type const&amp;);
-      template &lt;class Sequence, class Typecode, class Type, class Shape&gt;
-      object factory(Sequence const&amp;, Typecode const&amp;, bool copy, bool savespace, Type const&amp;, Shape const&amp;);
+      template &lt;class Buffer&gt;
+      object factory(Buffer const&amp;);
+      template &lt;class Buffer, class Type&gt;
+      object factory(Buffer const&amp;, Type const&amp;);
+      template &lt;class Buffer, class Type, class Shape&gt;
+      object factory(Buffer const&amp;, Type const&amp;, Shape const&amp;, bool copy = true, bool savespace = false);
+      template &lt;class Buffer, class Type, class Shape&gt;
+      object factory(Buffer const&amp;, Type const&amp;, Shape const&amp;, bool copy, bool savespace, char typecode);
 
       template &lt;class T1&gt;
       explicit array(T1 const&amp; x1);
@@ -155,7 +152,6 @@ namespace boost { namespace python { namespace numeric
 
       static void set_module_and_type();
       static void set_module_and_type(char const* package_path = 0, char const* type_name = 0);
-      static void get_module_name();
 
       object argmax(long axis=-1);
 
@@ -204,60 +200,54 @@ namespace boost { namespace python { namespace numeric
 }}}
 </pre>
 
-  <h4><a name="array-spec-observers" id="array-spec-observers"></a>Class
-  <code>array</code> observer functions</h4>
-  <pre>
+    <h4><a name="array-spec-observers"></a>Class <code>array</code> observer
+    functions</h4>
+<pre>
 object factory();
-template &lt;class Sequence&gt;
-object factory(Sequence const&amp;);
-template &lt;class Sequence, class Typecode&gt;
-object factory(Sequence const&amp;, Typecode const&amp;, bool copy = true, bool savespace = false);
-template &lt;class Sequence, class Typecode, class Type&gt;
-object factory(Sequence const&amp;, Typecode const&amp;, bool copy, bool savespace, Type const&amp;);
-template &lt;class Sequence, class Typecode, class Type, class Shape&gt;
-object factory(Sequence const&amp;, Typecode const&amp;, bool copy, bool savespace, Type const&amp;, Shape const&amp;);
-</pre>These functions map to the underlying array type's <code>array()</code>
-function family. They are not called "<code>array</code>" because of the C++
-limitation that you can't define a member function with the same name as its
-enclosing class.
-  <pre>
+template &lt;class Buffer&gt;
+object factory(Buffer const&amp;);
+template &lt;class Buffer, class Type&gt;
+object factory(Buffer const&amp;, Type const&amp;);
+template &lt;class Buffer, class Type, class Shape&gt;
+object factory(Buffer const&amp;, Type const&amp;, Shape const&amp;, bool copy = true, bool savespace = false);
+template &lt;class Buffer, class Type, class Shape&gt;
+object factory(Buffer const&amp;, Type const&amp;, Shape const&amp;, bool copy, bool savespace, char typecode);
+</pre>
+    These functions map to the underlying array type's <code>array()</code>
+    function family. They are not called "<code>array</code>" because of the
+    C++ limitation that you can't define a member function with the same name
+    as its enclosing class. 
+<pre>
 template &lt;class Type&gt;
-array new_(Type const&amp;) const;
-</pre>This function maps to the underlying array type's <code>new()</code>
-function. It is not called "<code>new</code>" because that is a keyword in
-C++.
+object new_(Type const&amp;) const;
+</pre>
+    This function maps to the underlying array type's <code>new()</code>
+    function. It is not called "<code>new</code>" because that is a keyword
+    in C++. 
 
-  <h4><a name="array-spec-statics" id="array-spec-statics"></a>Class
-  <code>array</code> static functions</h4>
-  <pre>
+    <h4><a name="array-spec-statics"></a>Class <code>array</code> static
+    functions</h4>
+<pre>
 static void set_module_and_type(char const* package_path, char const* type_name);
 static void set_module_and_type();
 </pre>
 
-  <dl class="function-semantics">
-    <dt><b>Requires:</b> <code>package_path</code> and
-    <code>type_name</code>, if supplied, is an <a href=
-    "definitions.html#ntbs">ntbs</a>.</dt>
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>package_path</code> and
+      <code>type_name</code>, if supplied, is an <a href=
+      "definitions.html#ntbs">ntbs</a>.</dt>
 
-    <dt><b>Effects:</b> The first form sets the package path of the module
-    that supplies the type named by <code>type_name</code> to
-    <code>package_path</code>. The second form restores the <a href=
-    "#default_search">default search behavior</a>. The associated Python type
-    will be searched for only the first time it is needed, and thereafter the
-    first time it is needed after an invocation of
-    <code>set_module_and_type</code>.</dt>
-  </dl>
-  <pre>
-static std::string get_module_name()
-</pre>
+      <dt><b>Effects:</b> The first form sets the package path of the module
+      which supplies the type named by <code>type_name</code> to
+      <code>package_path</code>. The second form restores the <a href=
+      "#default_search">default search behavior</a>. The associated Python
+      type will be searched for only the first time it is needed, and
+      thereafter the first time it is needed after an invocation of
+      <code>set_module_and_type</code>.</dt>
+    </dl>
 
-  <dl class="function-semantics">
-    <dt><b>Effects:</b> Returns the name of the module containing the class
-    that will be held by new <code>numeric::array</code> instances.</dt>
-  </dl>
-
-  <h2><a name="examples" id="examples"></a>Example</h2>
-  <pre>
+    <h2><a name="examples"></a>Example</h2>
+<pre>
 #include &lt;boost/python/numeric.hpp&gt;
 #include &lt;boost/python/tuple.hpp&gt;
 
@@ -268,9 +258,10 @@ void set_first_element(numeric::array&amp; y, double value)
 }
 </pre>
 
-  <p>Revised 07 October, 2006</p>
+    <p>Revised 03 October, 2002</p>
 
-  <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
-  Abrahams</a> 2002-2006.</i></p>
-</body>
+    <p><i>&copy; Copyright <a href=
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+  </body>
 </html>
+

doc/v2/object.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -74,32 +71,6 @@
             </dl>
           </dd>
 
-          <dt><a href="#const_objattribute_policies-spec">Class
-          <code>const_objattribute_policies</code></a></dt>
-
-          <dd>
-            <dl class="page-index">
-              <dt><a href="#const_objattribute_policies-spec-synopsis">Class
-              <code>const_objattribute_policies</code> synopsis</a></dt>
-
-              <dt><a href="#const_objattribute_policies-spec-statics">Class
-              <code>const_objattribute_policies</code> static functions</a></dt>
-            </dl>
-          </dd>
-
-          <dt><a href="#objattribute_policies-spec">Class
-          <code>objattribute_policies</code></a></dt>
-
-          <dd>
-            <dl class="page-index">
-              <dt><a href="#objattribute_policies-spec-synopsis">Class
-              <code>objattribute_policies</code> synopsis</a></dt>
-
-              <dt><a href="#objattribute_policies-spec-statics">Class
-              <code>objattribute_policies</code> static functions</a></dt>
-            </dl>
-          </dd>
-
           <dt><a href="#const_item_policies-spec">Class
           <code>const_item_policies</code></a></dt>
 
@@ -212,16 +183,11 @@
           <dt><a href="#binary-spec">binary operations</a></dt>
 
           <dt><a href="#assignment-spec">assignment operations</a></dt>
-
         </dl>
 
         <dl class="page-index">
           <dt><a href="#object_operators-spec">operators</a></dt>
         </dl>
-
-        <dl class="page-index">
-          <dt><a href="#len-spec">len()</a></dt>
-        </dl>
       </dd>
 
       <dt><a href="#examples">Example</a></dt>
@@ -354,102 +320,6 @@ static void del(object const&amp;target, char const* key);
     <!-- end -->
     <!-- begin -->
 
-    <h3><a name="const_objattribute_policies-spec"></a>Class
-    <code>const_objattribute_policies</code></h3>
-
-    <p>The policies which are used for proxies representing an attribute
-    access to a <code>const&nbsp;object</code> when the attribute name is
-    given as a <code>const&nbsp;object</code>.</p>
-
-    <h4><a name="const_objattribute_policies-spec-synopsis"></a>Class
-    <code>const_objattribute_policies</code> synopsis</h4>
-<pre>
-namespace boost { namespace python { namespace api
-{
-  struct const_objattribute_policies
-  {
-      typedef object const& key_type;
-      static object get(object const&amp; target, object const& key);
-  };
-}}}
-</pre>
-
-    <h4><a name="const_objattribute_policies-spec-statics"></a>Class
-    <code>const_objattribute_policies</code> static functions</h4>
-<pre>
-static object get(object const&amp; target, object const& key);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> <code>key</code> is an <code>object</code>
-      holding a string.</dt>
-
-      <dt><b>Effects:</b> accesses the attribute of <code>target</code> named
-      by <code>key</code>.</dt>
-
-      <dt><b>Returns:</b> An <code>object</code> managing the result of the
-      attribute access.</dt>
-
-      <dt><b>Throws:</b> <code><a href=
-      "errors.html#error_already_set-spec">error_already_set</a></code> if a
-      Python exception is raised.</dt>
-    </dl>
-
-    <h3><a name="objattribute_policies-spec"></a>Class
-    <code>objattribute_policies</code></h3>
-
-    <p>The policies which are used for proxies representing an attribute
-    access to a mutable <code>object</code> when the attribute name is
-    given as a <code>const&nbsp;object</code>.</p>
-
-    <h4><a name="objattribute_policies-spec-synopsis"></a>Class
-    <code>objattribute_policies</code> synopsis</h4>
-<pre>
-namespace boost { namespace python { namespace api
-{
-  struct objattribute_policies : const_objattribute_policies
-  {
-      static object const&amp; set(object const&amp; target, object const& key, object const&amp; value);
-      static void del(object const&amp;target, object const& key);
-  };
-}}}
-</pre>
-
-    <h4><a name="objattribute_policies-spec-statics"></a>Class
-    <code>objattribute_policies</code> static functions</h4>
-<pre>
-static object const&amp; set(object const&amp; target, object const& key, object const&amp; value);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> <code>key</code> is an <code>object</code>
-      holding a string.</dt>
-
-      <dt><b>Effects:</b> sets the attribute of <code>target</code> named by
-      <code>key</code> to <code>value</code>.</dt>
-
-      <dt><b>Throws:</b> <code><a href=
-      "errors.html#error_already_set-spec">error_already_set</a></code> if a
-      Python exception is raised.</dt>
-    </dl>
-<pre>
-static void del(object const&amp;target, object const& key);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> <code>key</code> is an <code>object</code>
-      holding a string.</dt>
-
-      <dt><b>Effects:</b> deletes the attribute of <code>target</code> named
-      by <code>key</code>.</dt>
-
-      <dt><b>Throws:</b> <code><a href=
-      "errors.html#error_already_set-spec">error_already_set</a></code> if a
-      Python exception is raised.</dt>
-    </dl>
-    <!-- end -->
-    <!-- begin -->
-
     <h3><a name="const_item_policies-spec"></a>Class
     <code>const_item_policies</code></h3>
 
@@ -655,11 +525,6 @@ namespace boost { namespace python { namespace api
       template &lt;class A0, class A1,...class An&gt;
       object operator()(A0 const&amp;, A1 const&amp;,...An const&amp;) const;
 
-      detail::args_proxy operator* () const; 
-      object operator()(detail::args_proxy const &amp;args) const; 
-      object operator()(detail::args_proxy const &amp;args, 
-                        detail::kwds_proxy const &amp;kwds) const; 
-
       // truth value testing
       //
       typedef unspecified bool_type;
@@ -669,8 +534,6 @@ namespace boost { namespace python { namespace api
       //
       proxy&lt;const_object_attribute&gt; attr(char const*) const;
       proxy&lt;object_attribute&gt; attr(char const*);
-      proxy&lt;const_object_objattribute&gt; attr(object const&) const;
-      proxy&lt;object_objattribute&gt; attr(object const&);
 
       // item access
       //
@@ -709,25 +572,6 @@ object operator()(A0 const&amp; a1, A1 const&amp; a2,...An const&amp; aN) const;
       call&lt;object&gt;(object(*static_cast&lt;U*&gt;(this)).ptr(), a1,
       a2,...aN)</dt>
     </dl>
-
-<pre>
-object operator()(detail::args_proxy const &amp;args) const; 
-</pre>
-<dl class="function-semantics">
-  <dt><b>Effects:</b>
-  call object with arguments given by the tuple <varname>args</varname></dt>
-</dl>
-<pre>
-object operator()(detail::args_proxy const &amp;args, 
-                  detail::kwds_proxy const &amp;kwds) const; 
-</pre>
-<dl class="function-semantics">
-  <dt><b>Effects:</b>
-  call object with arguments given by the tuple <varname>args</varname>, and named
-  arguments given by the dictionary <varname>kwds</varname></dt>
-</dl>
-
-
 <pre>
 operator bool_type() const;
 </pre>
@@ -756,21 +600,6 @@ proxy&lt;object_attribute&gt; attr(char const* name);
       <code>name</code> as its key.</dt>
     </dl>
 <pre>
-proxy&lt;const_object_objattribute&gt; attr(const object& name) const;
-proxy&lt;object_objattribute&gt; attr(const object& name);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> name is a <code>object</code> holding a string.</dt>
-
-      <dt><b>Effects:</b> accesses the named attribute of
-      <code>*this</code>.</dt>
-
-      <dt><b>Returns:</b> a proxy object which binds
-      <code>object(*static_cast&lt;U*&gt;(this))</code> as its target, and
-      <code>name</code> as its key.</dt>
-    </dl>
-<pre>
 template &lt;class T&gt;
 proxy&lt;const_object_item&gt; operator[](T const&amp; key) const;
 template &lt;class T&gt;
@@ -835,8 +664,6 @@ namespace boost { namespace python { namespace api
       object&amp; operator=(object const&amp;); 
 
       PyObject* ptr() const;
-
-      bool is_none() const;
   };
 }}}
 </pre>
@@ -897,14 +724,6 @@ PyObject* ptr() const;
       <dt><b>Returns:</b> a pointer to the internally-held Python
       object.</dt>
     </dl>
-
-<pre>
-bool is_none() const;
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Returns:</b> result of (ptr() == Py_None)</dt>
-    </dl>
     <!-- -->
 
     <h3><a name="proxy-spec"></a>Class template <code>proxy</code></h3>
@@ -1027,12 +846,12 @@ void del(proxy&lt;T&gt; const&amp; x);
     </dl>
 <pre>
 <a name="comparisons-spec"></a>
-template&lt;class L,class R&gt; object operator&gt;(L const&amp;l,R const&amp;r);
-template&lt;class L,class R&gt; object operator&gt;=(L const&amp;l,R const&amp;r);
-template&lt;class L,class R&gt; object operator&lt;(L const&amp;l,R const&amp;r);
-template&lt;class L,class R&gt; object operator&lt;=(L const&amp;l,R const&amp;r);
-template&lt;class L,class R&gt; object operator==(L const&amp;l,R const&amp;r);
-template&lt;class L,class R&gt; object operator!=(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; bool operator&gt;(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; bool operator&gt;=(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; bool operator&lt;(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; bool operator&lt;=(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; bool operator==(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; bool operator!=(L const&amp;l,R const&amp;r);
 </pre>
 
     <dl class="function-semantics">
@@ -1081,16 +900,7 @@ template&lt;class R&gt; object&amp; operator|=(object&amp;l,R const&amp;r);
       <dt><b>Returns:</b> <code>l</code>.</dt>
     </dl>
 
-<pre>
-inline long len(object const&amp; obj);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Effects:</b> PyObject_Length(obj.ptr()) </dt>
-      <dt><b>Returns:</b> len() of object.</dt>
-    </dl>
-
-<h2><a name="examples"></a>Example</h2>
+    <h2><a name="examples"></a>Example</h2>
     Python code: 
 <pre>
 def sum_items(seq):
@@ -1104,18 +914,20 @@ def sum_items(seq):
 object sum_items(object seq)
 {
    object result = object(0);
-   for (int i = 0; i &lt; len(seq); ++i)
+   for (int i = 0; i &lt; seq.attr("__len__")(); ++i)
       result += seq[i];
    return result;
 }
 </pre>
+
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  15 March, 2010
+  13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2008.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
+

doc/v2/opaque.html

@@ -1,138 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<!-- Copyright 2003..2006 Haufe Mediengruppe. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
-
-<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 - &lt;boost/python/opaque_pointer_converter.hpp&gt;</title>
-  </head>
-
-  <body>
-    <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">Header
-          &lt;boost/python/opaque_pointer_converter.hpp&gt;</h2>
-        </td>
-      </tr>
-    </table>
-    <hr>
-
-    <h2>Contents</h2>
-
-    <dl class="page-index">
-      <dt><a href="#classes">Classes</a></dt>
-
-      <dd>
-        <dl class="page-index">
-          <dt><a href="#opaque-spec">Class template
-          <code>opaque&lt;Pointee&gt;</code></a></dt>
-
-          <dd>
-            <dl class="page-index">
-              <dt><a href="#opaque-spec-synopsis">Class template
-              <code>opaque</code> synopsis</a></dt>
-            </dl>
-          </dd>
-        </dl>
-      </dd>
-
-      <dt><a href="#macros">Macros</a></dt>
-      <dd>
-        <dl class="page-index">
-          <dt><a href="#BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID-spec">Macro
-          <code>BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID</code></a></dt>
-        </dl>
-      </dd>
-
-      <dt><a href="#see-also">See Also</a></dt>
-    </dl>
-    <hr>
-
-    <h2><a name="classes"></a>Classes</h2>
-
-    <h3><a name="opaque-spec"></a>Class template
-    <code>opaque&lt;P&gt;</code></h3>
-
-    <p><code>opaque&lt;&gt;</code> registers itself as a converter from
-      Python objects to pointers to undefined types and vice versa.</p>
-
-    <h4><a name="opaque-spec-synopsis"></a>Class template
-    <code>opaque</code> synopsis</h4>
-<pre>
-namespace boost { namespace python
-{
-    template&lt;class Pointee&gt;
-    struct opaque
-    {
-        opaque();
-    };
-}}
-</pre>
-
-    <h4><a name="opaque-spec-constructor"></a>Class template
-    <code>opaque</code> constructor</h4>
-<pre>
-opaque();
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Effects:</b>
-    <ul>
-        <li>Registers the instance as a 
-        <a href="lvalue_from_pytype.html#lvalue_from_pytype-spec"> <code>lvalue_from_pytype</code></a>
-        converter from Python objects into opaque pointers.</p>
-        <p>The Python Objects created are named after the type pointed to
-          by the opaque pointer being wrapped.</p></li>
-        <li>Registers the instance as a 
-          <a href="to_python_converter.html#to_python_converter-spec"> <code>to_python_converter</code></a>
-        from opaque pointers to Python objects.</p></li>
-    </ul>
-    <p>If there is already an instance registered by another module, this
-      instance doesn't try to register again in order to avoid warnings
-      about multiple registrations.</p>
-
-    <h4>Note</h4>
-    <p>Normally only a single instance of this class is created for every
-      Pointee.</p>
-    </dt>
-    </dl>
-
-    <h2><a name="macros"></a>Macros</h2>
-
-    <h3><a name="BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID-spec"></a>
-      Macro BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID(Pointee)</h3>
-    <p>This macro must be used to define specializations of the 
-      <a href="type_id.html#type_id-spec">type_id</a> function
-      which can't be instantiated for incomplete types.</p>
-    <h4>Note</h4>
-    <p>The macro must be invoked in every translation unit which uses the
-      opaque converter.</p>
-
-    <h2><a name="see-also"></a>See Also</h2>
-        <p>
-          <a href="return_opaque_pointer.html">return_opaque_pointer</a>
-        </p>
-
-    <p>Revised 
-  10 September, 2006
-    </p>
-
-    <p><i>&copy; Copyright 2003..2006 Haufe Mediengruppe. All Rights
-    Reserved.</i></p>
-  </body>
-</html>
-

doc/v2/opaque_pointer_converter.html

@@ -0,0 +1,142 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<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 - &lt;boost/python/opaque_pointer_converter.hpp&gt;</title>
+  </head>
+
+  <body>
+    <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">Header
+          &lt;boost/python/opaque_pointer_converter.hpp&gt;</h2>
+        </td>
+      </tr>
+    </table>
+    <hr>
+
+    <h2>Contents</h2>
+
+    <dl class="page-index">
+      <dt><a href="#classes">Classes</a></dt>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#opaque_pointer_converter-spec">Class template
+          <code>opaque_pointer_converter&lt;P&gt;</code></a></dt>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#opaque_pointer_converter-spec-synopsis">Class template
+              <code>opaque_pointer_converter</code> synopsis</a></dt>
+            </dl>
+          </dd>
+        </dl>
+      </dd>
+
+      <dt><a href="#macros">Macros</a></dt>
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID-spec">Macro
+          <code>BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID</code></a></dt>
+        </dl>
+      </dd>
+
+      <dt><a href="#examples">Example</a></dt>
+
+      <dt><a href="#see-also">See Also</a></dt>
+    </dl>
+    <hr>
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="opaque_pointer_converter-spec"></a>Class template
+    <code>opaque_pointer_converter&lt;P&gt;</code></h3>
+
+    <p><code>opaque_pointer_converter&lt;&gt;</code> is derived from 
+          <a href="to_python_converter.html#to_python_converter-spec">
+            <code>to_python_converter</code></a>
+          and registers itself as an
+          <a href="lvalue_from_pytype.html#lvalue_from_pytype-spec">
+            <code>lvalue_from_pytype</code></a> converter from Python objects
+          into pointers to undefined types.
+            Thus it may be used as a converter from opaque pointers into
+          Python objects and vice versa.</p>
+
+    <h4><a name="opaque_pointer_converter-spec-synopsis"></a>Class template
+    <code>opaque_pointer_converter</code> synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+    template&lt;class Pointer&gt;
+    struct opaque_pointer_converter
+        : to_python_converter&lt;
+          Pointer, opaque_pointer_converter&lt;Pointer&gt; &gt;
+    {
+        explicit opaque_pointer_converter(char const* name);
+    };
+}}
+</pre>
+
+    <h4><a name="opaque_pointer_converter-spec-constructor"></a>Class template
+    <code>opaque_pointer_converter</code> constructor</h4>
+<pre>
+explicit opaque_pointer_converter(char const* name);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Effects:</b>
+            <p>Registers the instance as a 
+            <a href="lvalue_from_pytype.html#lvalue_from_pytype-spec">
+              <code>lvalue_from_pytype</code></a> converter from Python objects
+            into opaque pointers.</p>
+            <p>The name is used for the type of the Python Objects created;
+              it should be printable but needn't be an 
+              <a href="definitions.html#ntbs">ntbs</a> because the object type is
+              not supposed to be user constructible within python scripts.</p>
+          </dt>
+    </dl>
+
+    <h2><a name="macros"></a>Macros</h2>
+
+    <h3><a name="BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID-spec"></a>
+      Macro BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID(Pointee)</h3>
+    <p>This macro must be used to define specializations of the 
+      <a href="type_id.html#type_id-spec">type_id</a> function
+      which can't be instantiated for incomplete types.</p>
+    <h4>Note</h4>
+    <p>In order for this to work in a cross-module environment the macro must
+      be invoked in every translation unit which uses the
+      opaque_pointer_converter.</p>
+
+    <h2><a name="examples"></a>Example</h2>
+
+        please see example for <a href="return_opaque_pointer.html#examples">
+          return_opaque_pointer</a>.
+
+    <h2><a name="see-also"></a>See Also</h2>
+        <p>
+          <a href="return_opaque_pointer.html">return_opaque_pointer</a>
+        </p>
+
+    <p>Revised 
+  10 March, 2003
+    </p>
+
+    <p><i>&copy; Copyright 2003 Haufe Mediengruppe. All Rights
+    Reserved.</i></p>
+  </body>
+</html>
+

doc/v2/operators.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -214,9 +211,6 @@ namespace boost { namespace python { namespace self_ns {
    <a href=
 "#operator_-spec">operator_</a>&lt;<i>unspecified</i>&gt; str(self_t);
 
-   <a href=
-"#operator_-spec">operator_</a>&lt;<i>unspecified</i>&gt; repr(self_t);
-
 }}};
 </pre>
     The tables below describe the methods generated when the results of the
@@ -768,15 +762,6 @@ namespace boost { namespace python { namespace self_ns {
         <td><code><a href=
         "../../../conversion/lexical_cast.htm#lexical_cast">lexical_cast</a>&lt;std::string&gt;(x)</code></td>
       </tr>
-
-      <tr>
-        <td><code>repr</code></td>
-
-        <td><code>__repr__</code></td>
-
-        <td><code><a href=
-        "../../../conversion/lexical_cast.htm#lexical_cast">lexical_cast</a>&lt;std::string&gt;(x)</code></td>
-      </tr>
     </table>
 
     <h3><a name="other-spec"></a>Class Template <code>other</code></h3>
@@ -915,7 +900,7 @@ BOOST_PYTHON_MODULE(demo)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/overloads.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -223,7 +220,7 @@ BOOST_PYTHON_MODULE(args_ext)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>