Release 1.47.0 beta 1

[SVN r72708]

build/Jamfile

@@ -1,95 +0,0 @@
-#  (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
-      ;
-
-  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,87 +1,151 @@
+# 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 ;
 
-# Use a very crude way to sense there python is locatted
+import python ;
 
-
-local PYTHON_PATH = [ modules.peek : PYTHON_PATH ] ;
-
-if [ GLOB /usr/local/include/python2.2 : * ]
+if ! [ python.configured ] && ! ( --without-python in  [ modules.peek : ARGV ] )
 {
-    PYTHON_PATH = /usr/local ;
-}
-else if [ GLOB /usr/include/python2.2 : * ] 
-{
-    PYTHON_PATH = /usr ;
+    # Attempt default configuration of python
+    import toolset : using ;
+    using python ;
 }
 
-if [ os.name ] in CYGWIN NT
+if [ python.configured ] || ( --without-python in  [ modules.peek : ARGV ] )
 {
-    lib_condition = <link>shared: ;
-    defines = USE_DL_IMPORT ;
-   
-    # Declare a target for the python interpreter library
-    lib python : : <name>python22 <search>$(PYTHON_PATH)/libs ;
-    PYTHON_LIB = python ;    
-} 
-else 
+    alias config-warning ;
+}
+else
 {
-   lib python : : <name>python2.2 ;
-   PYTHON_LIB = python ;    
+    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) ;
+}
 
-
-if $(PYTHON_PATH) {
-    
+py3-version = [ find-py3-version ] ;
 
 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
+  : source-location ../src
+  : requirements
+    -<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
+    <tag>@$(__name__).tag
+  ;
 
-# 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
-
-    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
-    :   <link>static:<define>BOOST_PYTHON_STATIC_LIB 
-        <define>BOOST_PYTHON_SOURCE
-    : <link>shared
-      ;
+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 ;
 }

build/VisualStudio/boost_python.dsp

@@ -1,882 +0,0 @@
-# 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\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
-# 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

@@ -1,29 +0,0 @@
-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

@@ -0,0 +1,28 @@
+// 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

@@ -0,0 +1,23 @@
+# 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.txt

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

doc/PyConDC_2003/bpl_mods.txt

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

doc/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,3 +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)
+*/
 H1
 {
     FONT-SIZE: 200%

doc/building.rst

@@ -0,0 +1,680 @@
+.. 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,11 +1,14 @@
 <!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</title>
   </head>
@@ -24,10 +27,60 @@
 
           <h2 align="center">Index</h2>
         </td>
+
+
+        <td align="right">
+
+          <form method="get" action="http://www.google.com/custom">
+            <p>
+              <span id= "search-choice">
+                Search
+                <select name="hq" id="hq">
+                  <option label="All Documentation" value=
+                          "site:www.boost.org inurl:www.boost.org/libs/python/doc">
+                    All Documentation
+                  </option>
+                  <option label="Tutorial" value=
+                          "site:www.boost.org inurl:www.boost.org/libs/python/doc/tutorial">
+                    Tutorial
+                  </option>
+                  <option label="Reference" value=
+                          "site:www.boost.org inurl:www.boost.org/libs/python/doc/v2">
+                    Reference
+                  </option>
+              </select>
+                <br>
+             </span> 
+
+              <span id="search-text">
+                <input type="text" name="q" id="q" size="31" maxlength="255" alt="Search Text" />
+              </span> 
+
+              <br>
+              <span id= "google">
+                <a href= "http://www.google.com/search"> 
+                  <img src="../../../more/google_logo_25wht.gif" alt="Google" border="0" /></a>Powered
+              </span> 
+
+              <span id="go">
+                <input type="image" name="search" src="../../../more/space.gif" alt="Search" id="search-button" />
+              </span> 
+
+              <br>
+              <input type="hidden" name="cof" value= "LW:277;L:http://www.boost.org/boost.png;LH:86;AH:center;GL:0;S:http://www.boost.org;AWFID:9b83d16ce652ed5a;" />
+              <input type="hidden" name="sa" value= "Google Search" /> 
+              <input type="hidden" name= "domains" value= "www.boost.org;mail.python.org" /></p>
+          </form>
+
+        </td>
+      </tr>
+<tr>
+
       </tr>
     </table>
     <hr>
 
+
     <h2>Synopsis</h2>
     Welcome to version 2 of <b>Boost.Python</b>, a C++ library which enables
     seamless interoperability between C++ and the <a href=
@@ -94,7 +147,9 @@
 
       <dt><a href="v2/faq.html">Frequently Asked Questions (FAQs)</a></dt>
       
-      <dt><a href="../pyste/index.html">Pyste (Boost.Python code generator)</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="internals.html">Internals Documentation</a></dt>
 
@@ -122,8 +177,8 @@
     <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
-    <p><i>&copy; Copyright <a href="../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002-2003. All Rights Reserved.</i></p>
+    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002-2003.</i></p>
   </body>
 </html>
 

doc/new-conversions.html

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

doc/new-conversions.txt

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

doc/news.html

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

doc/polymorphism.txt

@@ -1,3 +1,8 @@
+.. 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,390 +1,466 @@
 <!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 April 2002), see www.w3.org">
-    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-    <link rel="stylesheet" type="text/css" href="boost.css">
-
-    <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/index.htm">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 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/dev_simba.phtml">Simba</a></b>
-        provides 3D visualization of geological formations gattered from the
-        simulation of the evolution of oil systems, allowing the user to
-        analyse various aspects of the simulation, like deformation, pressure
-        and fluids, along the time of the simulation.</p>
-
-        <p><b><a href="http://www.esss.com.br/dev_aero.phtml">Aero</a></b>
-        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>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. All Rights Reserved.</i></p>
-  </body>
+<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://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 -->
+   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>
 </html>
-

doc/support.html

@@ -1,5 +1,8 @@
 <!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=
@@ -64,7 +67,7 @@
      12 Sept, 2003 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
-    <p><i>&copy; Copyright <a href="../../../people/dave_abrahams.htm">Dave
+    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
     Abrahams</a> 2003.</i></p>
   </body>
 </html>

doc/tutorial/doc/Jamfile.v2

@@ -1,5 +1,18 @@
+# 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 ;
 
-boostbook tutorial : tutorial.xml
+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
     ;

doc/tutorial/doc/catalog.xml

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

doc/tutorial/doc/html/HTML.manifest

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

doc/tutorial/doc/html/boostbook.css

@@ -1,295 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2002 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)
-=============================================================================*/
-
-/* CSS based on w3c documentation which I like a lot, and the classic Spirit
-documentation. */
-
-/* Body defaults */
-body 
-{
-    padding: 2em 1em 2em 1em;
-    margin: 1em 1em 1em 1em;
-    font-family: sans-serif;
-}
-
-/* Paragraphs */
-p 
-{
-    text-align: justify;
-}
-
-pre.synopsis
-{
-    margin: 1pc 4% 0pc 4%;
-    padding: 0.5pc 0.5pc 0.5pc 0.5pc;
-}
-
-/* Headings */
-h1, h2, h3, h4, h5, h6 { text-align: left; margin-top: 2pc; }
-h1 { font: 170% sans-serif }
-h2 { font: bold 140% sans-serif }
-h3 { font: 120% sans-serif }
-h4 { font: bold 100% sans-serif }
-h5 { font: italic 100% sans-serif }
-h6 { font: italic 100% sans-serif }
-
-/* Unordered lists */
-ul 
-{
-    text-align: justify;
-}
-
-/* Links */
-a
-{
-    text-decoration: none; /* no underline */
-}
-
-a:hover
-{
-    text-decoration: underline;
-}
-
-/* Top page title */
-title, h1.title, h2.title, h3.title,
-       h4.title, h5.title, h6.title,
-       .refentrytitle
-{
-    font-weight:   bold;
-    font-size:     2pc;
-    margin-bottom: 1pc;
-}
-
-/* Spirit style navigation */
-.spirit-nav
-{
-    text-align: right;
-}
-
-.spirit-nav a
-{
-    color: white;
-    padding-left: 0.5em;
-}
-
-.spirit-nav img
-{
-    border-width: 0px;
-}
-
-/* Program listing box */
-.programlisting, .screen
-{
-    display: block;
-    margin-left:  4%;
-    margin-right: 4%;
-    padding: 0.5pc 0.5pc 0.5pc 0.5pc;
-}
-
-/* Table of contents */
-.toc
-{
-   margin: 1pc 4% 0pc 4%;
-   padding: 0.5pc 0.5pc 0.5pc 0.5pc;
-}
-
-.boost-toc
-{
-   float:   right;
-   padding: 0.5pc;
-}
-
-/* Tables */
-.table-title, div.table p.title
-{
-    margin-left: 4%;
-    padding-right: 0.5em; 
-    padding-left: 0.5em;
-    font-size: 120%;
-}
-
-.informaltable table, .table table
-{
-    width: 92%;
-    margin-left: 4%;
-    margin-right: 4%;
-}
-
-div.informaltable table, div.table table
-{
-    padding: 4px 4px 4px 4px;
-}
-
-div.informaltable table tr td, div.table table tr td
-{
-    padding: 0.5em 0.5em 0.5em 0.5em;
-    text-align: justify;
-}
-
-div.informaltable table tr th, div.table table tr th
-{
-    padding: 0.5em 0.5em 0.5em 0.5em;
-    border: 1pt solid white;
-}
-
-/* inlined images */
-.inlinemediaobject
-{
-    padding: 0.5em 0.5em 0.5em 0.5em;
-}
-
-/* tone down the title of Parameter lists */
-div.variablelist p.title
-{
-    font-weight: bold;
-    font-size: 100%;
-    text-align: left;
-}
-
-/* tabularize parameter lists */
-div.variablelist dl dt
-{
-    float: left;
-    clear: left;
-    display: block;
-    font-style: italic;
-}
-
-div.variablelist dl dd
-{
-    display: block;
-    clear:   right;
-    padding-left: 8pc;
-}
-
-/* title of books and articles in bibliographies */
-span.title
-{
-    font-style: italic;
-}
-
-
-@media screen
-{
-    a
-    {
-        color: #005a9c;
-    }
-
-    a:visited
-    {
-        color: #9c5a9c;
-    }
-
-    /* Syntax Highlighting */
-    .keyword        { color: #0000AA; font-weight: bold; }
-    .identifier     {}
-    .special        { color: #707070; }
-    .preprocessor   { color: #402080; font-weight: bold; }
-    .char           { color: teal; }
-    .comment        { color: #800000; }
-    .string         { color: teal; }
-    .number         { color: teal; }
-    .copyright      { color: #666666; font-size: small; }
-    .white_bkd      { background-color: #FFFFFF; }
-    .dk_grey_bkd    { background-color: #999999; }
-
-    pre.synopsis
-    {
-        background-color: #f3f3f3;
-    }
-
-    .programlisting, .screen
-    {
-        background-color: #f3f3f3;
-    }
-
-    /* Table of contents */
-    .toc
-    {
-        background-color: #f3f3f3;
-    }
-
-    div.informaltable table tr td, div.table table tr td
-    {
-        background-color: #F3F3F3;
-        border: 1pt solid white;
-    }
-
-    div.informaltable table tr th, div.table table tr th
-    {
-        background-color: #e4e4e4;
-    }
-
-    span.highlight
-    {
-        color: #00A000;
-    }
-}
-
-@media print
-{
-    a
-    {
-        color: black;
-    }
-
-    a:visited
-    {
-        color: black;
-    }
-
-    .spirit-nav
-    {
-        display: none;
-    }
-
-    /* Syntax Highlighting */
-    .keyword
-    {
-        font-weight: bold;
-    }
-
-    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;
-    }
-
-    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;
-    }
-
-    span.highlight
-    {
-        font-weight: bold;
-    }
-}

doc/tutorial/doc/html/index.html

@@ -1,46 +1,43 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Chapter 1. python 1.0</title>
-<link rel="stylesheet" href="boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
-<link rel="home" href="index.html" title="Chapter 1. python 1.0">
-<link rel="next" href="python/hello.html" title=" Building Hello World">
+<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.75.2">
+<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">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../boost.png"></td>
-<td align="center"><a href="../../index.htm">Home</a></td>
-<td align="center"><a href="libraries.html">Libraries</a></td>
-<td align="center"><a href="../../people/people.htm">People</a></td>
-<td align="center"><a href="../../more/faq.htm">FAQ</a></td>
-<td align="center"><a href="../../more/index.htm">More</a></td>
-</table>
+<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>
+<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="../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
-<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="images/next.png" alt="Next"></a></div>
-<div class="chapter" lang="en">
-<div class="titlepage">
-<div>
+<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a></div>
+<div class="chapter">
+<div class="titlepage"><div>
 <div><h2 class="title">
-<a name="python"></a>Chapter 1. python 1.0</h2></div>
+<a name="python"></a>Chapter&#160;1.&#160;python 2.0</h2></div>
 <div><div class="author"><h3 class="author">
 <span class="firstname">Joel</span> <span class="surname">de Guzman</span>
 </h3></div></div>
 <div><div class="author"><h3 class="author">
 <span class="firstname">David</span> <span class="surname">Abrahams</span>
 </h3></div></div>
-<div><p class="copyright">Copyright © 2002-2004 Joel de Guzman, David Abrahams</p></div>
-<div><div class="legalnotice"><p>
-        Distributed under the Boost Software License, Version 1.0.
-        (See accompanying file LICENSE_1_0.txt or copy at
-        <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
-            http://www.boost.org/LICENSE_1_0.txt
-        </a>)
-    
-      </p></div></div>
-</div>
-<div></div>
-</div>
+<div><p class="copyright">Copyright &#169; 2002-2005 Joel
+      de Guzman, David Abrahams</p></div>
+<div><div class="legalnotice">
+<a name="id759709"></a><p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
+        http://www.boost.org/LICENSE_1_0.txt </a>)
+      </p>
+</div></div>
+</div></div>
 <div class="toc">
 <p><b>Table of Contents</b></p>
 <dl>
@@ -53,7 +50,6 @@
 <dt><span class="section"><a href="python/exposing.html#python.class_properties">Class Properties</a></span></dt>
 <dt><span class="section"><a href="python/exposing.html#python.inheritance">Inheritance</a></span></dt>
 <dt><span class="section"><a href="python/exposing.html#python.class_virtual_functions">Class Virtual Functions</a></span></dt>
-<dt><span class="section"><a href="python/exposing.html#python.deriving_a_python_class">Deriving a Python Class</a></span></dt>
 <dt><span class="section"><a href="python/exposing.html#python.virtual_functions_with_default_implementations">Virtual Functions with Default Implementations</a></span></dt>
 <dt><span class="section"><a href="python/exposing.html#python.class_operators_special_functions">Class Operators/Special Functions</a></span></dt>
 </dl></dd>
@@ -83,55 +79,67 @@
 </dl></dd>
 </dl>
 </div>
-<div class="section" lang="en">
-<div class="titlepage">
-<div><div><h2 class="title" style="clear: both">
-<a name="python.quickstart"></a>QuickStart</h2></div></div>
-<div></div>
-</div>
+<div class="section">
+<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>
-<a name="quickstart.hello_world"></a><h2>
-<a name="id344076"></a>Hello World</h2>
+      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><h3>
+<a name="id759740"></a>
+      Hello World
+    </h3>
 <p>
-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>
+      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>
 <p>
-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">
+      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>
 
-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>
+<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>
 <p>
-That's it. We're done. We can now build this as a shared library. The
-resulting DLL is now visible to Python. Here's a sample Python session:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> import</span><span class="identifier"> hello</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> print</span><span class="identifier"> hello</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span><span class="identifier">
-hello</span><span class="special">,</span><span class="identifier"> world</span></tt></pre>
-<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>
+      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"><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>
+<p>
+    </p>
+<div class="blockquote"><blockquote class="blockquote"><p>
+        <span class="emphasis"><em><span class="bold"><strong>Next stop... Building your Hello World module
+        from start to finish...</strong></span></em></span>
+      </p></blockquote></div>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><small><p>Last revised: October 12, 2004 at 03:11:11 GMT</p></small></td>
-<td align="right"><small></small></td>
+<td align="left"><p><small>Last revised: July 01, 2010 at 21:56:58 GMT</small></p></td>
+<td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>
-<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a></div>
 </body>
 </html>

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

@@ -1,347 +1,271 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Embedding</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
-<link rel="home" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="previous" href="object.html" title=" Object Interface">
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../index.html" title="Chapter&#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="next" href="iterators.html" title="Iterators">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../boost.png"></td>
-<td align="center"><a href="../../../index.htm">Home</a></td>
-<td align="center"><a href="../libraries.html">Libraries</a></td>
-<td align="center"><a href="../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../more/faq.htm">FAQ</a></td>
-<td align="center"><a href="../../../more/index.htm">More</a></td>
-</table>
+<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>
+<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="../../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="object.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage">
-<div><div><h2 class="title" style="clear: both">
-<a name="python.embedding"></a>Embedding</h2></div></div>
-<div></div>
+<a accesskey="p" href="object.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
+<div class="section">
+<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"></span></p>
-<a name="embedding.building_embedded_programs"></a><h2>
-<a name="id428755"></a>Building embedded programs</h2>
+      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>
+<a name="embedding.building_embedded_programs"></a><h3>
+<a name="id773307"></a>
+      Building embedded programs
+    </h3>
 <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>
+      To be able to embed python into your programs, you have to link to both Boost.Python's
+      as well as Python's own runtime library.
+    </p>
 <p>
-Boost.Python's static link library comes in two variants. Both are located
-in Boost's <tt class="literal">/libs/python/build/bin-stage</tt> subdirectory. On Windows, the
-variants are called <tt class="literal">boost_python.lib</tt> (for release builds) and
-<tt class="literal">boost_python_debug.lib</tt> (for debugging). If you can't find the libraries,
-you probably haven't built Boost.Python yet. See <a href="../../../../building.html%20Building" target="_top">and Testing</a> on how to do this.</p>
+      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>
 <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>
+      Python's library can be found in the <code class="literal">/libs</code> subdirectory
+      of your Python directory. On Windows it is called pythonXY.lib where X.Y is
+      your major Python version number.
+    </p>
 <p>
-Additionally, Python's <tt class="literal">/include</tt> subdirectory has to be added to your
-include path.</p>
+      Additionally, Python's <code class="literal">/include</code> subdirectory has to be added
+      to your include path.
+    </p>
 <p>
-In a Jamfile, all the above boils down to:</p>
-<pre class="programlisting"><tt class="literal">    projectroot c:\projects\embedded_program ; # location of the program
+      In a Jamfile, all the above boils down to:
+    </p>
+<pre class="programlisting">projectroot c:\projects\embedded_program ; # location of the program
 
-    # bring in the rules for python
-    SEARCH on python.jam = $(BOOST_BUILD_PATH) ;
-    include python.jam ;
+# bring in the rules for python
+SEARCH on python.jam = $(BOOST_BUILD_PATH) ;
+include python.jam ;
 
-    exe embedded_program # name of the executable
-      : #sources
-         embedded_program.cpp
-      : # requirements
-         &lt;find-library&gt;boost_python &lt;library-path&gt;c:\boost\libs\python
-      $(PYTHON_PROPERTIES)
-        &lt;library-path&gt;$(PYTHON_LIB_PATH)
-        &lt;find-library&gt;$(PYTHON_EMBEDDED_LIBRARY) ;
-</tt></pre>
-<a name="embedding.getting_started"></a><h2>
-<a name="id428846"></a>Getting started</h2>
+exe embedded_program # name of the executable
+  : #sources
+     embedded_program.cpp
+  : # requirements
+     &lt;find-library&gt;boost_python &lt;library-path&gt;c:\boost\libs\python
+  $(PYTHON_PROPERTIES)
+    &lt;library-path&gt;$(PYTHON_LIB_PATH)
+    &lt;find-library&gt;$(PYTHON_EMBEDDED_LIBRARY) ;
+</pre>
+<a name="embedding.getting_started"></a><h3>
+<a name="id773391"></a>
+      Getting started
+    </h3>
 <p>
-Being able to build is nice, but there is nothing to build yet. Embedding
-the Python interpreter into one of your C++ programs requires these 4
-steps:</p>
-<div class="orderedlist"><ol type="1">
-<li>
-#include <tt class="literal">&lt;boost/python.hpp&gt;</tt><p></p>
-<p></p>
-</li>
-<li>
-Call <a href="http://www.python.org/doc/current/api/initialization.html#l2h-652" target="_top">Py_Initialize</a>() to start the interpreter and create the <tt class="literal"><span class="underline">_main</span>_</tt> module.<p></p>
-<p></p>
-</li>
-<li>
-Call other Python C API routines to use the interpreter.<p></p>
-<p></p>
-</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>
+      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"><span class="underline">_main</span>_</code>
+          module.
+        </li>
+<li class="listitem">
+          Call other Python C API routines to use the interpreter.
+        </li>
 </ol></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"><b>Now that we can embed the interpreter in our programs, lets see how to put it to use...</b></span></em></span></p></blockquote></div>
-<div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.using_the_interpreter"></a>Using the interpreter</h3></div></div>
-<div></div>
-</div>
-<p>
-As you probably already know, objects in Python are reference-counted.
-Naturally, the <tt class="literal">PyObject</tt>s of the Python/C API are also reference-counted.
-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="id428977"></a>Reference-counting handles and objects</h2>
-<p>
-There are two ways in which a function in the Python/C API can return a
-<tt class="literal">PyObject*</tt>: as a <span class="emphasis"><em>borrowed reference</em></span> or as a <span class="emphasis"><em>new reference</em></span>. Which of
-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>
-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">
-
-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>
-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>
-<span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>Handle is a class <span class="emphasis"><em>template</em></span>, so why haven't we been using any template parameters?</b></span><p></p>
-<p></p>
-<tt class="literal">handle</tt> has a single template parameter specifying the type of the managed object. This type is <tt class="literal">PyObject</tt> 99% of the time, so the parameter was defaulted to <tt class="literal">PyObject</tt> for convenience. Therefore we can use the shorthand <tt class="literal">handle&lt;&gt;</tt> instead of the longer, but equivalent, <tt class="literal">handle&lt;PyObject&gt;</tt>.
-</td></tr></tbody>
+<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>
-<a name="using_the_interpreter.running_python_code"></a><h2>
-<a name="id429281"></a>Running Python code</h2>
 <p>
-To run Python code from C++ there is a family of functions in the API
-starting with the PyRun prefix. You can find the full list of these
-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>
+      (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">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.using_the_interpreter"></a>Using the interpreter</h3></div></div></div>
 <p>
-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="id429442"></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>
+        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>
+<a name="using_the_interpreter.running_python_code"></a><h3>
+<a name="id773549"></a>
+        Running Python code
+      </h3>
 <p>
-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>
+        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>
 <p>
-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>
+        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>
-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">
+        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"><span class="underline">_main</span>_</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"><span class="underline">_main</span>_</code>
+        module and run some Python code in its namespace:
+      </p>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
+<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>
 
-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>
+<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>
 <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>
+        This should create a file called 'hello.txt' in the current directory containing
+        a phrase that is well-known in programming circles.
+      </p>
+<a name="using_the_interpreter.manipulating_python_objects"></a><h3>
+<a name="id774064"></a>
+        Manipulating Python objects
+      </h3>
 <p>
-This should create a file called 'hello.txt' in the current directory
-containing a phrase that is well-known in programming circles.</p>
-<p><span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>Note</b></span> that we wrap the return value of <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a> in a
-(nameless) <tt class="literal">handle</tt> even though we are not interested in it. If we didn't
-do this, the the returned object would be kept alive unnecessarily. Unless
-you want to be a Dr. Frankenstein, always wrap <tt class="literal">PyObject*</tt>s in <tt class="literal">handle</tt>s.</p>
-<a name="using_the_interpreter.beyond_handles"></a><h2>
-<a name="id429881"></a>Beyond handles</h2>
+        Often we'd like to have a class to manipulate Python objects. But we have
+        already seen such a class above, and in the <a href="object.html" target="_top">previous
+        section</a>: the aptly named <code class="literal">object</code> class and its
+        derivatives. We've already seen that they can be constructed from a <code class="literal">handle</code>.
+        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>
 <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>
+        Here we create a dictionary object for the <code class="literal"><span class="underline">_main</span>_</code>
+        module's namespace. Then we assign 5 squared to the result variable and read
+        this variable from the dictionary. Another way to achieve the same result
+        is to use eval instead, which returns the result directly:
+      </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>
+<a name="using_the_interpreter.exception_handling"></a><h3>
+<a name="id774390"></a>
+        Exception handling
+      </h3>
 <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>
-<p><span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>Note</b></span> that <tt class="literal">object</tt>'s member function to return the wrapped
-<tt class="literal">PyObject*</tt> is called <tt class="literal">ptr</tt> instead of <tt class="literal">get</tt>. This makes sense if you
-take into account the different functions that <tt class="literal">object</tt> and <tt class="literal">handle</tt>
-perform.</p>
-<a name="using_the_interpreter.exception_handling"></a><h2>
-<a name="id430451"></a>Exception handling</h2>
+        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>
 <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>
+        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>
 <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>
+        (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>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2004 Joel de Guzman, David Abrahams</small></td>
+<td align="right"><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>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="object.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="object.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

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

@@ -1,57 +1,63 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Exception Translation</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
-<link rel="home" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="previous" href="iterators.html" title="Iterators">
-<link rel="next" href="techniques.html" title=" General Techniques">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Exception Translation</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<link rel="prev" href="iterators.html" title="Iterators">
+<link rel="next" href="techniques.html" title="General Techniques">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../boost.png"></td>
-<td align="center"><a href="../../../index.htm">Home</a></td>
-<td align="center"><a href="../libraries.html">Libraries</a></td>
-<td align="center"><a href="../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../more/faq.htm">FAQ</a></td>
-<td align="center"><a href="../../../more/index.htm">More</a></td>
-</table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="iterators.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="techniques.html"><img src="../images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage">
-<div><div><h2 class="title" style="clear: both">
-<a name="python.exception"></a> Exception Translation</h2></div></div>
-<div></div>
-</div>
-<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"><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"><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"><small>Copyright © 2002-2004 Joel de Guzman, David Abrahams</small></td>
+<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>
+<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="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="iterators.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="techniques.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="iterators.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="techniques.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="python.exception"></a> Exception Translation</h2></div></div></div>
+<p>
+      All C++ exceptions must be caught at the boundary with Python code. This boundary
+      is the point where C++ meets Python. Boost.Python provides a 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>
+<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>
+</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>
+</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>
 </div>
 </body>
 </html>

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

@@ -1,233 +1,195 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Building Hello World</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
-<link rel="home" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="previous" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="next" href="exposing.html" title=" Exposing Classes">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Building Hello World</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../index.html" title="Chapter&#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">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../boost.png"></td>
-<td align="center"><a href="../../../index.htm">Home</a></td>
-<td align="center"><a href="../libraries.html">Libraries</a></td>
-<td align="center"><a href="../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../more/faq.htm">FAQ</a></td>
-<td align="center"><a href="../../../more/index.htm">More</a></td>
-</table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="../index.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage">
-<div><div><h2 class="title" style="clear: both">
-<a name="python.hello"></a> Building Hello World</h2></div></div>
-<div></div>
-</div>
-<a name="hello.from_start_to_finish"></a><h2>
-<a name="id343708"></a>From Start To Finish</h2>
-<p>
-Now the first thing you'd want to do is to build the Hello World module and
-try it for yourself in Python. In this section, we shall outline the steps
-necessary to achieve that. We shall use the build tool that comes bundled
-with every boost distribution: <span class="bold"><b>bjam</b></span>.</p>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td>
-<span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>Building without bjam</b></span><p></p>
-<p></p>
-
-    Besides bjam, there are of course other ways to get your module built.
-    What's written here should not be taken as "the one and only way".
-    There are of course other build tools apart from <tt class="literal">bjam</tt>.<p></p>
-<p></p>
-
-    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 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>
-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>
-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>
-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>
-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="id343869"></a>Let's Jam!</h2>
-<p><span class="inlinemediaobject"><img src="../images/jam.png"></span></p>
-<p>
-Here is our minimalist Jamfile:</p>
-<pre class="programlisting"><tt class="literal">    subproject libs/python/example/tutorial ;
-
-    SEARCH on python.jam = $(BOOST_BUILD_PATH) ;
-    include python.jam ;
-
-    extension hello                     # Declare a Python extension called hello
-    :   hello.cpp                       # source
-        &lt;dll&gt;../../build/boost_python   # dependencies
-        ;
-</tt></pre>
-<p>
-First, we need to specify our location in the boost project hierarchy.
-It so happens that the tutorial example is located in <tt class="literal">/libs/python/example/tutorial</tt>.
-Thus:</p>
-<pre class="programlisting"><tt class="literal">    subproject libs/python/example/tutorial ;
-</tt></pre>
-<p>
-Then we will include the definitions needed by Python modules:</p>
-<pre class="programlisting"><tt class="literal">    SEARCH on python.jam = $(BOOST_BUILD_PATH) ;
-    include python.jam ;
-</tt></pre>
-<p>
-Finally we declare our <tt class="literal">hello</tt> extension:</p>
-<pre class="programlisting"><tt class="literal">    extension hello                     # Declare a Python extension called hello
-    :   hello.cpp                       # source
-        &lt;dll&gt;../../build/boost_python   # dependencies
-        ;
-</tt></pre>
-<a name="hello.running_bjam"></a><h2>
-<a name="id343964"></a>Running bjam</h2>
-<p><span class="emphasis"><em>bjam</em></span> is run using your operating system's command line interpreter.</p>
-<div class="blockquote"><blockquote class="blockquote"><p>Start it up.</p></blockquote></div>
-<p>
-Make sure that the environment is set so that we can invoke the C++
-compiler. With MSVC, that would mean running the <tt class="literal">Vcvars32.bat</tt> batch
-file. For instance:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">C</span><span class="special">:\</span><span class="identifier">Program</span><span class="identifier"> Files</span><span class="special">\</span><span class="identifier">Microsoft</span><span class="identifier"> Visual</span><span class="identifier"> Studio</span><span class="special">\</span><span class="identifier">VC98</span><span class="special">\</span><span class="identifier">bin</span><span class="special">\</span><span class="identifier">Vcvars32</span><span class="special">.</span><span class="identifier">bat</span></tt></pre>
-<p>
-Some environment variables will have to be setup for proper building of our
-Python modules. Example:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">set</span><span class="identifier"> PYTHON_ROOT</span><span class="special">=</span><span class="identifier">c</span><span class="special">:/</span><span class="identifier">dev</span><span class="special">/</span><span class="identifier">tools</span><span class="special">/</span><span class="identifier">python</span><span class="identifier">
-set</span><span class="identifier"> PYTHON_VERSION</span><span class="special">=</span><span class="number">2.2</span></tt></pre>
-<p>
-The above assumes that the Python installation is in <tt class="literal">c:/dev/tools/python</tt>
-and that we are using Python version 2.2. You'll have to tweak this path
-appropriately.</p>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td>
-<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>
-Now we are ready... Be sure to <tt class="literal">cd</tt> to <tt class="literal">libs/python/example/tutorial</tt>
-where the tutorial <tt class="literal">"hello.cpp"</tt> and the <tt class="literal">"Jamfile"</tt> is situated.</p>
-<p>
-Finally:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">bjam</span><span class="special"> -</span><span class="identifier">sTOOLS</span><span class="special">=</span><span class="identifier">msvc</span></tt></pre>
-<p>
-We are again assuming that we are using Microsoft Visual C++ version 6. If
-not, then you will have to specify the appropriate tool. See
-<a href="../../../../../../../tools/build/index.html" target="_top">Building Boost Libraries</a> for
-further details.</p>
-<p>
-It should be building now:</p>
-<pre class="programlisting"><tt class="literal">    cd C:\dev\boost\libs\python\example\tutorial
-    bjam -sTOOLS=msvc
-    ...patience...
-    ...found 1703 targets...
-    ...updating 40 targets...
-</tt></pre>
-<p>
-And so on... Finally:</p>
-<pre class="programlisting"><tt class="literal">    vc-C++ ........\libs\python\example\tutorial\bin\hello.pyd\msvc\debug\
-    runtime-link-dynamic\hello.obj
-    hello.cpp
-    vc-Link ........\libs\python\example\tutorial\bin\hello.pyd\msvc\debug\
-    runtime-link-dynamic\hello.pyd ........\libs\python\example\tutorial\bin\
-    hello.pyd\msvc\debug\runtime-link-dynamic\hello.lib
-       Creating library ........\libs\python\example\tutorial\bin\hello.pyd\
-       msvc\debug\runtime-link-dynamic\hello.lib and object ........\libs\python\
-       example\tutorial\bin\hello.pyd\msvc\debug\runtime-link-dynamic\hello.exp
-    ...updated 40 targets...
-</tt></pre>
-<p>
-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> can be found somewhere in <tt class="literal">libs\python\build\bin</tt>
-while <tt class="literal">hello.pyd</tt> can be found somewhere in
-<tt class="literal">libs\python\example\tutorial\bin</tt>. After a successful build, you can just
-link in these DLLs with the Python interpreter. In Windows for example, you
-can simply put these libraries inside the directory where the Python
-executable is.</p>
-<p>
-You may now fire up Python and run our hello module:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> import</span><span class="identifier"> hello</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> print</span><span class="identifier"> hello</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span><span class="identifier">
-hello</span><span class="special">,</span><span class="identifier"> world</span></tt></pre>
-<div class="blockquote"><blockquote class="blockquote"><p><span class="bold"><b>There you go... Have fun!</b></span></p></blockquote></div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><small>Copyright © 2002-2004 Joel de Guzman, David Abrahams</small></td>
+<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>
+<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="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../index.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="../index.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="python.hello"></a> Building Hello World</h2></div></div></div>
+<a name="hello.from_start_to_finish"></a><h3>
+<a name="id760024"></a>
+      From Start To Finish
+    </h3>
+<p>
+      Now the first thing you'd want to do is to build the Hello World module and
+      try it for yourself in Python. In this section, we will outline the steps necessary
+      to achieve that. We will use the build tool that comes bundled with every boost
+      distribution: <span class="bold"><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>
+</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>
+</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>
+<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>
+<a name="hello.let_s_jam_"></a><h3>
+<a name="id760177"></a>
+      Let's Jam!
+    </h3>
+<p>
+      <span class="inlinemediaobject"><img src="../images/jam.png" alt="jam"></span>
+    </p>
+<p>
+      <a href="../../../../../example/tutorial/Jamroot" target="_top">Here</a> is our minimalist
+      Jamroot file. Simply copy the file and tweak <code class="literal">use-project boost</code>
+      to where your boost root directory is and your OK.
+    </p>
+<p>
+      The comments contained in the Jamrules file above should be sufficient to get
+      you going.
+    </p>
+<a name="hello.running_bjam"></a><h3>
+<a name="id760225"></a>
+      Running bjam
+    </h3>
+<p>
+      <span class="emphasis"><em>bjam</em></span> is run using your operating system's command line
+      interpreter.
+    </p>
+<div class="blockquote"><blockquote class="blockquote"><p>
+        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 ;
+
+#  Python configuration
+using python : 2.4 : C:/dev/tools<span class="emphasis"><em>Python</em></span> ;
+</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:/dev/tools/Python/</code>.
+      If you have one fairly "standard" python installation for your platform,
+      you might not need to do this.
+    </p>
+<p>
+      Now we are ready... Be sure to <code class="literal">cd</code> to <code class="literal">libs/python/example/tutorial</code>
+      where the tutorial <code class="literal">"hello.cpp"</code> and the <code class="literal">"Jamroot"</code>
+      is situated.
+    </p>
+<p>
+      Finally:
+    </p>
+<pre class="programlisting"><span class="identifier">bjam</span>
+</pre>
+<p>
+      It should be building now:
+    </p>
+<pre class="programlisting">cd C:\dev\boost\libs\python\example\tutorial
+bjam
+...patience...
+...found 1101 targets...
+...updating 35 targets...
+</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 <span class="emphasis"><em>path-to-'''hello_ext'''.exp</em></span>
+**passed** ... hello.test
+...updated 35 targets...
+</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>
+</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>
+</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>
 </div>
 </body>
 </html>

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

@@ -1,131 +1,199 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Iterators</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
-<link rel="home" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="previous" href="embedding.html" title="Embedding">
-<link rel="next" href="exception.html" title=" Exception Translation">
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<link rel="prev" href="embedding.html" title="Embedding">
+<link rel="next" href="exception.html" title="Exception Translation">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../boost.png"></td>
-<td align="center"><a href="../../../index.htm">Home</a></td>
-<td align="center"><a href="../libraries.html">Libraries</a></td>
-<td align="center"><a href="../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../more/faq.htm">FAQ</a></td>
-<td align="center"><a href="../../../more/index.htm">More</a></td>
-</table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="embedding.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="exception.html"><img src="../images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage">
-<div><div><h2 class="title" style="clear: both">
-<a name="python.iterators"></a>Iterators</h2></div></div>
-<div></div>
-</div>
-<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"><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>
-The typical Python iteration protocol: <tt class="literal"><span class="bold"><b>for y in x...</b></span></tt> is as follows:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">iter</span><span class="special"> =</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">__iter__</span><span class="special">()</span>         #<span class="identifier"> get</span><span class="identifier"> iterator</span><span class="keyword">
-try</span><span class="special">:</span><span class="keyword">
-    while</span><span class="number"> 1</span><span class="special">:</span><span class="identifier">
-    y</span><span class="special"> =</span><span class="identifier"> iter</span><span class="special">.</span><span class="identifier">next</span><span class="special">()</span>         #<span class="identifier"> get</span><span class="identifier"> each</span><span class="identifier"> item</span><span class="special">
-    ...</span>                     #<span class="identifier"> process</span><span class="identifier"> y</span><span class="identifier">
-except</span><span class="identifier"> StopIteration</span><span class="special">:</span><span class="identifier"> pass</span>  #<span class="identifier"> iterator</span><span class="identifier"> exhausted</span></tt></pre>
-<p>
-Boost.Python provides some mechanisms to make C++ iterators play along
-nicely as Python iterators. What we need to do is to produce
-appropriate <span class="underline">_iter</span>_ function from C++ iterators that is compatible
-with the Python iteration protocol. For example:</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>
-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>
-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>
-Let's put this into action... Here's an example from some hypothetical
-bogon Particle accelerator code:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">f</span><span class="special"> =</span><span class="identifier"> Field</span><span class="special">()</span><span class="keyword">
-for</span><span class="identifier"> x</span><span class="identifier"> in</span><span class="identifier"> f</span><span class="special">.</span><span class="identifier">pions</span><span class="special">:</span><span class="identifier">
-    smash</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span><span class="keyword">
-for</span><span class="identifier"> y</span><span class="identifier"> in</span><span class="identifier"> f</span><span class="special">.</span><span class="identifier">bogons</span><span class="special">:</span><span class="identifier">
-    count</span><span class="special">(</span><span class="identifier">y</span><span class="special">)</span></tt></pre>
-<p>
-Now, our C++ Wrapper:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">&gt;(</span><span class="string">"Field"</span><span class="special">)</span><span class="special">
-    .</span><span class="identifier">property</span><span class="special">(</span><span class="string">"pions"</span><span class="special">,</span><span class="identifier"> range</span><span class="special">(&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">p_begin</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">p_end</span><span class="special">))</span><span class="special">
-    .</span><span class="identifier">property</span><span class="special">(</span><span class="string">"bogons"</span><span class="special">,</span><span class="identifier"> range</span><span class="special">(&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">b_begin</span><span class="special">,</span><span class="special"> &amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">b_end</span><span class="special">));</span></tt></pre>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><small>Copyright © 2002-2004 Joel de Guzman, David Abrahams</small></td>
+<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>
+<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="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="embedding.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="exception.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="embedding.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exception.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<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>
+</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>
+</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>
+<p>
+    </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>
+<p>
+    </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>
+</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>
+<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>
+<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>
+<p>
+    </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>
+<p>
+    </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>
+<p>
+    </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>
+<p>
+    </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>
+</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>
+</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>
 </div>
 </body>
 </html>

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

@@ -1,33 +1,30 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Object Interface</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
-<link rel="home" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="previous" href="functions.html" title="Functions">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Object Interface</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.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%">
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../boost.png"></td>
-<td align="center"><a href="../../../index.htm">Home</a></td>
-<td align="center"><a href="../libraries.html">Libraries</a></td>
-<td align="center"><a href="../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../more/faq.htm">FAQ</a></td>
-<td align="center"><a href="../../../more/index.htm">More</a></td>
-</table>
+<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>
+<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="../../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="functions.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage">
-<div><div><h2 class="title" style="clear: both">
-<a name="python.object"></a> Object Interface</h2></div></div>
-<div></div>
+<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="python.object"></a> Object Interface</h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="object.html#python.basic_interface">Basic Interface</a></span></dt>
 <dt><span class="section"><a href="object.html#python.derived_object_types">Derived Object types</a></span></dt>
@@ -35,239 +32,310 @@
 <dt><span class="section"><a href="object.html#python.enums">Enums</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 <tt class="literal">object</tt>. We shall 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 <code class="literal">object</code>. We will see in this
+      chapter how to deal with Python objects.
+    </p>
 <p>
-As mentioned, one of the goals of Boost.Python is to provide a
-bidirectional mapping between C++ and Python while maintaining the Python
-feel. Boost.Python C++ <tt class="literal">object</tt>s are as close as possible to Python. This
-should minimize the learning curve significantly.</p>
-<p><span class="inlinemediaobject"><img src="../images/python.png"></span></p>
-<div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.basic_interface"></a>Basic Interface</h3></div></div>
-<div></div>
-</div>
+      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>
-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>
+      <span class="inlinemediaobject"><img src="../images/python.png" alt="python"></span>
+    </p>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.basic_interface"></a>Basic Interface</h3></div></div></div>
 <p>
-To illustrate, this Python code snippet:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">def</span><span class="identifier"> f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span><span class="identifier"> y</span><span class="special">):</span><span class="keyword">
-     if</span><span class="special"> (</span><span class="identifier">y</span><span class="special"> ==</span><span class="char"> 'foo'</span><span class="special">):</span><span class="identifier">
-         x</span><span class="special">[</span><span class="number">3</span><span class="special">:</span><span class="number">7</span><span class="special">]</span><span class="special"> =</span><span class="char"> 'bar'</span><span class="keyword">
-     else</span><span class="special">:</span><span class="identifier">
-         x</span><span class="special">.</span><span class="identifier">items</span><span class="special"> +=</span><span class="identifier"> y</span><span class="special">(</span><span class="number">3</span><span class="special">,</span><span class="identifier"> x</span><span class="special">)</span><span class="keyword">
-     return</span><span class="identifier"> x</span><span class="identifier">
+        Class <code class="literal">object</code> wraps <code class="literal">PyObject*</code>. All the
+        intricacies of dealing with <code class="literal">PyObject</code>s such as managing
+        reference counting are handled by the <code class="literal">object</code> class. C++
+        object interoperability is seamless. Boost.Python C++ <code class="literal">object</code>s
+        can in fact be explicitly constructed from any C++ object.
+      </p>
+<p>
+        To illustrate, this Python code snippet:
+      </p>
+<p>
+      </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>
 
-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>
+<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>
 <p>
-Can be rewritten in C++ using Boost.Python facilities this way:</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>
+        Can be rewritten in C++ using Boost.Python facilities this way:
+      </p>
 <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" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.derived_object_types"></a>Derived Object types</h3></div></div>
-<div></div>
+      </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>
+<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="titlepage"><div><div><h3 class="title">
+<a name="python.derived_object_types"></a>Derived Object types</h3></div></div></div>
 <p>
-Boost.Python comes with a set of derived <tt class="literal">object</tt> types corresponding to
-that of Python's:</p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-list
-</li>
-<li>
-dict
-</li>
-<li>
-tuple
-</li>
-<li>
-str
-</li>
-<li>
-long_
-</li>
-<li>
-enum
-</li>
+        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>
 </ul></div>
 <p>
-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>
+        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>
 <p>
-Wherever appropriate, a particular derived <tt class="literal">object</tt> has corresponding
-Python type's methods. For instance, <tt class="literal">dict</tt> has a <tt class="literal">keys()</tt> method:</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>
+        Wherever appropriate, a particular derived <code class="literal">object</code> has
+        corresponding Python type's methods. For instance, <code class="literal">dict</code>
+        has a <code class="literal">keys()</code> method:
+      </p>
+<pre class="programlisting"><span class="identifier">d</span><span class="special">.</span><span class="identifier">keys</span><span class="special">()</span>
+</pre>
 <p>
-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>
+        <code class="literal">make_tuple</code> is provided for declaring <span class="emphasis"><em>tuple literals</em></span>.
+        Example:
+      </p>
+<pre class="programlisting"><span class="identifier">make_tuple</span><span class="special">(</span><span class="number">123</span><span class="special">,</span> <span class="char">'D'</span><span class="special">,</span> <span class="string">"Hello, World"</span><span class="special">,</span> <span class="number">0.0</span><span class="special">);</span>
+</pre>
 <p>
-In 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>
+        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>
 <p>
-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>
+        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>
 <p>
-Demonstrates that you can write the C++ equivalent of <tt class="literal">"format" % x,y,z</tt>
-in Python, which is useful since there's no easy way to do that in std C++.</p>
-<p><span class="inlinemediaobject"><img src="../images/alert.png"></span><span class="bold"><b>Beware</b></span> the common pitfall of forgetting that the constructors
-of most of Python's mutable types make copies, just as in Python.</p>
+        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>
 <p>
-Python:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> d</span><span class="special"> =</span><span class="identifier"> dict</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">__dict__</span><span class="special">)</span>     #<span class="identifier"> copies</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">__dict__</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> d</span><span class="special">[</span><span class="char">'whatever'</span><span class="special">]</span>            #<span class="identifier"> modifies</span><span class="identifier"> the</span><span class="identifier"> copy</span></tt></pre>
+        Demonstrates that you can write the C++ equivalent of <code class="literal">"format"
+        % x,y,z</code> in Python, which is useful since there's no easy way to
+        do that in std C++.
+      </p>
+<div class="sidebar">
+<p class="title"><b></b></p>
 <p>
-C++:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">dict</span><span class="identifier"> d</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>  #<span class="identifier"> copies</span><span class="identifier"> x</span><span class="special">.</span><span class="identifier">__dict__</span><span class="identifier">
-d</span><span class="special">[</span><span class="char">'whatever'</span><span class="special">]</span><span class="special"> =</span><span class="number"> 3</span><span class="special">;</span>           #<span class="identifier"> modifies</span><span class="identifier"> the</span><span class="identifier"> copy</span></tt></pre>
-<a name="derived_object_types.class__lt_t_gt__as_objects"></a><h2>
-<a name="id427284"></a>class_&lt;T&gt; as objects</h2>
+        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><strong>Beware</strong></span> the common pitfall
+        of forgetting that the constructors of most of Python's mutable types make
+        copies, just as in Python.
+      </p>
+</div>
 <p>
-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>
+        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>
 <p>
-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">
+        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>
+<a name="derived_object_types.class__lt_t_gt__as_objects"></a><h3>
+<a name="id771905"></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>
 
-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>
+<span class="identifier">assert</span><span class="special">(</span><span class="identifier">vec345</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">)</span> <span class="special">==</span> <span class="number">5.0</span><span class="special">);</span>
+</pre>
 </div>
-<div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.extracting_c___objects"></a>Extracting C++ objects</h3></div></div>
-<div></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.extracting_c___objects"></a>Extracting C++ objects</h3></div></div></div>
+<p>
+        At some point, we will need to get C++ values out of object instances. This
+        can be achieved with the <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>
+<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>
+<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>
+<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>
 </div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.enums"></a>Enums</h3></div></div></div>
 <p>
-At some point, we will need to get C++ values out of object instances. This
-can be achieved with the <tt class="literal">extract&lt;T&gt;</tt> function. Consider the following:</p>
-<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>
+        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>
 <p>
-In the code above, we got a compiler error because Boost.Python
-<tt class="literal">object</tt> can't be implicitly converted to <tt class="literal">double</tt>s. Instead, what
-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>
+        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>
 <p>
-The first line attempts to extract the "length" attribute of the
-Boost.Python <tt class="literal">object</tt><tt class="literal">o</tt>. The second line attempts to <span class="emphasis"><em>extract</em></span> the
-<tt class="literal">Vec2</tt> object from held by the Boost.Python <tt class="literal">object</tt><tt class="literal">o</tt>.</p>
+        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>
-Take note that we said "attempt to" above. What if the Boost.Python
-<tt class="literal">object</tt><tt class="literal">o</tt> does not really hold a <tt class="literal">Vec2</tt> type? This is certainly
-a possibility considering the dynamic nature of Python <tt class="literal">object</tt>s. To
-be on the safe side, if the C++ type can't be extracted, an
-appropriate exception is thrown. To avoid an exception, we need to
-test for extractibility:</p>
-<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" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.enums"></a>Enums</h3></div></div>
-<div></div>
-</div>
+          <span class="bold"><strong>what is a scope?</strong></span>
+        </p>
 <p>
-Boost.Python has a nifty facility to capture and wrap C++ enums. While
-Python has no <tt class="literal">enum</tt> type, we'll often want to expose our C++ enums to
-Python as an <tt class="literal">int</tt>. Boost.Python's enum facility makes 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"><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 <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>
-<span class="inlinemediaobject"><img src="../images/note.png"></span><span class="bold"><b>what is a scope?</b></span><p></p>
-<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>.</td></tr></tbody>
+          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>
 </table></div>
 <p>
-You can access those values in Python as</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>
+        You can access those values in Python as
+      </p>
 <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"><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">
+      </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>
+<p>
+        where my_module is the module where the enum is declared. You can also create
+        a new scope around a class:
+      </p>
+<p>
+      </p>
+<pre class="programlisting"><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>
 
-// 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>
+<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>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2004 Joel de Guzman, David Abrahams</small></td>
+<td align="right"><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>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="functions.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

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

@@ -1,373 +1,452 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> General Techniques</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
-<link rel="home" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="previous" href="exception.html" title=" Exception Translation">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>General Techniques</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../index.html" title="Chapter&#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">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../boost.png"></td>
-<td align="center"><a href="../../../index.htm">Home</a></td>
-<td align="center"><a href="../libraries.html">Libraries</a></td>
-<td align="center"><a href="../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../more/faq.htm">FAQ</a></td>
-<td align="center"><a href="../../../more/index.htm">More</a></td>
-</table>
+<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>
+<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="../../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="exception.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage">
-<div><div><h2 class="title" style="clear: both">
-<a name="python.techniques"></a> General Techniques</h2></div></div>
-<div></div>
+<a accesskey="p" href="exception.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a>
 </div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="python.techniques"></a> General Techniques</h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="techniques.html#python.creating_packages">Creating Packages</a></span></dt>
 <dt><span class="section"><a href="techniques.html#python.extending_wrapped_objects_in_python">Extending Wrapped Objects in Python</a></span></dt>
 <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" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.creating_packages"></a>Creating Packages</h3></div></div>
-<div></div>
-</div>
+      Here are presented some useful techniques that you can use while wrapping code
+      with Boost.Python.
+    </p>
+<div class="section">
+<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)
-<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>
+        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>
 <p>
-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>
+        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>
 <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"><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">
+        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>
 
-/* 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">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 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>
+<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>
 <p>
-Compiling these files will generate the following Python extensions:
-<tt class="literal">core.pyd</tt>, <tt class="literal">io.pyd</tt> and <tt class="literal">filters.pyd</tt>.</p>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td>
-<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>
+        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>
 </table></div>
 <p>
-Now, we create this directory structure for our Python package:</p>
-<pre class="programlisting"><tt class="literal">    sounds/
-        <span class="underline">_init</span>_.py
-        core.pyd
-        filters.pyd
-        io.pyd
-</tt></pre>
+        Now, we create this directory structure for our Python package:
+      </p>
+<pre class="programlisting">sounds/
+    __init__.py
+    core.pyd
+    filters.pyd
+    io.pyd
+</pre>
 <p>
-The file <tt class="literal"><span class="underline">_init</span>_.py</tt> is what tells Python that the directory <tt class="literal">sounds/</tt> is
-actually a Python package. It can be a empty file, but can also perform some
-magic, that will be shown later.</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>
 <p>
-Now our package is ready. All the user has to do is put <tt class="literal">sounds</tt> into his
-<a href="http://www.python.org/doc/current/tut/node8.html#SECTION008110000000000000000" target="_top">PYTHONPATH</a> 
-and fire up the interpreter:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> import</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">io</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> import</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> sound</span><span class="special"> =</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">io</span><span class="special">.</span><span class="identifier">open</span><span class="special">(</span><span class="char">'file.mp3'</span><span class="special">)</span><span class="special">
-&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>
+        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>
 <p>
-Nice heh?</p>
+      </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>
 <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>
+        Nice heh?
+      </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"><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>
+        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>
-Note that we added an underscore to the module name. The filename will have to
-be changed to <tt class="literal">_core.pyd</tt> as well, and we do the same to the other extension modules.
-Now, we change our package hierarchy like so:</p>
-<pre class="programlisting"><tt class="literal">    sounds/
-        <span class="underline">_init</span>_.py
-        core/
-            <span class="underline">_init</span>_.py
-            _core.pyd
-        filters/
-            <span class="underline">_init</span>_.py
-            _filters.pyd
-        io/
-            <span class="underline">_init</span>_.py
-            _io.pyd
-</tt></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>
-Note that we created a directory for each extension module, and added a
-<span class="underline">_init</span>_.py to each one. But if we leave it that way, the user will have to
-access the functions in the core module with this syntax:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> import</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span><span class="special">
-&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>
+<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>
 <p>
-which is not what we want. But here enters the <tt class="literal"><span class="underline">_init</span>_.py</tt> magic: everything
-that is brought to the <tt class="literal"><span class="underline">_init</span>_.py</tt> namespace can be accessed directly by the
-user.  So, all we have to do is bring the entire namespace from <tt class="literal">_core.pyd</tt>
-to <tt class="literal">core/<span class="underline">_init</span><span class="underline">.py]. So add this line of code to [^sounds/core/</span><span class="underline">init</span>_.py</tt>:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">from</span><span class="identifier"> _core</span><span class="identifier"> import</span><span class="special"> *</span></tt></pre>
+        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/
+    __init__.py
+    core/
+        __init__.py
+        <span class="underline">core.pyd
+    filters/
+        \</span>_init__.py
+        <span class="underline">filters.pyd
+    io/
+        \</span>_init__.py
+        _io.pyd
+</pre>
 <p>
-We do the same for the other packages. Now the user accesses the functions and
-classes in the extension modules like before:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> import</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">
-&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>
+        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>
-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="identifier">import</span><span class="identifier"> _filters</span><span class="identifier">
-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>
+<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>
 <p>
-Next, we add this line to <tt class="literal">sounds<span class="emphasis"><em>filters</em></span><span class="underline">_init</span>_.py</tt>:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">from</span><span class="identifier"> echo_noise</span><span class="identifier"> import</span><span class="identifier"> echo_noise</span></tt></pre>
+        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<span class="emphasis"><em>core</em></span>__init__.py</code>:
+      </p>
+<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">_core</span> <span class="keyword">import</span> <span class="special">*</span>
+</pre>
 <p>
-And that's it. The user now accesses this function like any other function
-from the <tt class="literal">filters</tt> package:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> import</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo_noise</span><span class="special">(...)</span></tt></pre>
-</div>
-<div class="section" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.extending_wrapped_objects_in_python"></a>Extending Wrapped Objects in Python</h3></div></div>
-<div></div>
+        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>
+<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>
+<p>
+        Next, we add this line to <code class="literal">sounds<span class="emphasis"><em>filters</em></span>__init__.py</code>:
+      </p>
+<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">echo_noise</span> <span class="keyword">import</span> <span class="identifier">echo_noise</span>
+</pre>
+<p>
+        And that's it. The user now accesses this function like any other function
+        from the <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>
 </div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.extending_wrapped_objects_in_python"></a>Extending Wrapped Objects in Python</h3></div></div></div>
 <p>
-Thanks to Python's flexibility, you can easily add new methods to a class,
-even after it was already created:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="keyword"> class</span><span class="identifier"> C</span><span class="special">(</span><span class="identifier">object</span><span class="special">):</span><span class="identifier"> pass</span><span class="special">
-&gt;&gt;&gt;</span><span class="special">
-&gt;&gt;&gt;</span> #<span class="identifier"> a</span><span class="identifier"> regular</span><span class="identifier"> function</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> def</span><span class="identifier"> C_str</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span><span class="keyword"> return</span><span class="char"> 'A C instance!'</span><span class="special">
-&gt;&gt;&gt;</span><span class="special">
-&gt;&gt;&gt;</span> #<span class="identifier"> now</span><span class="identifier"> we</span><span class="identifier"> turn</span><span class="identifier"> it</span><span class="identifier"> in</span><span class="identifier"> a</span><span class="identifier"> member</span><span class="identifier"> function</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> C</span><span class="special">.</span><span class="identifier">__str__</span><span class="special"> =</span><span class="identifier"> C_str</span><span class="special">
-&gt;&gt;&gt;</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> c</span><span class="special"> =</span><span class="identifier"> C</span><span class="special">()</span><span class="special">
-&gt;&gt;&gt;</span><span class="identifier"> print</span><span class="identifier"> c</span><span class="identifier">
-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>
+        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>
 <p>
-Yes, Python rox. <span class="inlinemediaobject"><img src="../images/smiley.png"></span></p>
+        Yes, Python rox. <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span>
+      </p>
 <p>
-We can do the same with classes that were wrapped with Boost.Python. Suppose
-we have a class <tt class="literal">point</tt> in C++:</p>
-<pre class="programlisting"><tt class="literal"><span class="keyword">class</span><span class="identifier"> point</span><span class="special"> {...};</span><span class="identifier">
+        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>
+<p>
+      </p>
+<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">point</span> <span class="special">{...};</span>
 
-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>
+<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>
 <p>
-If we are using the technique from the previous session,
-<a href="techniques.html#creating_packages" target="_top">Creating Packages</a>, we can code directly 
-into <tt class="literal">geom/<span class="underline">_init</span>_.py</tt>:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">from</span><span class="identifier"> _geom</span><span class="identifier"> import</span><span class="special"> *</span>
+        If we are using the technique from the previous session, <a class="link" href="techniques.html#python.creating_packages" title="Creating Packages">Creating
+        Packages</a>, we can code directly into <code class="literal">geom/__init__.py</code>:
+      </p>
+<p>
+      </p>
+<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">_geom</span> <span class="keyword">import</span> <span class="special">*</span>
 
-#<span class="identifier"> a</span><span class="identifier"> regular</span><span class="identifier"> function</span><span class="identifier">
-def</span><span class="identifier"> point_str</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span><span class="keyword">
-    return</span><span class="identifier"> str</span><span class="special">((</span><span class="identifier">self</span><span class="special">.</span><span class="identifier">x</span><span class="special">,</span><span class="identifier"> self</span><span class="special">.</span><span class="identifier">y</span><span class="special">))</span>
+<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>
 
-#<span class="identifier"> now</span><span class="identifier"> we</span><span class="identifier"> turn</span><span class="identifier"> it</span><span class="identifier"> into</span><span class="identifier"> a</span><span class="identifier"> member</span><span class="identifier"> function</span><span class="identifier">
-point</span><span class="special">.</span><span class="identifier">__str__</span><span class="special"> =</span><span class="identifier"> point_str</span></tt></pre>
-<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>
+<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>
 </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"><tt class="literal">
-#<span class="identifier"> The</span><span class="identifier"> one</span><span class="identifier"> Boost</span><span class="special">.</span><span class="identifier">Python</span><span class="identifier"> uses</span><span class="keyword"> for</span><span class="identifier"> all</span><span class="identifier"> wrapped</span><span class="identifier"> classes</span><span class="special">.</span>
-#<span class="identifier"> You</span><span class="identifier"> can</span><span class="identifier"> use</span><span class="identifier"> here</span><span class="identifier"> any</span><span class="keyword"> class</span><span class="identifier"> exported</span><span class="identifier"> by</span><span class="identifier"> Boost</span><span class="identifier"> instead</span><span class="identifier"> of</span><span class="string"> "point"</span><span class="identifier">
-BoostPythonMetaclass</span><span class="special"> =</span><span class="identifier"> point</span><span class="special">.</span><span class="identifier">__class__</span><span class="keyword">
+        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>
 
-class</span><span class="identifier"> injector</span><span class="special">(</span><span class="identifier">object</span><span class="special">):</span><span class="keyword">
-    class</span><span class="identifier"> __metaclass__</span><span class="special">(</span><span class="identifier">BoostPythonMetaclass</span><span class="special">):</span><span class="identifier">
-        def</span><span class="identifier"> __init__</span><span class="special">(</span><span class="identifier">self</span><span class="special">,</span><span class="identifier"> name</span><span class="special">,</span><span class="identifier"> bases</span><span class="special">,</span><span class="identifier"> dict</span><span class="special">):</span><span class="keyword">
-            for</span><span class="identifier"> b</span><span class="identifier"> in</span><span class="identifier"> bases</span><span class="special">:</span><span class="keyword">
-                if</span><span class="identifier"> type</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span><span class="keyword"> not</span><span class="identifier"> in</span><span class="special"> (</span><span class="identifier">self</span><span class="special">,</span><span class="identifier"> type</span><span class="special">):</span><span class="keyword">
-                    for</span><span class="identifier"> k</span><span class="special">,</span><span class="identifier">v</span><span class="identifier"> in</span><span class="identifier"> dict</span><span class="special">.</span><span class="identifier">items</span><span class="special">():</span><span class="identifier">
-                        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="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>
 
-#<span class="identifier"> inject</span><span class="identifier"> some</span><span class="identifier"> methods</span><span class="identifier"> in</span><span class="identifier"> the</span><span class="identifier"> point</span><span class="identifier"> foo</span><span class="keyword">
-class</span><span class="identifier"> more_point</span><span class="special">(</span><span class="identifier">injector</span><span class="special">,</span><span class="identifier"> point</span><span class="special">):</span><span class="identifier">
-    def</span><span class="identifier"> __repr__</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span><span class="keyword">
-        return</span><span class="char"> 'Point(x=%s, y=%s)'</span><span class="special"> %</span><span class="special"> (</span><span class="identifier">self</span><span class="special">.</span><span class="identifier">x</span><span class="special">,</span><span class="identifier"> self</span><span class="special">.</span><span class="identifier">y</span><span class="special">)</span><span class="identifier">
-    def</span><span class="identifier"> foo</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span><span class="identifier">
-        print</span><span class="char"> 'foo!'</span></tt></pre>
+<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>
 <p>
-Now let's see how it got:</p>
-<pre class="programlisting"><tt class="literal"><span class="special">&gt;&gt;&gt;</span><span class="identifier"> print</span><span class="identifier"> point</span><span class="special">()</span><span class="identifier">
-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>
+        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>
 <p>
-Another useful idea is to replace constructors with factory functions:</p>
-<pre class="programlisting"><tt class="literal"><span class="identifier">_point</span><span class="special"> =</span><span class="identifier"> point</span><span class="identifier">
+        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>
 
-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>
+<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>
 <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" lang="en">
-<div class="titlepage">
-<div><div><h3 class="title">
-<a name="python.reducing_compiling_time"></a>Reducing Compiling Time</h3></div></div>
-<div></div>
+        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="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"><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">
-
-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">
-
-/* 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">
-
-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>
+        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>
-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">
+      </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>
 
-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"><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="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>
 
-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>
+<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>
+
+<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>
 <p>
-but the memory is kept under control.</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>
+
+<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>
 <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="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td>
-<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>
+        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>
+
+<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>
+<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>
 </table></div>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td>
-<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>
+<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>
 </table></div>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2004 Joel de Guzman, David Abrahams</small></td>
+<td align="right"><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>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="exception.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a>
+<a accesskey="p" href="exception.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a>
 </div>
 </body>
 </html>

doc/tutorial/index.html

@@ -1,10 +1,18 @@
 <!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>
+    <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>
   </body>
 </html>

doc/v2/Apr2002.html

@@ -1,3 +1,6 @@
+<!-- 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">
@@ -157,7 +160,7 @@ documentation).
   13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
+<p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. </i></p>
 </body>
 </html>

doc/v2/CallPolicies.html

@@ -1,11 +1,14 @@
 <!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>
@@ -57,6 +60,7 @@
 
       <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>
@@ -113,7 +117,7 @@
         "ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a>.</td>
 
         <td>An MPL unary <a href=
-        "../../../mpl/doc/paper/html/usage.html#metafunctions.classes">Metafunction
+        "../../../mpl/doc/refmanual/metafunction-class.html">Metafunction
         Class</a> used produce the "preliminary" result object.</td>
       </tr>
 
@@ -129,7 +133,16 @@
         reference count must be decremented; if another existing object is
         returned, its reference count must be incremented.</td>
       </tr>
-    </table>
+      <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>
     Models of CallPolicies are required to be <a href=
     "../../../utility/CopyConstructible.html">CopyConstructible</a>. 
     <hr>
@@ -141,8 +154,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/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,7 +1,10 @@
+<!-- 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">
@@ -60,8 +63,8 @@ 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="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002-2003. All Rights Reserved.</i>
+    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002-2003. </i>
 
 <p>Permission to copy, use, modify, sell
  and distribute this software is granted provided this copyright notice appears

doc/v2/Extractor.html

@@ -1,7 +1,10 @@
+<!-- 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">
@@ -82,8 +85,8 @@ are layout-compatible with PyObject.
   13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. All Rights Reserved.</i>
+    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. </i>
 
 <p>Permission to copy, use, modify, sell
  and distribute this software is granted provided this copyright notice appears

doc/v2/HolderGenerator.html

@@ -1,7 +1,10 @@
+<!-- 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">
@@ -60,8 +63,8 @@ type.
   13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. All Rights Reserved.</i>
+    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. </i>
 
 <p>Permission to copy, use, modify, sell
  and distribute this software is granted provided this copyright notice appears

doc/v2/Jun2002.html

@@ -1,3 +1,6 @@
+<!-- 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">
@@ -220,7 +223,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="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
+<p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. </i></p>
 </body>
 </html>

doc/v2/Mar2002.html

@@ -1,3 +1,6 @@
+<!-- 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">
@@ -228,7 +231,7 @@ worth doing anything about it.
   13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
+<p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. </i></p>
 </body>
 </html>

doc/v2/May2002.html

@@ -1,3 +1,6 @@
+<!-- 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">
@@ -302,7 +305,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="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
+<p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. </i></p>
 </body>
 </html>

doc/v2/ObjectWrapper.html

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

doc/v2/ResultConverter.html

@@ -1,7 +1,12 @@
+<!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">
@@ -21,10 +26,12 @@
 <dl class="page-index"> 
   <dt><a href="#introduction">Introduction</a></dt>
   <dt><a href="#concept-requirements">Concept Requirements</a></dt>
-  <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>
+  </dd>
 </dl>
 
 <h2><a name="introduction"></a>Introduction</h2>
@@ -76,6 +83,13 @@ 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>
@@ -99,8 +113,8 @@ C++ function return type.
   09 May, 2002    <!--Luann's birthday! -->
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. All Rights Reserved.</i>
+    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. </i>
 
 <p>Permission to copy, use, modify, sell
  and distribute this software is granted provided this copyright notice appears

doc/v2/acknowledgments.html

@@ -1,5 +1,8 @@
 <!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=
@@ -28,7 +31,7 @@
     </table>
     <hr>
 
-    <p><a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> is
+    <p><a href="http://www.boost.org/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>
@@ -44,7 +47,7 @@
     argument support</a> and wrote the excellent <a href=
     "../tutorial/index.html">tutorial documentation</a>.</p>
 
-    <p><a href="../../../../people/ralf_w_grosse_kunstleve.htm">Ralf W.
+    <p><a href="http://www.boost.org/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
@@ -56,15 +59,15 @@
     C++ and Python for solving the problems of large-scale software
     construction.</p>
 
-    <p><a href="../../../../people/aleksey_gurtovoy.htm">Aleksey Gurtovoy</a>
+    <p><a href="http://www.boost.org/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="../../../../people/paul_mensonides.htm">Paul Mensonides</a>,
-    building on the work <a href="../../../../people/vesa_karvonen.htm">Vesa
+    <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
     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
@@ -126,8 +129,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/args.html

@@ -1,5 +1,8 @@
 <!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=
@@ -98,7 +101,7 @@ namespace boost { namespace python
         struct arg 
         {
           template &lt;class T&gt;
-                  arg &amp;perator = (T const &amp;value);
+                  arg &amp;operator = (T const &amp;value);
           explicit arg (char const *name){elements[0].name = name;}
         };
 
@@ -190,8 +193,7 @@ BOOST_PYTHON_MODULE(xxx)
     <p>Revised 01 August, 2003</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002-2003. All
-    Rights Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002-2003.</i></p>
   </body>
 </html>
 

doc/v2/bibliography.html

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

doc/v2/call.html

@@ -1,3 +1,6 @@
+<!-- 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">
@@ -76,7 +79,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="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
+<p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. </i></p>
 </body>
 </html>

doc/v2/call_method.html

@@ -1,5 +1,8 @@
 <!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=
@@ -152,8 +155,7 @@ BOOST_PYTHON_MODULE(my_module)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/callbacks.html

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

doc/v2/callbacks.txt

@@ -1,3 +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)
+
 Here's the plan:
 
 I aim to provide an interface similar to that of Boost.Python v1's

doc/v2/configuration.html

@@ -1,5 +1,8 @@
 <!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=
@@ -103,6 +106,33 @@
         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
@@ -136,6 +166,41 @@
         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>
 
@@ -146,8 +211,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/copy_const_reference.html

@@ -1,5 +1,8 @@
 <!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=
@@ -140,8 +143,7 @@ BOOST_PYTHON_MODULE(my_module)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/copy_non_const_reference.html

@@ -1,5 +1,8 @@
 <!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=
@@ -140,8 +143,7 @@ BOOST_PYTHON_MODULE(my_module)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/data_members.html

@@ -1,5 +1,8 @@
 <!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=
@@ -220,8 +223,7 @@ BOOST_PYTHON_MODULE_INIT(data_members_example)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/def.html

@@ -1,5 +1,8 @@
 <!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=
@@ -182,8 +185,7 @@ BOOST_PYTHON_MODULE(def_test)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/def_visitor.html

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

doc/v2/default_call_policies.html

@@ -82,6 +82,7 @@ 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>
@@ -161,10 +162,12 @@ struct return_value_policy : Base
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  13 November, 2002
+  11 June, 2007
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
-    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. All Rights Reserved.</i>
+  <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>
 

doc/v2/definitions.html

@@ -1,5 +1,8 @@
 <!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=
@@ -93,8 +96,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/dict.html

@@ -1,5 +1,8 @@
 <!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,8 +146,7 @@ dict swap_object_dict(object target, dict d)
     <p>Revised 30 September, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/docstring_options.html

@@ -0,0 +1,386 @@
+<!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,5 +1,8 @@
 <!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=
@@ -86,7 +89,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);
+    enum_(char const* name, char const* doc = 0);
     enum_&lt;T&gt;&amp; value(char const* name, T);
     enum_&lt;T&gt;&amp; export_values();
   };
@@ -96,7 +99,7 @@ namespace boost { namespace python
     <h4><a name="enum_-spec-ctors"></a>Class template <code>enum_</code>
     constructors</h4>
 <pre>
-enum_(char const* name);
+enum_(char const* name, char const* doc=0);
 </pre>
 
     <dl class="function-semantics">
@@ -128,7 +131,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>
 
@@ -143,7 +146,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>
 
@@ -225,8 +228,7 @@ TypeError: bad argument type for built-in operation
      
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/errors.html

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

doc/v2/exception_translator.html

@@ -1,5 +1,8 @@
 <!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=
@@ -141,8 +144,7 @@ BOOST_PYTHON_MODULE(exception_translator_ext)
     <p>Revised 03 October, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/exec.html

@@ -0,0 +1,163 @@
+<!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,5 +1,8 @@
 <!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,8 +226,7 @@ BOOST_PYTHON_MODULE(extract_ext)
     <p>Revised 15 November, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/faq.html

@@ -1,5 +1,8 @@
 <!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,8 +70,6 @@
       >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>
@@ -568,7 +569,7 @@ handle&lt;&gt; f_wrap()
 ...
 
 def("f", f_wrap());
-class_&lt;X,X_wrap&gt;("X", init&lt;int&gt;())
+class_&lt;X,X_wrap,boost::noncopyable&gt;("X", init&lt;int&gt;())
    ...
    ;
 </pre>
@@ -649,14 +650,14 @@ void b_insert(B&amp; b, std::auto_ptr&lt;A&gt; a)
     <h2><a name="slow_compilation">Compilation takes too much time and eats too
             much memory!  What can I do to make it faster?</a></h2>
     <p>
-    Please refer to the <a href="../tutorial/doc/reducing_compiling_time.html"
+    Please refer to the <a href="../tutorial/doc/html/python/techniques.html#python.reducing_compiling_time"
     >Reducing Compiling Time</a> section in the tutorial.
     </p>
 
     <hr>
     <h2><a name="packages">How do I create sub-packages using Boost.Python?</a></h2>
     <p>
-    Please refer to the <a href="../tutorial/doc/creating_packages.html"
+    Please refer to the <a href="../tutorial/doc/html/python/techniques.html#python.creating_packages"
     >Creating Packages</a> section in the tutorial.
     </p>
 
@@ -693,29 +694,6 @@ 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>
@@ -873,12 +851,11 @@ BOOST_PYTHON_MODULE(custom_string)
 
     <p>Revised
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     28 January, 2004
+     12 March, 2006
     <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002-2003. All
-    Rights Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002-2006.</i></p>
   </body>
 </html>

doc/v2/feb2002.html

@@ -360,7 +360,8 @@
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
-    <p class="c3">&copy; Copyright <a href= 
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a>
-    2002. All Rights Reserved.
+  <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>
 

doc/v2/from_python.html

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

doc/v2/function_doc_signature.html

@@ -0,0 +1,216 @@
+<!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,5 +1,8 @@
 <!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=
@@ -326,8 +329,8 @@ null_ok&lt;T&gt;* allow_null(T* p)
     </p>
 
     <p class="c4">&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002
+.</p>
   </body>
 </html>
 

doc/v2/has_back_reference.html

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

doc/v2/header.html

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

doc/v2/implicit.html

@@ -1,5 +1,8 @@
 <!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=
@@ -110,7 +113,7 @@ using namespace boost::python;
 struct X
 {
     X(int x) : v(x) {}
-    operator int() { return v; }
+    operator int() const { return v; }
     int v;
 };
 
@@ -154,8 +157,7 @@ BOOST_PYTHON_MODULE(implicit_ext)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/import.html

@@ -0,0 +1,90 @@
+<!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,5 +1,8 @@
 <!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,4 +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 name="generator" content=
@@ -66,8 +69,8 @@
       </dt>
       <dt>
         <a href="#vector_indexing_suite_class">vector_indexing_suite
-        class</a>
-      </dt>
+        class<br>
+        </a><a href="#map_indexing_suite_class">map_indexing_suite class</a> </dt>
     </dl>
     <hr>
     <h2>
@@ -141,7 +144,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 protocol class for the
+      The <tt>indexing_suite</tt> class is the base  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
@@ -275,8 +278,7 @@
       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 (currently, this is the only predefined
-      suite available). It provides all the policies required by the
+      std::vector interface]) classes. It provides all the policies required by the
       <tt>indexing_suite</tt>.
   </p>
     <p>
@@ -295,22 +297,32 @@
          <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>
+</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>
     <hr>
     <h2>
-      <a name="indexing_suite_class"></a>indexing_suite class
-    </h2>
-  <h3>
-<br>
-      <tt>indexing_suite&lt;<br>
-      class Container<br>
+      <a name="indexing_suite_class"></a>indexing_suite class    </h2>
+    <h2>  <tt>indexing_suite&lt;<br>
+    </tt><tt>class Container<br>
        , class DerivedPolicies<font color="#007F00"><br>
        </font></tt> <tt>,
-      bool NoProxy<br>
-       , class Element<br>
-       , class Key<br>
-       , class Index</tt>
-    </h3>
+          bool NoProxy<br>
+       ,
+  bool NoSlice<br>
+       </tt><tt>, class Data<br>
+      , class Index<br>
+    </tt><tt>, class Key</tt></h2>
     <table width="100%" border="1">
       <tr>
         <td>
@@ -355,36 +367,45 @@
           
         </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>NoProxy</tt></font>
+          <font color="#007F00"><tt>NoSlice</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>
+          Do not allow slicing. </td>
         <td>
           false
         </td>
       </tr>
       <tr>
         <td>
-          <font color="#007F00"><tt>Element</tt></font>
+          <font color="#007F00"><tt>Data</tt></font>
         </td>
         <td>&nbsp;
           
         </td>
         <td>
-          The container's element type.
+          The container's data 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>
@@ -399,28 +420,14 @@
           <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>
-    </table>
+  </table>
     <pre>
     template &lt;<br>          class Container
         , class DerivedPolicies
-        , bool NoProxy = false
-        , class Element = typename Container::value_type
-        , class Key = typename Container::value_type
+        , bool NoProxy = false<br>        , bool NoSlice = false
+        , class Data = typename Container::value_type
         , class Index = typename Container::size_type
+        , class Key = typename Container::value_type
     &gt;<br>    class indexing_suite
         : unspecified
     {
@@ -435,23 +442,22 @@
     <dl>
       <dd>
         Derived classes provide the hooks needed by
-        the<tt>indexing_suite:</tt>
+        the <tt>indexing_suite:</tt>
       </dd>
     </dl>
-    <pre>
-        static element_type&amp;
+    <pre>        data_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, element_type const&amp; v);
+        set_item(Container&amp; container, index_type i, data_type const&amp; v);
 
         static void
         set_slice(
             Container&amp; container, index_type from,
-            index_type to, element_type const&amp; v
+            index_type to, data_type const&amp; v
         );
 
         template &lt;class Iter&gt;
@@ -593,16 +599,16 @@
         </tr>
       </table>
       <pre>
-    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);
+    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);
 
         static object
         get_slice(Container&amp; container, index_type from, index_type to);
 
-        static void<br>        set_item(Container&amp; container, index_type i, element_type const&amp; v);
+        static void<br>        set_item(Container&amp; container, index_type i, data_type const&amp; v);
 
         static void
         set_slice(Container&amp; container, index_type from, 
-            index_type to, element_type const&amp; v);
+            index_type to, data_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);
 
@@ -624,7 +630,60 @@
         adjust_index(index_type current, index_type from, 
             index_type to, size_type len);
     };
-      </pre>
+
+</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>
       <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,5 +1,8 @@
 <!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=
@@ -109,7 +112,7 @@
     <i>unspecified</i><code>,</code>...<code>Tn</code> =
     <i>unspecified</i><code>&gt;</code></h3>
 
-    <p>A <a href="../../../mpl/doc/ref/Sequences.html">MPL sequence</a> which
+    <p>A <a href="../../../mpl/doc/refmanual/forward-sequence.html">MPL sequence</a> which
     can be used to specify a family of one or more <code>__init__</code>
     functions. Only the last <code>T</code><i><small>i</small></i> supplied
     may be an instantiation of <a href=
@@ -195,7 +198,7 @@ template &lt;class Policies&gt;
     <i>unspecified</i><code>,</code>...<code>Tn</code> =
     <i>unspecified</i><code>&gt;</code></h3>
 
-    <p>A <a href="../../../mpl/doc/ref/Sequences.html">MPL sequence</a> which
+    <p>A <a href="../../../mpl/doc/refmanual/forward-sequence.html">MPL sequence</a> which
     can be used to specify the optional arguments to an <code>__init__</code>
     function.</p>
 
@@ -242,8 +245,7 @@ class_&lt;X&gt;("X", "This is X's docstring.",
      
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/instance_holder.html

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

doc/v2/iterator.html

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

doc/v2/list.html

@@ -1,5 +1,8 @@
 <!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=
@@ -133,8 +136,7 @@ long zeroes(list l)
     <p>Revised 1 October, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/long.html

@@ -1,5 +1,8 @@
 <!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=
@@ -110,8 +113,7 @@ python::long_ fact(long n)
     <p>Revised 1 October, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/lvalue_from_pytype.html

@@ -1,5 +1,8 @@
 <!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=
@@ -292,8 +295,7 @@ BOOST_PYTHON_MODULE(noddy_cache)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>