module, class_ .def dispatching

[SVN r14963]

Jamfile

@@ -0,0 +1,42 @@
+subproject libs/python ;
+
+# bring in the rules for python
+SEARCH on <module@>python.jam = $(BOOST_BUILD_PATH) ;
+include <module@>python.jam ;
+
+local bpl-ldflags ;
+
+if $(UNIX) && ( $(OS) = AIX )
+{
+    bpl-linkflags = <linkflags>"-e initlibbpl" ;
+}
+
+dll bpl
+  : 
+  src/list.cpp
+  src/long.cpp
+  src/dict.cpp
+  src/tuple.cpp
+  src/str.cpp
+
+  src/aix_init_module.cpp
+  src/converter/from_python.cpp
+  src/converter/registry.cpp
+  src/converter/type_id.cpp
+  src/object/class.cpp
+  src/object/function.cpp
+  src/object/inheritance.cpp
+  src/object/life_support.cpp
+  src/object/pickle_support.cpp
+  src/errors.cpp
+  src/module.cpp
+  src/converter/builtin_converters.cpp
+  src/converter/arg_to_python_base.cpp
+  src/object/iterator.cpp
+  src/object_protocol.cpp
+  src/object_operators.cpp
+  :
+  $(BOOST_PYTHON_V2_PROPERTIES)
+    <define>BOOST_PYTHON_SOURCE
+    $(bpl-linkflags)
+    ;

build/Jamfile

@@ -3,8 +3,56 @@
 #  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
-
+# Boost.Python build and test Jamfile
+#
+# To run all tests quietly: jam test
+# To run all tests with verbose output: jam -sPYTHON_TEST_ARGS=-v test
+#
+# Declares the following targets:
+#   1. libboost_python.dll/.so, a dynamic library to be linked with all
+#      Boost.Python modules
+#
+#   2. pairs of test targets of the form <name>.test and <name>.run
+#      <name>.test runs the test when it is out-of-date, and the "test"
+#      pseudotarget depends on it. <name>.run runs
+#      a test unconditionally, and can be used to force a test to run.. Each
+#      test target builds one or more Boost.Python modules and runs a Python
+#      script to test them. The test names are:
+#
+#      from ../test
+#
+#         comprehensive         - a comprehensive test of Boost.Python features
+#
+#      from ../example:
+#         abstract              -
+#         getting_started1      -
+#         getting_started2      -
+#         simple_vector         -
+#         do_it_yourself_convts -
+#         pickle1               -
+#         pickle2               -
+#         pickle3               -
+#
+#         dvect1                -
+#         dvect2                -
+#         ivect1                -
+#         ivect2                -
+#         noncopyable           -
+#
+# subproject-specific environment/command-line variables:
+#
+# PYTHON                - How to invoke the Python interpreter. Defaults to "python"
+#
+# PYTHON_ROOT           - Windows only: where Python is installed. Defaults to "c:/tools/python"
+#
+# PYTHON_VERSION        - Version of Python. Defaults to "2.1" on Windows, "1.5" on Unix
+#
+# PYTHON_TEST_ARGS      - specifies arguments to be passed to test scripts on
+#                         the command line. "-v" can be useful if you want to
+#                         see the output of successful tests.
+#
+# PYTHON_VECT_ITERATIONS - specifies the number of test iterations to use for
+#                          the dvect and ivect tests above.
 
 # declare the location of this subproject relative to the root
 subproject libs/python/build ;
@@ -13,54 +61,113 @@ subproject libs/python/build ;
 SEARCH on <module@>python.jam = $(BOOST_BUILD_PATH) ;
 include <module@>python.jam ;
 
-if [ check-python-config ]
+# This nasty hack works with versions of Python 1.5.2 -> 2.2 to avoid
+# building any Python stuff if there's no installation.
+SEARCH on <find-python-install>__init__.py = $(PYTHON_STDLIB_PATH)/test $(SUBDIR) ;
+include <find-python-install>__init__.py ;
+if ! $(gNO_PYTHON_INSTALL)
 {
     
-  local bpl-linkflags ;
+local PYTHON_PROPERTIES = $(PYTHON_PROPERTIES) <define>BOOST_PYTHON_DYNAMIC_LIB ;
 
-  if $(UNIX) && ( $(OS) = AIX )
-  {
-      bpl-linkflags = <linkflags>"-e initlibboost_python" ;
-  }
+#######################
+rule bpl-test ( test-name : sources + )
+{
+    boost-python-test $(test-name) : $(sources) <dll>boost_python ;
+}
 
-  dll boost_python
-    : 
-    ../src/numeric.cpp
+#######################
 
-    ../src/list.cpp
-    ../src/long.cpp
-    ../src/dict.cpp
-    ../src/tuple.cpp
-    ../src/str.cpp
+#
+# Declare the boost python static link library
+#
 
-    ../src/aix_init_module.cpp
-    ../src/converter/from_python.cpp
-    ../src/converter/registry.cpp
-    ../src/converter/type_id.cpp
-    ../src/object/enum.cpp
-    ../src/object/class.cpp
-    ../src/object/function.cpp
-    ../src/object/inheritance.cpp
-    ../src/object/life_support.cpp
-    ../src/object/pickle_support.cpp
-    ../src/errors.cpp
-    ../src/module.cpp
-    ../src/converter/builtin_converters.cpp
-    ../src/converter/arg_to_python_base.cpp
-    ../src/object/iterator.cpp
-    ../src/object_protocol.cpp
-    ../src/object_operators.cpp
-    :
-    $(BOOST_PYTHON_V2_PROPERTIES)
-      <define>BOOST_PYTHON_SOURCE
-      $(bpl-linkflags)
+# Base names of the source files for libboost_python
+local CPP_SOURCES =
+  types classes conversions extension_class functions 
+  init_function module_builder objects cross_module errors
+  ;
+
+lib boost_python_static : ../src/$(CPP_SOURCES).cpp
+  # requirements
+  : $(BOOST_PYTHON_INCLUDES)
+    <shared-linkable>true
+    <define>BOOST_PYTHON_STATIC_LIB=1
+    [ difference $(PYTHON_PROPERTIES) : <define>BOOST_PYTHON_DYNAMIC_LIB ] 
+      : <suppress>true # don't build this unless the user asks for it by name
       ;
 
-  stage bin-stage : <dll>boost_python
+dll boost_python
+  # $(SUFDLL[1])
+    : ../src/$(CPP_SOURCES).cpp
+	# requirements
+      : $(BOOST_PYTHON_INCLUDES)
+	<shared-linkable>true
+        <runtime-link>dynamic
+	$(PYTHON_PROPERTIES)
+          ;
+
+stage bin-stage : <dll>boost_python
     :
         <tag><debug>"_debug"
         <tag><debug-python>"_pydebug"
     :
         debug release
     ;
+
+############# comprehensive module and test ###########
+bpl-test boost_python_test
+      : ../test/comprehensive.cpp ;
+
+boost-python-runtest comprehensive
+         : ../test/comprehensive.py <pyd>boost_python_test <dll>boost_python ;
+
+############# simple tests from ../example ############
+
+rule boost-python-example-runtest ( name )
+{
+    bpl-test $(name)
+      : ../example/$(name).cpp ;
+    
+    boost-python-runtest $(name)
+      : ../example/test_$(name).py <pyd>$(name) <dll>boost_python ;
+}
+
+
+boost-python-example-runtest abstract ;
+boost-python-example-runtest getting_started1 ;
+boost-python-example-runtest getting_started2 ;
+boost-python-example-runtest simple_vector ;
+boost-python-example-runtest do_it_yourself_convts ;
+boost-python-example-runtest pickle1 ;
+boost-python-example-runtest pickle2 ;
+boost-python-example-runtest pickle3 ;
+
+
+bpl-test ivect : ../example/ivect.cpp ;
+bpl-test dvect : ../example/dvect.cpp ;
+bpl-test noncopyable_export : ../example/noncopyable_export.cpp ;
+bpl-test noncopyable_import : ../example/noncopyable_import.cpp ;
+
+############## cross-module tests from ../example ##########
+
+# A simple rule to build a test which depends on multiple modules in the PYTHONPATH
+rule boost-python-multi-example-runtest ( test-name : modules + )
+{
+    boost-python-runtest $(test-name)
+        : ../example/tst_$(test-name).py <pyd>$(modules) <dll>boost_python
+        : : : $(PYTHON_VECT_ITERATIONS) ;
+}
+
+PYTHON_VECT_ITERATIONS ?= 10 ;
+
+boost-python-multi-example-runtest dvect1 : ivect dvect ;
+boost-python-multi-example-runtest dvect2 : ivect dvect ;
+
+boost-python-multi-example-runtest ivect1 : ivect dvect ;
+boost-python-multi-example-runtest ivect2 : ivect dvect ;
+
+boost-python-multi-example-runtest
+        noncopyable : noncopyable_import noncopyable_export ;
+
 }

build/__init__.py

@@ -0,0 +1,22 @@
+# Dummy file actually to be included by Jam when the python headers
+# can't be found
+
+if ! $(gNO_PYTHON_INSTALL)
+{
+    ECHO "---------------------------------------------------------------------" ;
+    ECHO skipping Boost.Python library build ;
+    ECHO You can configure the location of your python installation, by setting: ;
+    ECHO "PYTHON_ROOT    - currently" \"$(PYTHON_ROOT:J=" ")\" ;
+    ECHO "PYTHON_VERSION - The 2-part python Major.Minor version number (e.g." ;
+    ECHO "                 \"2.2\", NOT \"2.2.1\")  - currently" \"$(PYTHON_VERSION)\" ;
+    ECHO ;
+    ECHO "The following are automatically configured from PYTHON_ROOT if not" ;
+    ECHO "otherwise set:" ;
+    ECHO "    PYTHON_INCLUDES    - path to Python #include directories; currently" \"$(PYTHON_INCLUDES:J=" ")\" ;
+    ECHO "    PYTHON_LIB_PATH    - path to Python library; currently" ;
+    ECHO "                         " \"$(PYTHON_LIB_PATH:J=" ")\" ;
+    ECHO "    PYTHON_STDLIB_PATH - path to Python standard library modules; currently" ;
+    ECHO "                         " \"$(PYTHON_STDLIB_PATH:J=" ")\" ;
+    ECHO "---------------------------------------------------------------------" ;
+}
+gNO_PYTHON_INSTALL ?= true ;

build/como.mak

@@ -0,0 +1,59 @@
+# Revision History:
+# 17 Apr 01  include cross-module support, compile getting_started1 (R.W. Grosse-Kunstleve) UNTESTED!
+# 06 Mar 01  Fixed typo in use of "PYTHON_LIB" (Dave Abrahams)
+# 04 Mar 01  Changed library name to libboost_python.a (David Abrahams)
+
+LIBSRC = \
+    classes.cpp \
+    conversions.cpp \
+    cross_module.cpp \
+    errors.cpp \
+    extension_class.cpp \
+    functions.cpp \
+    init_function.cpp \
+    module_builder.cpp \
+    objects.cpp \
+    types.cpp
+        
+LIBOBJ = $(LIBSRC:.cpp=.o)
+OBJ = $(LIBOBJ)
+
+
+ifeq "$(OS)" "Windows_NT"
+PYTHON_LIB=c:/tools/python/libs/python15.lib
+INC = -Ic:/cygnus/usr/include/g++-3 -Ic:/cygnus/usr/include -Ic:/boost -Ic:/tools/python/include
+MODULE_EXTENSION=dll
+else
+INC = -I/usr/local/include/python1.5
+MODULE_EXTENSION=so
+endif
+
+%.o: ../src/%.cpp
+	como --pic $(INC) -o $*.o -c $<
+
+%.d: ../src/%.cpp
+	@echo creating $@
+	@set -e; como -M $(INC) -c $< \
+            | sed 's/\($*\)\.o[ :]*/\1.o $@ : /g' > $@; \
+                [ -s $@ ] || rm -f $@
+
+getting_started1: getting_started1.o libboost_python.a
+	como-dyn-link -o ../example/getting_started1.$(MODULE_EXTENSION) $(PYTHON_LIB) getting_started1.o -L. -lboost_python
+	ln -s ../test/doctest.py ../example
+	python ../example/test_getting_started1.py
+
+getting_started1.o: ../example/getting_started1.cpp
+	como --pic $(INC) -o $*.o -c $<
+
+clean:
+	rm -rf *.o *.$(MODULE_EXTENSION) *.a *.d *.pyc *.bak a.out
+
+libboost_python.a: $(LIBOBJ)
+	rm -f libboost_python.a
+	ar cq libboost_python.a $(LIBOBJ)
+
+DEP = $(OBJ:.o=.d)
+
+ifneq "$(MAKECMDGOALS)" "clean"
+include $(DEP)
+endif

build/filemgr.py

@@ -0,0 +1,146 @@
+# Revision history:
+#   12 Apr 01 use os.path, shutil
+#   Initial version: R.W. Grosse-Kunstleve
+
+bpl_src = "/libs/python/src"
+bpl_tst = "/libs/python/test"
+bpl_exa = "/libs/python/example"
+files = (
+bpl_src + "/classes.cpp",
+bpl_src + "/conversions.cpp",
+bpl_src + "/errors.cpp",
+bpl_src + "/extension_class.cpp",
+bpl_src + "/functions.cpp",
+bpl_src + "/init_function.cpp",
+bpl_src + "/module_builder.cpp",
+bpl_src + "/objects.cpp",
+bpl_src + "/types.cpp",
+bpl_src + "/cross_module.cpp",
+bpl_tst + "/comprehensive.cpp",
+bpl_tst + "/comprehensive.hpp",
+bpl_tst + "/comprehensive.py",
+bpl_tst + "/doctest.py",
+bpl_exa + "/abstract.cpp",
+bpl_exa + "/getting_started1.cpp",
+bpl_exa + "/getting_started2.cpp",
+bpl_exa + "/simple_vector.cpp",
+bpl_exa + "/do_it_yourself_convts.cpp",
+bpl_exa + "/nested.cpp",
+bpl_exa + "/pickle1.cpp",
+bpl_exa + "/pickle2.cpp",
+bpl_exa + "/pickle3.cpp",
+bpl_exa + "/test_abstract.py",
+bpl_exa + "/test_getting_started1.py",
+bpl_exa + "/test_getting_started2.py",
+bpl_exa + "/test_simple_vector.py",
+bpl_exa + "/test_do_it_yourself_convts.py",
+bpl_exa + "/test_nested.py",
+bpl_exa + "/test_pickle1.py",
+bpl_exa + "/test_pickle2.py",
+bpl_exa + "/test_pickle3.py",
+bpl_exa + "/noncopyable.h",
+bpl_exa + "/noncopyable_export.cpp",
+bpl_exa + "/noncopyable_import.cpp",
+bpl_exa + "/dvect.h",
+bpl_exa + "/dvect.cpp",
+bpl_exa + "/dvect_conversions.cpp",
+bpl_exa + "/dvect_defs.cpp",
+bpl_exa + "/ivect.h",
+bpl_exa + "/ivect.cpp",
+bpl_exa + "/ivect_conversions.cpp",
+bpl_exa + "/ivect_defs.cpp",
+bpl_exa + "/tst_noncopyable.py",
+bpl_exa + "/tst_dvect1.py",
+bpl_exa + "/tst_dvect2.py",
+bpl_exa + "/tst_ivect1.py",
+bpl_exa + "/tst_ivect2.py",
+bpl_exa + "/test_cross_module.py",
+bpl_exa + "/vector_wrapper.h",
+bpl_exa + "/richcmp1.cpp",
+bpl_exa + "/richcmp2.cpp",
+bpl_exa + "/richcmp3.cpp",
+bpl_exa + "/test_richcmp1.py",
+bpl_exa + "/test_richcmp2.py",
+bpl_exa + "/test_richcmp3.py",
+)
+
+defs = (
+"boost_python_test",
+"abstract",
+"getting_started1",
+"getting_started2",
+"simple_vector",
+"do_it_yourself_convts",
+"nested",
+"pickle1",
+"pickle2",
+"pickle3",
+"noncopyable_export",
+"noncopyable_import",
+"ivect",
+"dvect",
+"richcmp1",
+"richcmp2",
+"richcmp3",
+)
+
+if (__name__ == "__main__"):
+
+  import sys, os, shutil
+
+  path = sys.argv[1]
+  mode = sys.argv[2]
+  if (not mode in ("softlinks", "unlink", "cp", "rm", "copy", "del")):
+    raise RuntimeError, \
+      "usage: python filemgr.py path <softlinks|unlink|cp|rm|copy|del>"
+
+  if (mode in ("cp", "copy")):
+    for fn in files:
+      f = os.path.basename(fn)
+      print "Copying: " + f
+      shutil.copy(path + fn, ".")
+
+  elif (mode == "softlinks"):
+    for fn in files:
+      f = os.path.basename(fn)
+      if (os.path.exists(f)):
+        print "File exists: " + f
+      else:
+        print "Linking: " + f
+        os.symlink(path + fn, f)
+
+  elif (mode in ("rm", "del")):
+    for fn in files:
+      f = os.path.basename(fn)
+      if (os.path.exists(f)):
+        print "Removing: " + f
+        try: os.unlink(f)
+        except: pass
+
+  elif (mode == "unlink"):
+    for fn in files:
+      f = os.path.basename(fn)
+      if (os.path.exists(f)):
+        if (os.path.islink(f)):
+          print "Unlinking: " + f
+          try: os.unlink(f)
+          except: pass
+        else:
+          print "Not a softlink: " + f
+
+  if (mode in ("softlinks", "cp", "copy")):
+    for d in defs:
+      fn = d + ".def"
+      print "Creating: " + fn
+      f = open(fn, "w")
+      f.write("EXPORTS\n")
+      f.write("\tinit" + d + "\n")
+      f.close()
+
+  if (mode in ("unlink", "rm", "del")):
+    for d in defs:
+      fn = d + ".def"
+      if (os.path.exists(fn)):
+        print "Removing: " + fn
+        try: os.unlink(fn)
+        except: pass

build/gcc.mak

@@ -0,0 +1,88 @@
+#  Revision History
+
+#  17 Apr 01 include cross-module support, compile getting_started1 (R.W. Grosse-Kunstleve)
+#  17 Apr 01 build shared library (patch provided by Dan Nuffer)
+#  04 Mar 01 Changed library name to libboost_python.a, various cleanups,
+#            attempted Cygwin compatibility. Still needs testing on Linux
+#            (David Abrahams)
+
+
+LIBSRC = \
+    classes.cpp \
+    conversions.cpp \
+    cross_module.cpp \
+    errors.cpp \
+    extension_class.cpp \
+    functions.cpp \
+    init_function.cpp \
+    module_builder.cpp \
+    objects.cpp \
+    types.cpp
+
+LIBOBJ = $(LIBSRC:.cpp=.o)
+OBJ = $(LIBOBJ)
+
+LIBNAME = libboost_python
+# libpython2.0.dll
+
+ifeq "$(OS)" "Windows_NT"
+ROOT=c:/cygnus
+INC = -Ic:/cygnus/usr/include/g++-3 -Ic:/cygnus/usr/include -Ic:/boost -I$(PYTHON_INC)
+MODULE_EXTENSION=dll
+PYTHON_LIB=c:/cygnus/usr/local/lib/python2.0/config/libpython2.0.dll.a
+SHARED_LIB = $(LIBNAME).dll
+else
+PYTHON_INC=$(ROOT)/usr/local/Python-2.0/include/python2.0
+BOOST_INC=../../..
+INC = -I$(BOOST_INC) -I$(PYTHON_INC)
+MODULE_EXTENSION=so
+VERSION=1
+SHARED_LIB = $(LIBNAME).so.$(VERSION)
+endif
+
+%.o: ../src/%.cpp
+	g++ -fPIC -Wall -W $(INC) $(CXXFLAGS) -o $*.o -c $<
+
+%.d: ../src/%.cpp
+	@echo creating $@
+	@set -e; g++ -M $(INC) -c $< \
+            | sed 's/\($*\)\.o[ :]*/\1.o $@ : /g' > $@; \
+                [ -s $@ ] || rm -f $@
+
+
+PYTHON = python
+
+all: test $(SHARED_LIB) getting_started1
+
+test: comprehensive.o $(LIBNAME).a $(SHARED_LIB)
+	g++ $(CXXFLAGS) -shared -o ../test/boost_python_test.$(MODULE_EXTENSION) comprehensive.o -L. -lboost_python  $(PYTHON_LIB)
+	$(PYTHON) ../test/comprehensive.py
+
+comprehensive.o: ../test/comprehensive.cpp
+	g++ $(CXXFLAGS) --template-depth-32 -fPIC -Wall -W $(INC) -o $*.o -c $<
+
+
+getting_started1: getting_started1.o $(LIBNAME).a
+	g++ $(CXXFLAGS) -shared -o ../example/getting_started1.$(MODULE_EXTENSION) getting_started1.o -L. -lboost_python  $(PYTHON_LIB)
+	ln -s ../test/doctest.py ../example
+	$(PYTHON) ../example/test_getting_started1.py
+
+getting_started1.o: ../example/getting_started1.cpp
+	g++ $(CXXFLAGS) --template-depth-32 -fPIC -Wall -W $(INC) -o $*.o -c $<
+
+
+clean:
+	rm -rf *.o *.$(MODULE_EXTENSION) *.a *.d *.pyc *.bak a.out
+
+$(LIBNAME).a: $(LIBOBJ)
+	rm -f $@
+	ar cqs $@ $(LIBOBJ)
+
+$(SHARED_LIB): $(LIBOBJ)
+	g++ $(CXXFLAGS) -shared -o $@ -Wl,--soname=$(LIBNAME).$(MODULE_EXTENSION)
+
+DEP = $(OBJ:.o=.d)
+
+ifneq "$(MAKECMDGOALS)" "clean"
+include $(DEP)
+endif

build/irix_CC.mak

@@ -0,0 +1,184 @@
+# Usage:
+#
+#   Create a new empty directory anywhere (preferably not in the boost tree).
+#   Copy this Makefile to that new directory and rename it to "Makefile"
+#   Adjust the pathnames below.
+#
+#   make softlinks     Create softlinks to source code and tests
+#   make               Compile all sources
+#   make test          Run doctest tests
+#   make clean         Remove all object files
+#   make unlink        Remove softlinks
+#
+# Revision history:
+#   12 Apr 01 new macro ROOT to simplify configuration (R.W. Grosse-Kunstleve)
+#   Initial version: R.W. Grosse-Kunstleve
+
+ROOT=$(HOME)
+BOOST=$(ROOT)/boost
+
+#PYEXE=PYTHONPATH=. /usr/local/Python-1.5.2/bin/python
+#PYINC=-I/usr/local/Python-1.5.2/include/python1.5
+PYEXE=PYTHONPATH=. /usr/local_cci/Python-2.1.1/bin/python
+PYINC=-I/usr/local_cci/Python-2.1.1/include/python2.1
+STLPORTINC=-I$(BOOST)/boost/compatibility/cpp_c_headers
+
+STDOPTS=
+WARNOPTS=-woff 1001,1234,1682
+OPTOPTS=-g
+
+CPP=CC -LANG:std -n32 -mips4
+CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
+        $(STDOPTS) $(WARNOPTS) $(OPTOPTS)
+MAKEDEP=-M
+
+LD=CC -LANG:std -n32 -mips4
+LDOPTS=-shared
+
+OBJ=classes.o conversions.o errors.o extension_class.o functions.o \
+    init_function.o module_builder.o \
+    objects.o types.o cross_module.o
+DEPOBJ=$(OBJ) \
+       comprehensive.o \
+       abstract.o \
+       getting_started1.o getting_started2.o \
+       simple_vector.o \
+       do_it_yourself_convts.o \
+       nested.o \
+       pickle1.o pickle2.o pickle3.o \
+       noncopyable_export.o noncopyable_import.o \
+       ivect.o dvect.o \
+       richcmp1.o richcmp2.o richcmp3.o
+
+.SUFFIXES: .o .cpp
+
+all: libboost_python.a \
+     boost_python_test.so \
+     abstract.so \
+     getting_started1.so getting_started2.so \
+     simple_vector.so \
+     do_it_yourself_convts.so \
+     nested.so \
+     pickle1.so pickle2.so pickle3.so \
+     noncopyable_export.so noncopyable_import.so \
+     ivect.so dvect.so \
+     richcmp1.so richcmp2.so richcmp3.so
+
+libboost_python.a: $(OBJ)
+	rm -f libboost_python.a
+	$(CPP) -ar -o libboost_python.a $(OBJ)
+
+boost_python_test.so: $(OBJ) comprehensive.o
+	$(LD) $(LDOPTS) $(OBJ) comprehensive.o -o boost_python_test.so -lm
+
+abstract.so: $(OBJ) abstract.o
+	$(LD) $(LDOPTS) $(OBJ) abstract.o -o abstract.so
+
+getting_started1.so: $(OBJ) getting_started1.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started1.o -o getting_started1.so
+
+getting_started2.so: $(OBJ) getting_started2.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started2.o -o getting_started2.so
+
+simple_vector.so: $(OBJ) simple_vector.o
+	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
+
+do_it_yourself_convts.so: $(OBJ) do_it_yourself_convts.o
+	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_convts.o -o do_it_yourself_convts.so
+
+nested.so: $(OBJ) nested.o
+	$(LD) $(LDOPTS) $(OBJ) nested.o -o nested.so
+
+pickle1.so: $(OBJ) pickle1.o
+	$(LD) $(LDOPTS) $(OBJ) pickle1.o -o pickle1.so
+
+pickle2.so: $(OBJ) pickle2.o
+	$(LD) $(LDOPTS) $(OBJ) pickle2.o -o pickle2.so
+
+pickle3.so: $(OBJ) pickle3.o
+	$(LD) $(LDOPTS) $(OBJ) pickle3.o -o pickle3.so
+
+noncopyable_export.so: $(OBJ) noncopyable_export.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) \
+          noncopyable_export.o -o noncopyable_export.so
+
+noncopyable_import.so: $(OBJ) noncopyable_import.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) \
+          noncopyable_import.o -o noncopyable_import.so
+
+ivect.so: $(OBJ) ivect.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) ivect.o -o ivect.so
+
+dvect.so: $(OBJ) dvect.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) dvect.o -o dvect.so
+
+richcmp1.so: $(OBJ) richcmp1.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp1.o -o richcmp1.so
+
+richcmp2.so: $(OBJ) richcmp2.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp2.o -o richcmp2.so
+
+richcmp3.so: $(OBJ) richcmp3.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp3.o -o richcmp3.so
+
+.cpp.o:
+	$(CPP) $(CPPOPTS) -c $*.cpp
+
+test:
+	$(PYEXE) comprehensive.py
+	$(PYEXE) test_abstract.py
+	$(PYEXE) test_getting_started1.py
+	$(PYEXE) test_getting_started2.py
+	$(PYEXE) test_simple_vector.py
+	$(PYEXE) test_do_it_yourself_convts.py
+	$(PYEXE) test_nested.py
+	$(PYEXE) test_pickle1.py
+	$(PYEXE) test_pickle2.py
+	$(PYEXE) test_pickle3.py
+	$(PYEXE) test_cross_module.py
+	$(PYEXE) test_richcmp1.py
+	$(PYEXE) test_richcmp2.py
+	$(PYEXE) test_richcmp3.py
+
+clean:
+	rm -f $(OBJ) libboost_python.a libboost_python.a.input
+	rm -f comprehensive.o boost_python_test.so
+	rm -f abstract.o abstract.so
+	rm -f getting_started1.o getting_started1.so
+	rm -f getting_started2.o getting_started2.so
+	rm -f simple_vector.o simple_vector.so
+	rm -f do_it_yourself_convts.o do_it_yourself_convts.so
+	rm -f nested.o nested.so
+	rm -f pickle1.o pickle1.so
+	rm -f pickle2.o pickle2.so
+	rm -f pickle3.o pickle3.so
+	rm -f noncopyable_export.o noncopyable_export.so
+	rm -f noncopyable_import.o noncopyable_import.so
+	rm -f ivect.o ivect.so
+	rm -f dvect.o dvect.so
+	rm -f richcmp1.o richcmp1.so
+	rm -f richcmp2.o richcmp2.so
+	rm -f richcmp3.o richcmp3.so
+	rm -f so_locations *.pyc
+	rm -rf ii_files
+
+softlinks:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) softlinks
+
+unlink:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) unlink
+
+cp:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) cp
+
+rm:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) rm
+
+depend:
+	@ cat Makefile.nodepend; \
+          for obj in $(DEPOBJ); \
+          do \
+            bn=`echo "$$obj" | cut -d. -f1`; \
+            $(CPP) $(CPPOPTS) $(MAKEDEP) "$$bn".cpp; \
+          done
+

build/linux_gcc.mak

@@ -0,0 +1,184 @@
+# Usage:
+#
+#   Create a new empty directory anywhere (preferably not in the boost tree).
+#   Copy this Makefile to that new directory and rename it to "Makefile"
+#   Adjust the pathnames below.
+#
+#   make softlinks     Create softlinks to source code and tests
+#   make               Compile all sources
+#   make test          Run doctest tests
+#   make clean         Remove all object files
+#   make unlink        Remove softlinks
+#
+# Revision history:
+#   12 Apr 01 new macro ROOT to simplify configuration (R.W. Grosse-Kunstleve)
+#   Initial version: R.W. Grosse-Kunstleve
+
+ROOT=$(HOME)
+BOOST=$(ROOT)/boost
+
+#PYEXE=PYTHONPATH=. /usr/bin/python
+#PYINC=-I/usr/include/python1.5
+#PYEXE=PYTHONPATH=. /usr/local/Python-1.5.2/bin/python
+#PYINC=-I/usr/local/Python-1.5.2/include/python1.5
+PYEXE=PYTHONPATH=. /usr/local_cci/Python-2.1.1/bin/python
+PYINC=-I/usr/local_cci/Python-2.1.1/include/python2.1
+
+STDOPTS=-fPIC -ftemplate-depth-21
+WARNOPTS=
+OPTOPTS=-g
+
+CPP=g++
+CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
+        $(STDOPTS) $(WARNOPTS) $(OPTOPTS)
+MAKEDEP=-M
+
+LD=$(CPP)
+LDOPTS=-shared
+
+OBJ=classes.o conversions.o errors.o extension_class.o functions.o \
+    init_function.o module_builder.o \
+    objects.o types.o cross_module.o
+DEPOBJ=$(OBJ) \
+       comprehensive.o \
+       abstract.o \
+       getting_started1.o getting_started2.o \
+       simple_vector.o \
+       do_it_yourself_convts.o \
+       nested.o \
+       pickle1.o pickle2.o pickle3.o \
+       noncopyable_export.o noncopyable_import.o \
+       ivect.o dvect.o \
+       richcmp1.o richcmp2.o richcmp3.o
+
+.SUFFIXES: .o .cpp
+
+all: libboost_python.a \
+     boost_python_test.so \
+     abstract.so \
+     getting_started1.so getting_started2.so \
+     simple_vector.so \
+     do_it_yourself_convts.so \
+     nested.so \
+     pickle1.so pickle2.so pickle3.so \
+     noncopyable_export.so noncopyable_import.so \
+     ivect.so dvect.so \
+     richcmp1.so richcmp2.so richcmp3.so
+
+libboost_python.a: $(OBJ)
+	rm -f libboost_python.a
+	ar r libboost_python.a $(OBJ)
+
+boost_python_test.so: $(OBJ) comprehensive.o
+	$(LD) $(LDOPTS) $(OBJ) comprehensive.o -o boost_python_test.so -lm
+
+abstract.so: $(OBJ) abstract.o
+	$(LD) $(LDOPTS) $(OBJ) abstract.o -o abstract.so
+
+getting_started1.so: $(OBJ) getting_started1.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started1.o -o getting_started1.so
+
+getting_started2.so: $(OBJ) getting_started2.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started2.o -o getting_started2.so
+
+simple_vector.so: $(OBJ) simple_vector.o
+	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
+
+do_it_yourself_convts.so: $(OBJ) do_it_yourself_convts.o
+	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_convts.o -o do_it_yourself_convts.so
+
+nested.so: $(OBJ) nested.o
+	$(LD) $(LDOPTS) $(OBJ) nested.o -o nested.so
+
+pickle1.so: $(OBJ) pickle1.o
+	$(LD) $(LDOPTS) $(OBJ) pickle1.o -o pickle1.so
+
+pickle2.so: $(OBJ) pickle2.o
+	$(LD) $(LDOPTS) $(OBJ) pickle2.o -o pickle2.so
+
+pickle3.so: $(OBJ) pickle3.o
+	$(LD) $(LDOPTS) $(OBJ) pickle3.o -o pickle3.so
+
+noncopyable_export.so: $(OBJ) noncopyable_export.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) \
+          noncopyable_export.o -o noncopyable_export.so
+
+noncopyable_import.so: $(OBJ) noncopyable_import.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) \
+          noncopyable_import.o -o noncopyable_import.so
+
+ivect.so: $(OBJ) ivect.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) ivect.o -o ivect.so
+
+dvect.so: $(OBJ) dvect.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) dvect.o -o dvect.so
+
+richcmp1.so: $(OBJ) richcmp1.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp1.o -o richcmp1.so
+
+richcmp2.so: $(OBJ) richcmp2.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp2.o -o richcmp2.so
+
+richcmp3.so: $(OBJ) richcmp3.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp3.o -o richcmp3.so
+
+.cpp.o:
+	$(CPP) $(CPPOPTS) -c $*.cpp
+
+test:
+	$(PYEXE) comprehensive.py
+	$(PYEXE) test_abstract.py
+	$(PYEXE) test_getting_started1.py
+	$(PYEXE) test_getting_started2.py
+	$(PYEXE) test_simple_vector.py
+	$(PYEXE) test_do_it_yourself_convts.py
+	$(PYEXE) test_nested.py
+	$(PYEXE) test_pickle1.py
+	$(PYEXE) test_pickle2.py
+	$(PYEXE) test_pickle3.py
+	$(PYEXE) test_cross_module.py
+	$(PYEXE) test_richcmp1.py
+	$(PYEXE) test_richcmp2.py
+	$(PYEXE) test_richcmp3.py
+
+clean:
+	rm -f $(OBJ) libboost_python.a libboost_python.a.input
+	rm -f comprehensive.o boost_python_test.so
+	rm -f abstract.o abstract.so
+	rm -f getting_started1.o getting_started1.so
+	rm -f getting_started2.o getting_started2.so
+	rm -f simple_vector.o simple_vector.so
+	rm -f do_it_yourself_convts.o do_it_yourself_convts.so
+	rm -f nested.o nested.so
+	rm -f pickle1.o pickle1.so
+	rm -f pickle2.o pickle2.so
+	rm -f pickle3.o pickle3.so
+	rm -f noncopyable_export.o noncopyable_export.so
+	rm -f noncopyable_import.o noncopyable_import.so
+	rm -f ivect.o ivect.so
+	rm -f dvect.o dvect.so
+	rm -f richcmp1.o richcmp1.so
+	rm -f richcmp2.o richcmp2.so
+	rm -f richcmp3.o richcmp3.so
+	rm -f so_locations *.pyc
+
+softlinks:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) softlinks
+
+unlink:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) unlink
+
+cp:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) cp
+
+rm:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) rm
+
+depend:
+	@ cat Makefile.nodepend; \
+          for obj in $(DEPOBJ); \
+          do \
+            bn=`echo "$$obj" | cut -d. -f1`; \
+            $(CPP) $(CPPOPTS) $(MAKEDEP) "$$bn".cpp; \
+          done
+

build/mingw32.mak

@@ -0,0 +1,222 @@
+# Usage:
+#
+#   make copy          Copy the sources and tests
+#   make               Compile all sources
+#   make test          Run doctest tests
+#   make clean         Remove all object files
+#   make del           Remove the sources and tests
+#
+# Revision history:
+#   12 Apr 01 new macro ROOT to simplify configuration (R.W. Grosse-Kunstleve)
+#   Initial version: R.W. Grosse-Kunstleve
+
+# To install mingw32, follow instructions at:
+#   http://starship.python.net/crew/kernr/mingw32/Notes.html
+# In particular, install:
+#   ftp://ftp.xraylith.wisc.edu/pub/khan/gnu-win32/mingw32/gcc-2.95.2/gcc-2.95.2-msvcrt.exe
+#   ftp://ftp.xraylith.wisc.edu/pub/khan/gnu-win32/mingw32/gcc-2.95.2/fixes/quote-fix-msvcrt.exe
+#   http://starship.python.net/crew/kernr/mingw32/Python-1.5.2-mingw32.zip
+# Unpack the first two archives in the default locations and update your PATH.
+# Unpack the third archive in \usr.
+
+# Note: comprehensive.cpp generates compiler errors and later crashes.
+#   L:\boost\boost\python\detail\extension_class.hpp:643: warning:
+#   alignment of `vtable for class
+#   boost::python::detail::held_instance<bpl_test::Derived1>'
+#   is greater than maximum object file alignment. Using 16.
+# Could this be fixed with compiler options?
+# -fhuge-objects looks interesting, but requires recompiling the C++ library.
+#                (what exactly does that mean?)
+# -fvtable-thunks eliminates the compiler warning, but
+#                 "import boost_python_test" still causes a crash.
+
+ROOT=R:
+BOOST_WIN="$(ROOT)\boost"
+BOOST_UNIX=$(HOME)/boost
+
+PYEXE="C:\Program files\Python\python.exe"
+PYINC=-I"C:\usr\include\python1.5"
+PYLIB="C:\usr\lib\libpython15.a"
+#PYEXE="C:\Python21\python.exe"
+#PYINC=-I"C:\usr\include\python2.1"
+#PYLIB="C:\usr\lib\libpython21.a"
+
+STDOPTS=-ftemplate-depth-21
+WARNOPTS=
+OPTOPTS=-g
+
+CPP=g++
+CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) -I$(BOOST_WIN) $(PYINC) \
+        $(STDOPTS) $(WARNOPTS) $(OPTOPTS)
+
+LD=g++
+LDOPTS=-shared
+
+OBJ=classes.o conversions.o errors.o extension_class.o functions.o \
+    init_function.o module_builder.o \
+    objects.o types.o cross_module.o
+
+.SUFFIXES: .o .cpp
+
+all: libboost_python.a \
+     abstract.pyd \
+     getting_started1.pyd getting_started2.pyd \
+     simple_vector.pyd \
+     do_it_yourself_convts.pyd \
+     nested.pyd \
+     pickle1.pyd pickle2.pyd pickle3.pyd \
+     noncopyable_export.pyd noncopyable_import.pyd \
+     ivect.pyd dvect.pyd \
+     richcmp1.pyd richcmp2.pyd richcmp3.pyd
+
+libboost_python.a: $(OBJ)
+	-del libboost_python.a
+	ar r libboost_python.a $(OBJ)
+
+DLLWRAPOPTS=-s --driver-name g++ -s \
+            --entry _DllMainCRTStartup@12 --target=i386-mingw32
+
+boost_python_test.pyd: $(OBJ) comprehensive.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname boost_python_test.pyd \
+          --def boost_python_test.def \
+          $(OBJ) comprehensive.o $(PYLIB)
+
+abstract.pyd: $(OBJ) abstract.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname abstract.pyd \
+          --def abstract.def \
+          $(OBJ) abstract.o $(PYLIB)
+
+getting_started1.pyd: $(OBJ) getting_started1.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname getting_started1.pyd \
+          --def getting_started1.def \
+          $(OBJ) getting_started1.o $(PYLIB)
+
+getting_started2.pyd: $(OBJ) getting_started2.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname getting_started2.pyd \
+          --def getting_started2.def \
+          $(OBJ) getting_started2.o $(PYLIB)
+
+simple_vector.pyd: $(OBJ) simple_vector.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname simple_vector.pyd \
+          --def simple_vector.def \
+          $(OBJ) simple_vector.o $(PYLIB)
+
+do_it_yourself_convts.pyd: $(OBJ) do_it_yourself_convts.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname do_it_yourself_convts.pyd \
+          --def do_it_yourself_convts.def \
+          $(OBJ) do_it_yourself_convts.o $(PYLIB)
+
+nested.pyd: $(OBJ) nested.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname nested.pyd \
+          --def nested.def \
+          $(OBJ) nested.o $(PYLIB)
+
+pickle1.pyd: $(OBJ) pickle1.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname pickle1.pyd \
+          --def pickle1.def \
+          $(OBJ) pickle1.o $(PYLIB)
+
+pickle2.pyd: $(OBJ) pickle2.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname pickle2.pyd \
+          --def pickle2.def \
+          $(OBJ) pickle2.o $(PYLIB)
+
+pickle3.pyd: $(OBJ) pickle3.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname pickle3.pyd \
+          --def pickle3.def \
+          $(OBJ) pickle3.o $(PYLIB)
+
+noncopyable_export.pyd: $(OBJ) noncopyable_export.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname noncopyable_export.pyd \
+          --def noncopyable_export.def \
+          $(OBJ) noncopyable_export.o $(PYLIB)
+
+noncopyable_import.pyd: $(OBJ) noncopyable_import.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname noncopyable_import.pyd \
+          --def noncopyable_import.def \
+          $(OBJ) noncopyable_import.o $(PYLIB)
+
+ivect.pyd: $(OBJ) ivect.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname ivect.pyd \
+          --def ivect.def \
+          $(OBJ) ivect.o $(PYLIB)
+
+dvect.pyd: $(OBJ) dvect.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname dvect.pyd \
+          --def dvect.def \
+          $(OBJ) dvect.o $(PYLIB)
+
+richcmp1.pyd: $(OBJ) richcmp1.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname richcmp1.pyd \
+          --def richcmp1.def \
+          $(OBJ) richcmp1.o $(PYLIB)
+
+richcmp2.pyd: $(OBJ) richcmp2.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname richcmp2.pyd \
+          --def richcmp2.def \
+          $(OBJ) richcmp2.o $(PYLIB)
+
+richcmp3.pyd: $(OBJ) richcmp3.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname richcmp3.pyd \
+          --def richcmp3.def \
+          $(OBJ) richcmp3.o $(PYLIB)
+
+.cpp.o:
+	$(CPP) $(CPPOPTS) -c $*.cpp
+
+test:
+#	$(PYEXE) comprehensive.py
+	$(PYEXE) test_abstract.py
+	$(PYEXE) test_getting_started1.py
+	$(PYEXE) test_getting_started2.py
+	$(PYEXE) test_simple_vector.py
+	$(PYEXE) test_do_it_yourself_convts.py
+	$(PYEXE) test_nested.py
+	$(PYEXE) test_pickle1.py
+	$(PYEXE) test_pickle2.py
+	$(PYEXE) test_pickle3.py
+	$(PYEXE) test_cross_module.py
+	$(PYEXE) test_richcmp1.py
+	$(PYEXE) test_richcmp2.py
+	$(PYEXE) test_richcmp3.py
+
+clean:
+	-del *.o
+	-del *.a
+	-del *.pyd
+	-del *.pyc
+
+softlinks:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) softlinks
+
+unlink:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) unlink
+
+cp:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) cp
+
+rm:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) rm
+
+copy:
+	$(PYEXE) $(BOOST_WIN)\libs\python\build\filemgr.py $(BOOST_WIN) copy
+
+del:
+	$(PYEXE) $(BOOST_WIN)\libs\python\build\filemgr.py $(BOOST_WIN) del

build/tru64_cxx.mak

@@ -0,0 +1,199 @@
+# Usage:
+#
+#   Create a new empty directory anywhere (preferably not in the boost tree).
+#   Copy this Makefile to that new directory and rename it to "Makefile"
+#   Adjust the pathnames below.
+#
+#   make softlinks     Create softlinks to source code and tests
+#   make               Compile all sources
+#   make test          Run doctest tests
+#   make clean         Remove all object files
+#   make unlink        Remove softlinks
+#
+# Revision history:
+#   12 Apr 01 new macro ROOT to simplify configuration (R.W. Grosse-Kunstleve)
+#   Initial version: R.W. Grosse-Kunstleve
+
+ROOT=$(HOME)
+BOOST=$(ROOT)/boost
+
+#PYEXE=PYTHONPATH=. /usr/local/Python-1.5.2/bin/python
+#PYINC=-I/usr/local/Python-1.5.2/include/python1.5
+PYEXE=PYTHONPATH=. /usr/local_cci/Python-2.1.1/bin/python
+PYINC=-I/usr/local_cci/Python-2.1.1/include/python2.1
+#STLPORTINC=-I/usr/local/STLport-4.1b3/stlport
+#STLPORTINC=-I/usr/local/STLport-4.1b4/stlport
+#STLPORTOPTS= \
+# -D__USE_STD_IOSTREAM \
+# -D__STL_NO_SGI_IOSTREAMS \
+# -D__STL_USE_NATIVE_STRING \
+# -D__STL_NO_NEW_C_HEADERS \
+# -D_RWSTD_COMPILE_INSTANTIATE=1
+STLPORTINC=-I$(BOOST)/boost/compatibility/cpp_c_headers
+
+STDOPTS=-std strict_ansi
+# use -msg_display_number to obtain integer tags for -msg_disable
+WARNOPTS=-msg_disable 186,450,1115
+OPTOPTS=-g
+
+CPP=cxx
+CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
+        $(STDOPTS) $(WARNOPTS) $(OPTOPTS)
+MAKEDEP=-Em
+
+LD=cxx
+LDOPTS=-shared -expect_unresolved 'Py*' -expect_unresolved '_Py*'
+
+#HIDDEN=-hidden
+
+OBJ=classes.o conversions.o errors.o extension_class.o functions.o \
+    init_function.o module_builder.o \
+    objects.o types.o cross_module.o
+DEPOBJ=$(OBJ) \
+       comprehensive.o \
+       abstract.o \
+       getting_started1.o getting_started2.o \
+       simple_vector.o \
+       do_it_yourself_convts.o \
+       nested.o \
+       pickle1.o pickle2.o pickle3.o \
+       noncopyable_export.o noncopyable_import.o \
+       ivect.o dvect.o \
+       richcmp1.o richcmp2.o richcmp3.o
+
+.SUFFIXES: .o .cpp
+
+all: libboost_python.a \
+     boost_python_test.so \
+     abstract.so \
+     getting_started1.so getting_started2.so \
+     simple_vector.so \
+     do_it_yourself_convts.so \
+     nested.so \
+     pickle1.so pickle2.so pickle3.so \
+     noncopyable_export.so noncopyable_import.so \
+     ivect.so dvect.so \
+     richcmp1.so richcmp2.so richcmp3.so
+
+libboost_python.a: $(OBJ)
+	rm -f libboost_python.a
+	cd cxx_repository; \
+          ls -1 > ../libboost_python.a.input; \
+          ar r ../libboost_python.a -input ../libboost_python.a.input
+	rm -f libboost_python.a.input
+	ar r libboost_python.a $(OBJ)
+
+boost_python_test.so: $(OBJ) comprehensive.o
+	$(LD) $(LDOPTS) $(OBJ) comprehensive.o -o boost_python_test.so -lm
+
+abstract.so: $(OBJ) abstract.o
+	$(LD) $(LDOPTS) $(OBJ) abstract.o -o abstract.so
+
+getting_started1.so: $(OBJ) getting_started1.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started1.o -o getting_started1.so
+
+getting_started2.so: $(OBJ) getting_started2.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started2.o -o getting_started2.so
+
+simple_vector.so: $(OBJ) simple_vector.o
+	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
+
+do_it_yourself_convts.so: $(OBJ) do_it_yourself_convts.o
+	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_convts.o -o do_it_yourself_convts.so
+
+nested.so: $(OBJ) nested.o
+	$(LD) $(LDOPTS) $(OBJ) nested.o -o nested.so
+
+pickle1.so: $(OBJ) pickle1.o
+	$(LD) $(LDOPTS) $(OBJ) pickle1.o -o pickle1.so
+
+pickle2.so: $(OBJ) pickle2.o
+	$(LD) $(LDOPTS) $(OBJ) pickle2.o -o pickle2.so
+
+pickle3.so: $(OBJ) pickle3.o
+	$(LD) $(LDOPTS) $(OBJ) pickle3.o -o pickle3.so
+
+noncopyable_export.so: $(OBJ) noncopyable_export.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) \
+          noncopyable_export.o -o noncopyable_export.so
+
+noncopyable_import.so: $(OBJ) noncopyable_import.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) \
+          noncopyable_import.o -o noncopyable_import.so
+
+ivect.so: $(OBJ) ivect.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) ivect.o -o ivect.so
+
+dvect.so: $(OBJ) dvect.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) dvect.o -o dvect.so
+
+richcmp1.so: $(OBJ) richcmp1.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp1.o -o richcmp1.so
+
+richcmp2.so: $(OBJ) richcmp2.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp2.o -o richcmp2.so
+
+richcmp3.so: $(OBJ) richcmp3.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp3.o -o richcmp3.so
+
+.cpp.o:
+	$(CPP) $(CPPOPTS) -c $*.cpp
+
+test:
+	$(PYEXE) comprehensive.py
+	$(PYEXE) test_abstract.py
+	$(PYEXE) test_getting_started1.py
+	$(PYEXE) test_getting_started2.py
+	$(PYEXE) test_simple_vector.py
+	$(PYEXE) test_do_it_yourself_convts.py
+	$(PYEXE) test_nested.py
+	$(PYEXE) test_pickle1.py
+	$(PYEXE) test_pickle2.py
+	$(PYEXE) test_pickle3.py
+	$(PYEXE) test_cross_module.py
+	$(PYEXE) test_richcmp1.py
+	$(PYEXE) test_richcmp2.py
+	$(PYEXE) test_richcmp3.py
+
+clean:
+	rm -f $(OBJ) libboost_python.a libboost_python.a.input
+	rm -f comprehensive.o boost_python_test.so
+	rm -f abstract.o abstract.so
+	rm -f getting_started1.o getting_started1.so
+	rm -f getting_started2.o getting_started2.so
+	rm -f simple_vector.o simple_vector.so
+	rm -f do_it_yourself_convts.o do_it_yourself_convts.so
+	rm -f nested.o nested.so
+	rm -f pickle1.o pickle1.so
+	rm -f pickle2.o pickle2.so
+	rm -f pickle3.o pickle3.so
+	rm -f noncopyable_export.o noncopyable_export.so
+	rm -f noncopyable_import.o noncopyable_import.so
+	rm -f ivect.o ivect.so
+	rm -f dvect.o dvect.so
+	rm -f richcmp1.o richcmp1.so
+	rm -f richcmp2.o richcmp2.so
+	rm -f richcmp3.o richcmp3.so
+	rm -f so_locations *.pyc
+	rm -rf cxx_repository
+
+softlinks:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) softlinks
+
+unlink:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) unlink
+
+cp:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) cp
+
+rm:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) rm
+
+depend:
+	@ cat Makefile.nodepend; \
+          for obj in $(DEPOBJ); \
+          do \
+            bn=`echo "$$obj" | cut -d. -f1`; \
+            $(CPP) $(CPPOPTS) $(MAKEDEP) "$$bn".cpp; \
+          done
+

build/vc60.mak

@@ -0,0 +1,154 @@
+# Usage:
+#
+#   Create a new empty directory anywhere (preferably not in the boost tree).
+#   Copy this Makefile to that new directory and rename it to "Makefile"
+#   Adjust the pathnames below.
+#
+#   make copy          Copy the sources and tests
+#   make               Compile all sources
+#   make test          Run doctest tests
+#   make clean         Remove all object files
+#   make del           Remove the sources and tests
+#
+# Revision history:
+#   12 Apr 01 new macro ROOT to simplify configuration (R.W. Grosse-Kunstleve)
+#   Initial version: R.W. Grosse-Kunstleve
+
+ROOT=R:
+BOOST_WIN="$(ROOT)\boost"
+BOOST_UNIX=$(HOME)/boost
+
+#PYEXE="C:\Program files\Python\python.exe"
+#PYINC=/I"C:\Program files\Python\include"
+#PYLIB="C:\Program files\Python\libs\python15.lib"
+PYEXE="C:\Python21\python.exe"
+PYINC=/I"C:\Python21\include"
+PYLIB="C:\Python21\libs\python21.lib"
+
+STDOPTS=/nologo /MD /GR /GX /Zm300 /DBOOST_PYTHON_STATIC_LIB
+WARNOPTS=
+OPTOPTS=
+
+CPP=cl.exe
+CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) /I$(BOOST_WIN) $(PYINC) \
+        $(STDOPTS) $(WARNOPTS) $(OPTOPTS)
+
+LD=link.exe
+LDOPTS=/nologo /dll /incremental:no
+
+OBJ=classes.obj conversions.obj errors.obj extension_class.obj functions.obj \
+    init_function.obj module_builder.obj \
+    objects.obj types.obj cross_module.obj
+
+.SUFFIXES: .obj .cpp
+
+all: boost_python.lib \
+     boost_python_test.pyd \
+     abstract.pyd \
+     getting_started1.pyd getting_started2.pyd \
+     simple_vector.pyd \
+     do_it_yourself_convts.pyd \
+     nested.pyd \
+     pickle1.pyd pickle2.pyd pickle3.pyd \
+     noncopyable_export.pyd noncopyable_import.pyd \
+     ivect.pyd dvect.pyd \
+     richcmp1.pyd richcmp2.pyd richcmp3.pyd
+
+boost_python.lib: $(OBJ)
+	$(LD) -lib /nologo /out:boost_python.lib $(OBJ)
+
+boost_python_test.pyd: $(OBJ) comprehensive.obj
+	$(LD) $(LDOPTS) $(OBJ) comprehensive.obj $(PYLIB) /export:initboost_python_test /out:"boost_python_test.pyd"
+
+abstract.pyd: $(OBJ) abstract.obj
+	$(LD) $(LDOPTS) $(OBJ) abstract.obj $(PYLIB) /export:initabstract /out:"abstract.pyd"
+
+getting_started1.pyd: $(OBJ) getting_started1.obj
+	$(LD) $(LDOPTS) $(OBJ) getting_started1.obj $(PYLIB) /export:initgetting_started1 /out:"getting_started1.pyd"
+
+getting_started2.pyd: $(OBJ) getting_started2.obj
+	$(LD) $(LDOPTS) $(OBJ) getting_started2.obj $(PYLIB) /export:initgetting_started2 /out:"getting_started2.pyd"
+
+simple_vector.pyd: $(OBJ) simple_vector.obj
+	$(LD) $(LDOPTS) $(OBJ) simple_vector.obj $(PYLIB) /export:initsimple_vector /out:"simple_vector.pyd"
+
+do_it_yourself_convts.pyd: $(OBJ) do_it_yourself_convts.obj
+	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_convts.obj $(PYLIB) /export:initdo_it_yourself_convts /out:"do_it_yourself_convts.pyd"
+
+nested.pyd: $(OBJ) nested.obj
+	$(LD) $(LDOPTS) $(OBJ) nested.obj $(PYLIB) /export:initnested /out:"nested.pyd"
+
+pickle1.pyd: $(OBJ) pickle1.obj
+	$(LD) $(LDOPTS) $(OBJ) pickle1.obj $(PYLIB) /export:initpickle1 /out:"pickle1.pyd"
+
+pickle2.pyd: $(OBJ) pickle2.obj
+	$(LD) $(LDOPTS) $(OBJ) pickle2.obj $(PYLIB) /export:initpickle2 /out:"pickle2.pyd"
+
+pickle3.pyd: $(OBJ) pickle3.obj
+	$(LD) $(LDOPTS) $(OBJ) pickle3.obj $(PYLIB) /export:initpickle3 /out:"pickle3.pyd"
+
+noncopyable_export.pyd: $(OBJ) noncopyable_export.obj
+	$(LD) $(LDOPTS) $(OBJ) noncopyable_export.obj $(PYLIB) /export:initnoncopyable_export /out:"noncopyable_export.pyd"
+
+noncopyable_import.pyd: $(OBJ) noncopyable_import.obj
+	$(LD) $(LDOPTS) $(OBJ) noncopyable_import.obj $(PYLIB) /export:initnoncopyable_import /out:"noncopyable_import.pyd"
+
+ivect.pyd: $(OBJ) ivect.obj
+	$(LD) $(LDOPTS) $(OBJ) ivect.obj $(PYLIB) /export:initivect /out:"ivect.pyd"
+
+dvect.pyd: $(OBJ) dvect.obj
+	$(LD) $(LDOPTS) $(OBJ) dvect.obj $(PYLIB) /export:initdvect /out:"dvect.pyd"
+
+richcmp1.pyd: $(OBJ) richcmp1.obj
+	$(LD) $(LDOPTS) $(OBJ) richcmp1.obj $(PYLIB) /export:initrichcmp1 /out:"richcmp1.pyd"
+
+richcmp2.pyd: $(OBJ) richcmp2.obj
+	$(LD) $(LDOPTS) $(OBJ) richcmp2.obj $(PYLIB) /export:initrichcmp2 /out:"richcmp2.pyd"
+
+richcmp3.pyd: $(OBJ) richcmp3.obj
+	$(LD) $(LDOPTS) $(OBJ) richcmp3.obj $(PYLIB) /export:initrichcmp3 /out:"richcmp3.pyd"
+
+.cpp.obj:
+	$(CPP) $(CPPOPTS) /c $*.cpp
+
+test:
+	$(PYEXE) comprehensive.py --broken-auto-ptr 
+	$(PYEXE) test_abstract.py
+	$(PYEXE) test_getting_started1.py
+	$(PYEXE) test_getting_started2.py
+	$(PYEXE) test_simple_vector.py
+	$(PYEXE) test_do_it_yourself_convts.py
+	$(PYEXE) test_nested.py
+	$(PYEXE) test_pickle1.py
+	$(PYEXE) test_pickle2.py
+	$(PYEXE) test_pickle3.py
+	$(PYEXE) test_cross_module.py --broken-auto-ptr
+	$(PYEXE) test_richcmp1.py
+	$(PYEXE) test_richcmp2.py
+	$(PYEXE) test_richcmp3.py
+
+clean:
+	-del *.obj
+	-del *.lib
+	-del *.exp
+	-del *.idb
+	-del *.pyd
+	-del *.pyc
+
+softlinks:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) softlinks
+
+unlink:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) unlink
+
+cp:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) cp
+
+rm:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) rm
+
+copy:
+	$(PYEXE) $(BOOST_WIN)\libs\python\build\filemgr.py $(BOOST_WIN) copy
+
+del:
+	$(PYEXE) $(BOOST_WIN)\libs\python\build\filemgr.py $(BOOST_WIN) del

build/win32_mwcc.mak

@@ -0,0 +1,149 @@
+# Usage:
+#
+#   make copy          Copy the sources and tests
+#   make               Compile all sources
+#   make test          Run doctest tests
+#   make clean         Remove all object files
+#   make del           Remove the sources and tests
+#
+# Revision history:
+#   14 Dec 01 derived from vc60.mak (R.W. Grosse-Kunstleve)
+
+ROOT=R:
+BOOST_WIN="$(ROOT)\boost"
+BOOST_UNIX=$(HOME)/boost
+
+#PYEXE="C:\Program files\Python\python.exe"
+#PYINC=-I"C:\Program files\Python\include"
+#PYLIB="C:\Program files\Python\libs\python15.lib"
+PYEXE="C:\Python21\python.exe"
+PYINC=-I"C:\Python21\include"
+PYLIB="C:\Python21\libs\python21.lib"
+
+STDOPTS=-gccinc -prefix UseDLLPrefix.h -DBOOST_PYTHON_STATIC_LIB
+WARNOPTS=-warn on,nounusedexpr,nounused
+OPTOPTS=-O
+
+CPP=mwcc
+CPPOPTS=$(STDOPTS) $(WARNOPTS) $(OPTOPTS) \
+        $(STLPORTINC) $(STLPORTOPTS) -I$(BOOST_WIN) $(PYINC)
+
+LD=mwld
+LDOPTS=-export dllexport -shared
+
+OBJ=classes.obj conversions.obj errors.obj extension_class.obj functions.obj \
+    init_function.obj module_builder.obj \
+    objects.obj types.obj cross_module.obj
+
+.SUFFIXES: .obj .cpp
+
+all: libboost_python.lib \
+     boost_python_test.pyd \
+     abstract.pyd \
+     getting_started1.pyd getting_started2.pyd \
+     simple_vector.pyd \
+     do_it_yourself_convts.pyd \
+     nested.pyd \
+     pickle1.pyd pickle2.pyd pickle3.pyd \
+     noncopyable_export.pyd noncopyable_import.pyd \
+     ivect.pyd dvect.pyd \
+     richcmp1.pyd richcmp2.pyd richcmp3.pyd
+
+libboost_python.lib: $(OBJ)
+	$(LD) -library -o libboost_python.lib $(OBJ)
+
+boost_python_test.pyd: $(OBJ) comprehensive.obj
+	$(LD) $(LDOPTS) $(OBJ) comprehensive.obj $(PYLIB) -o boost_python_test.pyd
+
+abstract.pyd: $(OBJ) abstract.obj
+	$(LD) $(LDOPTS) $(OBJ) abstract.obj $(PYLIB)  -o abstract.pyd
+
+getting_started1.pyd: $(OBJ) getting_started1.obj
+	$(LD) $(LDOPTS) $(OBJ) getting_started1.obj $(PYLIB)  -o getting_started1.pyd
+
+getting_started2.pyd: $(OBJ) getting_started2.obj
+	$(LD) $(LDOPTS) $(OBJ) getting_started2.obj $(PYLIB)  -o getting_started2.pyd
+
+simple_vector.pyd: $(OBJ) simple_vector.obj
+	$(LD) $(LDOPTS) $(OBJ) simple_vector.obj $(PYLIB)  -o simple_vector.pyd
+
+do_it_yourself_convts.pyd: $(OBJ) do_it_yourself_convts.obj
+	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_convts.obj $(PYLIB)  -o do_it_yourself_convts.pyd
+
+nested.pyd: $(OBJ) nested.obj
+	$(LD) $(LDOPTS) $(OBJ) nested.obj $(PYLIB)  -o nested.pyd
+
+pickle1.pyd: $(OBJ) pickle1.obj
+	$(LD) $(LDOPTS) $(OBJ) pickle1.obj $(PYLIB)  -o pickle1.pyd
+
+pickle2.pyd: $(OBJ) pickle2.obj
+	$(LD) $(LDOPTS) $(OBJ) pickle2.obj $(PYLIB)  -o pickle2.pyd
+
+pickle3.pyd: $(OBJ) pickle3.obj
+	$(LD) $(LDOPTS) $(OBJ) pickle3.obj $(PYLIB)  -o pickle3.pyd
+
+noncopyable_export.pyd: $(OBJ) noncopyable_export.obj
+	$(LD) $(LDOPTS) $(OBJ) noncopyable_export.obj $(PYLIB)  -o noncopyable_export.pyd
+
+noncopyable_import.pyd: $(OBJ) noncopyable_import.obj
+	$(LD) $(LDOPTS) $(OBJ) noncopyable_import.obj $(PYLIB)  -o noncopyable_import.pyd
+
+ivect.pyd: $(OBJ) ivect.obj
+	$(LD) $(LDOPTS) $(OBJ) ivect.obj $(PYLIB)  -o ivect.pyd
+
+dvect.pyd: $(OBJ) dvect.obj
+	$(LD) $(LDOPTS) $(OBJ) dvect.obj $(PYLIB)  -o dvect.pyd
+
+richcmp1.pyd: $(OBJ) richcmp1.obj
+	$(LD) $(LDOPTS) $(OBJ) richcmp1.obj $(PYLIB)  -o richcmp1.pyd
+
+richcmp2.pyd: $(OBJ) richcmp2.obj
+	$(LD) $(LDOPTS) $(OBJ) richcmp2.obj $(PYLIB)  -o richcmp2.pyd
+
+richcmp3.pyd: $(OBJ) richcmp3.obj
+	$(LD) $(LDOPTS) $(OBJ) richcmp3.obj $(PYLIB)  -o richcmp3.pyd
+
+.cpp.obj:
+	$(CPP) $(CPPOPTS) -c $*.cpp
+
+test:
+	$(PYEXE) comprehensive.py
+	$(PYEXE) test_abstract.py
+	$(PYEXE) test_getting_started1.py
+	$(PYEXE) test_getting_started2.py
+	$(PYEXE) test_simple_vector.py
+	$(PYEXE) test_do_it_yourself_convts.py
+	$(PYEXE) test_nested.py
+	$(PYEXE) test_pickle1.py
+	$(PYEXE) test_pickle2.py
+	$(PYEXE) test_pickle3.py
+	$(PYEXE) test_cross_module.py
+	$(PYEXE) test_richcmp1.py
+	$(PYEXE) test_richcmp2.py
+	$(PYEXE) test_richcmp3.py
+
+clean:
+	-del *.obj
+	-del *.lib
+	-del *.exp
+	-del *.idb
+	-del *.pyd
+	-del *.pyc
+
+softlinks:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) softlinks
+
+unlink:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) unlink
+
+cp:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) cp
+
+rm:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) rm
+
+copy:
+	$(PYEXE) $(BOOST_WIN)\libs\python\build\filemgr.py $(BOOST_WIN) copy
+
+del:
+	$(PYEXE) $(BOOST_WIN)\libs\python\build\filemgr.py $(BOOST_WIN) del

build/win32_mwcc_setup.bat

@@ -0,0 +1,2 @@
+call "c:\program files\metrowerks\codewarrior\other metrowerks tools\command line tools\cwenv.bat"
+set MWWinx86LibraryFiles=MSL_All-DLL_x86.lib;gdi32.lib;user32.lib;kernel32.lib

doc/building.html

@@ -1,297 +1,222 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<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">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
 
-    <title>Boost.Python - Building and Testing</title>
-  </head>
+    <title>Building an Extension Module</title>
 
-  <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="../../../c++boost.gif" border="0"></a></h3>
-        </td>
+    <div>
+      <h1><img width="277" height="86" align="center" src=
+      "../../../c++boost.gif" alt="c++boost.gif (8819 bytes)">Building an
+      Extension Module</h1>
 
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+      <h2>Building Boost.Python</h2>
 
-          <h2 align="center">Building and Testing</h2>
-        </td>
-      </tr>
-    </table>
-    <hr>
+      <p>Every Boost.Python extension module must be linked with the
+      <code>boost_python</code> shared library. To build
+      <code>boost_python</code>, use <a
+      href="../../../tools/build/index.html">Boost.Build</a> in the
+      usual way from the <code>libs/python/build</code> subdirectory
+      of your boost installation (if you have already built boost from
+      the top level this may have no effect, since the work is already
+      done). 
 
-    <h2>Contents</h2>
-
-    <dl class="Reference">
-      <dt><a href="#requirements">Requirements</a></dt>
-
-      <dt><a href="#building">Building Boost.Python</a></dt>
-
-      <dd>
-        <dl class="index">
-          <dt><a href="#configuration">Configuration</a></dt>
-
-          <dt><a href="#results">Results</a></dt>
-
-          <dt><a href="#testing">Testing</a></dt>
-        </dl>
-      </dd>
-
-      <dt><a href="#building_ext">Building your Extension Module</a></dt>
-
-      <dt><a href="#variants">Build Variants</a></dt>
-    </dl>
-    <hr>
-
-    <h2><a name="requirements">Requirements</a></h2>
-    <b>Boost.Python</b> version 2 requires <a href=
-    "http://www.python.org/2.2">Python 2.2</a> <i>or <a href=
-    "http://www.python.org">newer</a></i>. An unsupported archive of
-    Boost.Python version 1, which works with versions of Python since 1.5.2,
-    is available <a href="../build/python_v1.zip">here</a>. 
-
-    <h2><a name="building">Building Boost.Python</a></h2>
-
-    <p>Every Boost.Python extension module must be linked with the
-    <code>boost_python</code> shared library. To build
-    <code>boost_python</code>, use <a href=
-    "../../../tools/build/index.html">Boost.Build</a> in the usual way from
-    the <code>libs/python/build</code> subdirectory of your boost
-    installation (if you have already built boost from the top level this may
-    have no effect, since the work is already done).</p>
-
-    <h3><a name="configuration">Configuration</a></h3>
-    You may need to configure the following variables to point Boost.Build at
-    your Python installation: 
-
-    <table border="1" summary="build configuration variables">
-      <tr>
-        <th>Variable Name</th>
-
-        <th>Semantics</th>
-
-        <th>Default</th>
-
-        <th>Notes</th>
-      </tr>
-
-      <tr>
-        <td><code>PYTHON_ROOT</code></td>
-
-        <td>The root directory of your Python installation</td>
+      <h3>Configuration</h3>
+        You may need to configure the following variables to point Boost.Build at your Python installation:
 
+<table border="1">
+<tr><th>Variable Name <th>Semantics <th>Default <th>Notes
+   <tr>
+        <td><code>PYTHON_ROOT</code>
+        <td>The root directory of your Python installation
         <td>Windows:&nbsp;<code>c:/tools/python</code>
-        Unix:&nbsp;<code>/usr/local</code></td>
-
-        <td>On Unix, this is the <code>--with-prefix=</code> directory used
-        to configure Python</td>
-      </tr>
-
-      <tr>
-        <td><code>PYTHON_VERSION</code></td>
-
-        <td>The The 2-part python Major.Minor version number</td>
-
-        <td><code>2.2</code></td>
+        Unix:&nbsp;<code>/usr/local</code>
+        <td>On Unix, this is the <code>--with-prefix=</code> directory
+        used to configure Python
 
+   <tr>
+        <td><code>PYTHON_VERSION</code>
+        <td>The The 2-part python Major.Minor version number
+        <td>Windows:&nbsp;<code>2.1</code>
+        Unix:&nbsp;<code>1.5</code>
         <td>Be sure not to include a third number, e.g. <b>not</b>
-        "<code>2.2.1</code>", even if that's the version you have.</td>
-      </tr>
+        &quot;<code>2.2.1</code>&quot;, even if that's the version you
+        have.
 
-      <tr>
-        <td><code>PYTHON_INCLUDES</code></td>
+   <tr>
+        <td><code>PYTHON_INCLUDES</code>
+        <td>path to Python <code>#include</code> directories
+        <td>Autoconfigured from <code>PYTHON_ROOT</code>
 
-        <td>path to Python <code>#include</code> directories</td>
+   <tr>
+        <td><code>PYTHON_LIB_PATH</code>
+        <td>path to Python library object.
+        <td>Autoconfigured from <code>PYTHON_ROOT</code>
 
-        <td>Autoconfigured from <code>PYTHON_ROOT</code></td>
-      </tr>
-
-      <tr>
-        <td><code>PYTHON_LIB_PATH</code></td>
-
-        <td>path to Python library object.</td>
-
-        <td>Autoconfigured from <code>PYTHON_ROOT</code></td>
-      </tr>
-
-      <tr>
-        <td><code>PYTHON_STDLIB_PATH</code></td>
-
-        <td>path to Python standard library modules</td>
-
-        <td>Autoconfigured from <code>PYTHON_ROOT</code></td>
-      </tr>
-
-      <tr>
-        <td><code>CYGWIN_ROOT</code></td>
-
-        <td>path to the user's Cygwin installation</td>
+   <tr>
+        <td><code>PYTHON_STDLIB_PATH</code>
+        <td>path to Python standard library modules
+        <td>Autoconfigured from <code>PYTHON_ROOT</code>
 
+   <tr>
+        <td><code>CYGWIN_ROOT</code>
+        <td>path to the user's Cygwin installation
         <td>
-        </td>
+        <td><a href="http://www.cygwin.com">Cygwin</a> only. This and the following two settings are
+        useful when building with multiple toolsets on Windows, since
+        Cygwin requires a different build of Python.
 
-        <td><a href="http://www.cygwin.com">Cygwin</a> only. This and the
-        following two settings are useful when building with multiple
-        toolsets on Windows, since Cygwin requires a different build of
-        Python.</td>
-      </tr>
+   <tr>
+        <td><code>GCC_PYTHON_ROOT</code>
+        <td>path to the user's Cygwin Python installation
+        <td><code>$(CYGWIN_ROOT)/usr/local</code>
+        <td><a href="http://www.cygwin.com">Cygwin</a> only
 
-      <tr>
-        <td><code>GCC_PYTHON_ROOT</code></td>
+   <tr>
+        <td><code>GCC_DEBUG_PYTHON_ROOT</code>
+        <td>path to the user's Cygwin <code><a
+        href="#variants">pydebug</a></code> build
+        <td><code>$(CYGWIN_ROOT)/usr/local/pydebug</code>
+        <td><a href="http://www.cygwin.com">Cygwin</a> only
 
-        <td>path to the user's Cygwin Python installation</td>
+</table>
 
-        <td><code>$(CYGWIN_ROOT)/usr/local</code></td>
+<h3>Results</h3>
+      <p>The build process will create a
+      <code>libs/python/build/bin-stage</code> subdirectory of the
+      boost root (or of <code>$(ALL_LOCATE_TARGET)</code>,
+      if you have set that variable), containing the built
+      libraries. The libraries are actually built to unique
+      directories for each toolset and variant elsewhere in the
+      filesystem, and copied to the
+      <code>bin-stage</code> directory as a convenience, so if you
+      build with multiple toolsets at once, the product of later
+      toolsets will overwrite that of earlier toolsets in
+      <code>bin-stage</code>.
 
-        <td><a href="http://www.cygwin.com">Cygwin</a> only</td>
-      </tr>
-
-      <tr>
-        <td><code>GCC_DEBUG_PYTHON_ROOT</code></td>
-
-        <td>path to the user's Cygwin <code><a href=
-        "#variants">pydebug</a></code> build</td>
-
-        <td><code>$(CYGWIN_ROOT)/usr/local/pydebug</code></td>
-
-        <td><a href="http://www.cygwin.com">Cygwin</a> only</td>
-      </tr>
-    </table>
-
-    <h3><a name="results">Results</a></h3>
-
-    <p>The build process will create a
-    <code>libs/python/build/bin-stage</code> subdirectory of the boost root
-    (or of <code>$(ALL_LOCATE_TARGET)</code>, if you have set that variable),
-    containing the built libraries. The libraries are actually built to
-    unique directories for each toolset and variant elsewhere in the
-    filesystem, and copied to the <code>bin-stage</code> directory as a
-    convenience, so if you build with multiple toolsets at once, the product
-    of later toolsets will overwrite that of earlier toolsets in
-    <code>bin-stage</code>.</p>
-
-    <h3><a name="testing">Testing</a></h3>
-
-    <p>To build and test Boost.Python, start from the
-    <code>libs/python/test</code> directory and invoke</p>
-
-    <blockquote>
+<h3>Testing</h3>
+      <p>To build and test Boost.Python from within the
+      <code>libs/python/build</code> directory, invoke
+<blockquote>
 <pre>
-bjam -sTOOLS=<i><a href=
-"../../../tools/build/index.html#Tools">toolset</a></i> test
+bjam -sTOOLS=<i><a href="../../../tools/build/index.html#Tools">toolset</a></i> test
 </pre>
-    </blockquote>
-    This will update all of the Boost.Python v1 test and example targets. The
-    tests are relatively quiet by default. To get more-verbose output, you
-    might try 
-
-    <blockquote>
+</blockquote>
+This will
+update all of the Boost.Python v1 test and example targets. The tests
+are relatively quiet by default. To get more-verbose output, you might try
+<blockquote>
 <pre>
-bjam -sTOOLS=<i><a href=
-"../../../tools/build/index.html#Tools">toolset</a></i> -sPYTHON_TEST_ARGS=-v test
+bjam -sTOOLS=<i><a href="../../../tools/build/index.html#Tools">toolset</a></i> -sPYTHON_TEST_ARGS=-v test
 </pre>
-    </blockquote>
-    which will print each test's Python code with the expected output as it
-    passes. 
+</blockquote>
+which will print each test's Python code with the expected output as
+it passes.
 
-    <h2><a name="building_ext">Building your Extension Module</a></h2>
-    Though there are other approaches, the easiest way to build an extension
-    module using Boost.Python is with Boost.Build. Until Boost.Build v2 is
-    released, cross-project build dependencies are not supported, so it works
-    most smoothly if you add a new subproject to your boost installation. The
-    <code>libs/python/example</code> subdirectory of your boost installation
-    contains a minimal example (along with many extra sources). To copy the
-    example subproject: 
+<h2>Building your Extension Module</h2>
 
-    <ol>
+      Though there are other approaches, the easiest way to build an
+      extension module using Boost.Python is with Boost.Build. Until
+      Boost.Build v2 is released, cross-project build dependencies are
+      not supported, so it works most smoothly if you add a new
+      subproject to your boost installation. The
+      <code>libs/python/example</code> subdirectory of your boost
+      installation contains a minimal example (along with many extra
+      sources). To copy the example subproject:
+
+      <ol>
       <li>Create a new subdirectory in, <code>libs/python</code>, say
-      <code>libs/python/my_project</code>.</li>
+      <code>libs/python/my_project</code>.
 
-      <li>Copy <code><a href=
-      "../example/Jamfile">libs/python/example/Jamfile</a></code> to your new
-      directory.</li>
+      <li>Copy <code><a
+      href="../example/Jamfile">libs/python/example/Jamfile</a></code>
+      to your new directory.
 
-      <li>Edit the Jamfile as appropriate for your project. You'll want to
-      change the "<code>subproject</code>" rule invocation at the top, and
-      the names of some of the source files and/or targets.</li>
-    </ol>
-    If you can't modify or copy your boost installation, the alternative is
-    to create your own Boost.Build project. A similar example you can use as
-    a starting point is available in <code><a href=
-    "../example/project.zip">this archive</a></code>. You'll need to edit the
-    Jamfile and Jamrules files, depending on the relative location of your
-    Boost installation and the new project. Note that automatic testing of
-    extension modules is not available in this configuration. 
+      <li>Edit the Jamfile as appropriate for your project. You'll
+      want to change the &quot;<code>subproject</code>&quot; rule
+      invocation at the top, and the names of some of the source files
+      and/or targets.
 
-    <h2><a name="variants">Build Variants</a></h2>
-    Three <a href=
-    "../../../tools/build/build_system.htm#variants">variant</a>
-    configurations of all python-related targets are supported, and can be
-    selected by setting the <code><a href=
-    "../../../tools/build/build_system.htm#user_globals">BUILD</a></code>
-    variable: 
+      </ol>
 
-    <ul>
-      <li><code>release</code> (optimization, <tt>-DNDEBUG</tt>)</li>
+      If you can't modify or copy your boost installation, the
+      alternative is to create your own Boost.Build project. A similar
+      example you can use as a starting point is available in <code><a
+      href="../example/project.zip">this archive</a></code>. You'll
+      need to edit the Jamfile and Jamrules files, depending on the
+      relative location of your Boost installation and the new
+      project. Note that automatic testing of extension modules is not
+      available in this configuration.
 
-      <li><code>debug</code> (no optimization <tt>-D_DEBUG</tt>)</li>
+<h2><a name="variants">Build Variants</a></h2>
 
-      <li><code>debug-python</code> (no optimization, <tt>-D_DEBUG
-      -DBOOST_DEBUG_PYTHON</tt>)</li>
-    </ul>
+      Three <a
+      href="../../../tools/build/build_system.htm#variants">variant</a>
+      configurations of all python-related targets are supported, and
+      can be selected by setting the <code><a
+      href="../../../tools/build/build_system.htm#user_globals">BUILD</a></code>
+      variable:
 
-    <p>The first two variants of the <code>boost_python</code> library are
-    built by default, and are compatible with the default Python
-    distribution. The <code>debug-python</code> variant corresponds to a
-    specially-built debugging version of Python. On Unix platforms, this
-    python is built by adding <code>--with-pydebug</code> when configuring
-    the Python build. On Windows, the debugging version of Python is
-    generated by the "Win32 Debug" target of the <code>PCBuild.dsw</code>
-    Visual C++ 6.0 project in the <code>PCBuild</code> subdirectory of your
-    Python distribution. Extension modules built with Python debugging
-    enabled are <b>not link-compatible</b> with a non-debug build of Python.
-    Since few people actually have a debug build of Python (it doesn't come
-    with the standard distribution), the normal <code>debug</code> variant
-    builds modules which are compatible with ordinary Python.</p>
+      <ul>
+        <li><code>release</code> (optimization, <tt>-DNDEBUG</tt>)
 
-    <p>On many windows compilers, when extension modules are built with
-    <tt>-D_DEBUG</tt>, Python defaults to <i>force</i> linking with a special
-    debugging version of the Python DLL. Since this debug DLL isn't supplied
-    with the default Python installation for Windows, Boost.Python uses
-    <tt><a href=
-    "../../../boost/python/detail/wrap_python.hpp">boost/python/detail/wrap_python.hpp</a></tt>
-    to temporarily undefine <tt>_DEBUG</tt> when <tt>Python.h</tt> is
-    <tt>#include</tt>d - unless <code>BOOST_DEBUG_PYTHON</code> is
-    defined.</p>
+        <li><code>debug</code> (no optimization <tt>-D_DEBUG</tt>)
 
-    <p>If you want the extra runtime checks available with the debugging
-    version of the library, <tt>#define BOOST_DEBUG_PYTHON</tt> to re-enable
-    python debuggin, and link with the <code>debug-python</code> variant of
-    <tt>boost_python</tt>.</p>
+        <li><code>debug-python</code> (no optimization, <tt>-D_DEBUG
+        -DBOOST_DEBUG_PYTHON</tt>)
+      </ul>
 
-    <p>If you do not <tt>#define BOOST_DEBUG_PYTHON</tt>, be sure that any
-    source files in your extension module <tt>#include&nbsp;&lt;<a href=
-    "../../../boost/python/detail/wrap_python.hpp">boost/python/detail/wrap_python.hpp</a>&gt;</tt>
-    instead of the usual <tt>Python.h</tt>, or you will have link
-    incompatibilities.<br>
-    </p>
-    <hr>
+      <p>The first two variants of the <code>boost_python</code>
+      library are built by default, and are compatible with the
+      default Python distribution. The <code>debug-python</code>
+      variant corresponds to a specially-built debugging version of
+      Python. On Unix platforms, this python is built by adding
+      <code>--with-pydebug</code> when configuring the Python
+      build. On Windows, the debugging version of Python is generated
+      by the &quot;Win32 Debug&quot; target of the
+      <code>PCBuild.dsw</code> Visual C++ 6.0 project in the
+      <code>PCBuild</code> subdirectory of your Python distribution.
 
-    <p>&copy; Copyright David Abrahams 2002. Permission to copy, use, modify,
-    sell and distribute this document is granted provided this copyright
-    notice appears in all copies. This document is provided ``as is'' without
-    express or implied warranty, and with no claim as to its suitability for
-    any purpose.</p>
+      Extension modules built with Python debugging enabled are <b>not
+      link-compatible</b> with a non-debug build of Python. Since few
+      people actually have a debug build of Python (it doesn't come
+      with the standard distribution), the normal
+      <code>debug</code> variant builds modules which are compatible
+      with ordinary Python.
 
-    <p>Updated: O8 October, 2002 (David Abrahams)</p>
-  </body>
-</html>
 
+      <p>On many windows compilers, when extension modules are built
+      with
+      <tt>-D_DEBUG</tt>, Python defaults to <i>force</i> linking with a
+      special debugging version of the Python DLL. Since this debug DLL
+      isn't supplied with the default Python installation for Windows,
+      Boost.Python uses <tt><a href=
+      "../../../boost/python/detail/wrap_python.hpp">boost/python/detail/wrap_python.hpp</a></tt>
+      to temporarily undefine <tt>_DEBUG</tt> when <tt>Python.h</tt> is
+      <tt>#include</tt>d - unless <code>BOOST_DEBUG_PYTHON</code> is defined.
+
+      <p>If you want the extra runtime checks available with the
+      debugging version of the library, <tt>#define
+      BOOST_DEBUG_PYTHON</tt> to re-enable python debuggin, and link
+      with the <code>debug-python</code> variant of
+      <tt>boost_python</tt>. 
+
+      <p>If you do not <tt>#define BOOST_DEBUG_PYTHON</tt>, be sure that
+      any source files in your extension module <tt>#include &lt;<a href=
+          "../../../boost/python/detail/wrap_python.hpp">boost/python/detail/wrap_python.hpp</a>&gt;</tt>
+      instead of the usual <tt>Python.h</tt>, or you will have link
+      incompatibilities.<br>
+
+      <hr>
+      Next: <a href="enums.html">Wrapping Enums</a> Previous: <a href=
+      "under-the-hood.html">A Peek Under the Hood</a> Up: <a href=
+      "index.html">Top</a>
+
+      <hr>
+      <p>&copy; Copyright David Abrahams 2002. Permission to copy, use, modify,
+      sell and distribute this document is granted provided this copyright
+      notice appears in all copies. This document is provided ``as is'' without
+      express or implied warranty, and with no claim as to its suitability for
+      any purpose.
+
+      <p>Updated: May 15, 2002 (David Abrahams)
+    </div>

doc/comparisons.html

@@ -0,0 +1,231 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
+"http://www.w3.org/TR/REC-html40/strict.dtd">
+    <title>
+      Comparisons with Other Systems
+    </title>
+    <div>
+      <h1>
+         <img width="277" height="86" id="_x0000_i1025" align="center"
+        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)"><br>
+        Comparisons with
+        Other Systems
+      </h1>
+      
+      <h2>CXX</h2>
+      <p>
+        Like Boost.Python, <a href="http://cxx.sourceforge.net/">CXX</a> attempts to
+        provide a C++-oriented interface to Python. In most cases, as with the
+        boost library, it relieves the user from worrying about
+        reference-counts. Both libraries automatically convert thrown C++
+        exceptions into Python exceptions. As far as I can tell, CXX has no
+        support for subclassing C++ extension types in Python. An even
+        more significant difference is that a user's C++ code is still basically
+        ``dealing with Python objects'', though they are wrapped in
+        C++ classes. This means such jobs as argument parsing and conversion are
+        still left to be done explicitly by the user.
+
+     <p>
+        CXX claims to interoperate well with the C++ Standard Library
+        (a.k.a. STL) by providing iterators into Python Lists and Dictionaries,
+        but the claim is unfortunately unsupportable. The problem is that in
+        general, access to Python sequence and mapping elements through
+        iterators requires the use of proxy objects as the return value of
+        iterator dereference operations. This usage conflicts with the basic
+        ForwardIterator requirements in <a
+        href="http://anubis.dkuug.dk/jtc1/sc22/open/n2356/lib-iterators.html#lib.forward.iterators">
+        section 24.1.3 of the standard</a> (dereferencing must produce a
+        reference). Although you may be able to use these iterators with some
+        operations in some standard library implementations, it is neither
+        guaranteed to work nor portable.
+
+      <p>
+        As far as I can tell, CXX enables one to write what is essentially
+        idiomatic Python code in C++, manipulating Python objects through the
+        same fully-generic interfaces we use in Python. While you're hardly
+        programming directly to the ``bare metal'' with CXX, it basically
+        presents a ``C++-ized'' version of the Python 'C' API. Some fraction of
+        that capability is available in Boost.Python through <tt><a
+        href="../../../boost/python/objects.hpp">boost/python/objects.hpp</a></tt>,
+        which provides C++ objects corresponding to Python lists, tuples,
+        strings, and dictionaries, and through <tt><a
+        href="../../../boost/python/callback.hpp">boost/python/callback.hpp</a></tt>,
+        which allows you to call back into python with C++ arguments.
+
+      <p>
+        <a href="mailto:dubois1@llnl.gov">Paul F. Dubois</a>, the original
+        author of CXX, has told me that what I've described is only half of the
+        picture with CXX, but I never understood his explanation well-enough to
+        fill in the other half. Here is his response to the commentary above:
+
+<blockquote>
+``My intention with CXX was not to do what you are doing. It was to enable a
+person to write an extension directly in C++ rather than C. I figured others had
+the wrapping business covered. I thought maybe CXX would provide an easier
+target language for those making wrappers, but I never explored
+that.''<br><i>-<a href="mailto:dubois1@llnl.gov">Paul Dubois</a></i>
+</blockquote>
+
+      <h2>SWIG</h2>
+      <p>
+        <a href= "http://www.swig.org/">SWIG</a> is an impressively mature tool
+        for exporting an existing ANSI 'C' interface into various scripting
+        languages. Swig relies on a parser to read your source code and produce
+        additional source code files which can be compiled into a Python (or
+        Perl or Tcl) extension module. It has been successfully used to create
+        many Python extension modules. Like Boost.Python, SWIG is trying to allow an
+        existing interface to be wrapped with little or no change to the
+        existing code. The documentation says ``SWIG parses a form of ANSI C
+        syntax that has been extended with a number of special directives. As a
+        result, interfaces are usually built by grabbing a header file and
+        tweaking it a little bit.'' For C++ interfaces, the tweaking has often
+        proven to amount to more than just a little bit. One user
+        writes:
+
+        <blockquote> ``The problem with swig (when I used it) is that it
+        couldnt handle templates, didnt do func overloading properly etc.  For
+        ANSI C libraries this was fine.  But for usual C++ code this was a
+        problem.  Simple things work.  But for anything very complicated (or
+        realistic), one had to write code by hand.  I believe Boost.Python doesn't have
+        this problem[<a href="#sic">sic</a>]...  IMHO overloaded functions are very important to
+        wrap correctly.''<br><i>-Prabhu Ramachandran</i>
+        </blockquote>
+        
+      <p>
+        By contrast, Boost.Python doesn't attempt to parse C++ - the problem is simply
+        too complex to do correctly. <a name="sic">Technically</a>, one does
+        write code by hand to use Boost.Python. The goal, however, has been to make
+        that code nearly as simple as listing the names of the classes and
+        member functions you want to expose in Python.
+
+      <h2>SIP</h2> 
+      <p>
+        <a
+        href="http://www.thekompany.com/projects/pykde/background.php3?dhtml_ok=1">SIP</a>
+        is a system similar to SWIG, though seemingly more
+        C++-oriented. The author says that like Boost.Python, SIP supports overriding
+        extension class member functions in Python subclasses. It appears to
+        have been designed specifically to directly support some features of
+        PyQt/PyKDE, which is its primary client. Documentation is almost
+        entirely missing at the time of this writing, so a detailed comparison
+        is difficult.
+
+      <h2>ILU</h2>
+      <p>
+        <a
+        href="ftp://ftp.parc.xerox.com/pub/ilu/ilu.html">ILU</a>
+        is a very ambitious project which tries to describe a module's interface
+        (types and functions) in terms of an <a
+        href="ftp://ftp.parc.xerox.com/pub/ilu/2.0b1/manual-html/manual_2.html">Interface
+        Specification Language</a> (ISL) so that it can be uniformly interfaced
+        to a wide range of computer languages, including Common Lisp, C++, C,
+        Modula-3, and Python. ILU can parse the ISL to generate a C++ language
+        header file describing the interface, of which the user is expected to
+        provide an implementation. Unlike Boost.Python, this means that the system
+        imposes implementation details on your C++ code at the deepest level. It
+        is worth noting that some of the C++ names generated by ILU are supposed
+        to be reserved to the C++ implementation. It is unclear from the
+        documentation whether ILU supports overriding C++ virtual functions in Python.
+        
+      <h2>GRAD</h2>
+      <p>
+      <a
+      href="http://www.python.org/workshops/1996-11/papers/GRAD/html/GRADcover.html">GRAD</a>
+      is another very ambitious project aimed at generating Python wrappers for
+      interfaces written in ``legacy languages'', among which C++ is the first one
+      implemented. Like SWIG, it aims to parse source code and automatically
+      generate wrappers, though it appears to take a more sophisticated approach
+      to parsing in general and C++ in particular, so it should do a much better
+      job with C++. It appears to support function overloading. The
+      documentation is missing a lot of information I'd like to see, so it is
+      difficult to give an accurate and fair assessment. I am left with the
+      following questions:
+<ul>
+<li>Does it support overriding of virtual functions?
+<li>What about overriding private or protected virtual functions (the documentation indicates
+that only public interfaces are supported)?
+<li>Which C++ language constructs are supportd?
+<li>Does it support implicit conversions between wrapped C++ classes that have
+an inheritance relationship?
+<li>Does it support smart pointers?
+</ul>
+      <p>
+        Anyone in the possession of the answers to these questions will earn my
+        gratitude for a write-up <code>;-)</code>
+
+      <h2>Zope ExtensionClasses</h2>
+      <p>
+         <a href="http:http://www.digicool.com/releases/ExtensionClass">
+        ExtensionClasses in Zope</a> use the same underlying mechanism as Boost.Python
+        to support subclassing of extension types in Python, including
+        multiple-inheritance. Both systems support pickling/unpickling of
+        extension class instances in very similar ways. Both systems rely on the
+        same ``<a
+        href="http://www.python.org/workshops/1994-11/BuiltInClasses/Welcome.html">Don
+        Beaudry Hack</a>'' that also inspired Don's MESS System.
+      <p>
+        The major differences are:
+      <ul>
+        <li>Zope is entirely 'C' language-based. It doesn't require a C++
+        compiler, so it's much more portable than Boost.Python, which stresses
+        the limits of even some modern C++ implementations.
+
+        <li>
+          Boost.Python lifts the burden on the user to parse and convert function
+          argument types. Zope provides no such facility.
+        <li>
+          Boost.Python lifts the burden on the user to maintain Python
+          reference-counts.
+        <li>
+          Boost.Python supports function overloading; Zope does not.
+        <li>
+          Boost.Python supplies a simple mechanism for exposing read-only and
+          read/write access to data members of the wrapped C++ type as Python
+          attributes.
+        <li>
+          Writing a Zope ExtensionClass is significantly more complex than
+          exposing a C++ class to python using Boost.Python (mostly a summary of the
+          previous 4 items). <a href= 
+          "http://www.digicool.com/releases/ExtensionClass/MultiMapping.html">A
+          Zope Example</a> illustrates the differences.
+        <li>
+          Zope's ExtensionClasses are specifically motivated by ``the need for a
+          C-based persistence mechanism''. Boost.Python's are motivated by the desire
+          to simply reflect a C++ API into Python with as little modification as
+          possible.
+        <li>
+          The following Zope restriction does not apply to Boost.Python: ``At most one
+          base extension direct or indirect super class may define C data
+          members. If an extension subclass inherits from multiple base
+          extension classes, then all but one must be mix-in classes that
+          provide extension methods but no data.''
+        <li>
+          Zope requires use of the somewhat funky inheritedAttribute (search for
+          ``inheritedAttribute'' on <a
+          href="http://www.digicool.com/releases/ExtensionClass">this page</a>)
+          method to access base class methods. In Boost.Python, base class methods can
+          be accessed in the usual way by writing
+          ``<code>BaseClass.method</code>''.
+        <li>
+          Zope supplies some creative but esoteric idioms such as <a href= 
+          "http://www.digicool.com/releases/ExtensionClass/Acquisition.html">
+          Acquisition</a>. No specific support for this is built into Boost.Python.
+        <li>
+          Zope's ComputedAttribute support is designed to be used from Python.
+          <a href="special.html#getter_setter">The analogous feature of
+          Boost.Python</a> can be used from C++ or Python. The feature is arguably
+          easier to use in Boost.Python.
+      </ul>
+      <p>
+        Next: <a href="example1.html">A Simple Example Using Boost.Python</a>
+        Previous: <a href="extending.html">A Brief Introduction to writing Python Extension Modules</a>
+        Up: <a href="index.html">Top</a>
+      <p>
+         &copy; Copyright David Abrahams 2000. Permission to copy, use, modify,
+        sell and distribute this document is granted provided this copyright
+        notice appears in all copies. This document is provided ``as is'' without
+        express or implied warranty, and with no claim as to its suitability
+        for any purpose.
+      <p>
+         Updated: Mar 6, 2001
+    </div>
+

doc/cross_module.html

@@ -0,0 +1,336 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
+"http://www.w3.org/TR/REC-html40/strict.dtd">
+
+<title>Cross-extension-module dependencies</title>
+
+<div>
+
+<img src="../../../c++boost.gif"
+     alt="c++boost.gif (8819 bytes)"
+     align="center"
+     width="277" height="86">
+
+<hr>
+<h1>Cross-extension-module dependencies</h1>
+
+It is good programming practice to organize large projects as modules
+that interact with each other via well defined interfaces. With
+Boost.Python it is possible to reflect this organization at the C++
+level at the Python level. This is, each logical C++ module can be
+organized as a separate Python extension module.
+
+<p>
+At first sight this might seem natural and straightforward. However, it
+is a fairly complex problem to establish cross-extension-module
+dependencies while maintaining the same ease of use Boost.Python
+provides for classes that are wrapped in the same extension module. To
+a large extent this complexity can be hidden from the author of a
+Boost.Python extension module, but not entirely.
+
+<hr>
+<h2>The recipe</h2>
+
+Suppose there is an extension module that exposes certain instances of
+the C++ <tt>std::vector</tt> template library such that it can be used
+from Python in the following manner:
+
+<pre>
+import std_vector
+v = std_vector.double([1, 2, 3, 4])
+v.push_back(5)
+v.size()
+</pre>
+
+Suppose the <tt>std_vector</tt> module is done well and reflects all
+C++ functions that are useful at the Python level, for all C++ built-in
+data types (<tt>std_vector.int</tt>, <tt>std_vector.long</tt>, etc.).
+
+<p>
+Suppose further that there is statistic module with a C++ class that
+has constructors or member functions that use or return a
+<tt>std::vector</tt>.  For example:
+
+<pre>
+class xy {
+  public:
+    xy(const std::vector&lt;double&gt;&amp; x, const std::vector&lt;double&gt;&amp; y) : m_x(x), m_y(y) {}
+    const std::vector&lt;double&gt;&amp; x() const { return m_x; }
+    const std::vector&lt;double&gt;&amp; y() const { return m_y; }
+    double correlation();
+  private:
+    std::vector&lt;double&gt; m_x;
+    std::vector&lt;double&gt; m_y;
+}
+</pre>
+
+What is more natural than reusing the <tt>std_vector</tt> extension
+module to expose these constructors or functions to Python?
+
+<p>
+Unfortunately, what seems natural needs a little work in both the
+<tt>std_vector</tt> and the <tt>statistics</tt> module.
+
+<p>
+In the <tt>std_vector</tt> extension module,
+<tt>std::vector&lt;double&gt;</tt> is exposed to Python in the usual
+way with the <tt>class_builder&lt;&gt;</tt> template.  To also enable the
+automatic conversion of <tt>std::vector&lt;double&gt;</tt> function
+arguments or return values in other Boost.Python C++ modules, the
+converters that convert a <tt>std::vector&lt;double&gt;</tt> C++ object
+to a Python object and vice versa (i.e. the <tt>to_python()</tt> and
+<tt>from_python()</tt> template functions) have to be exported. For
+example:
+
+<pre>
+  #include &lt;boost/python/cross_module.hpp&gt;
+  //...
+  class_builder&lt;std::vector&lt;double&gt; &gt; v_double(std_vector_module, &quot;double&quot;);
+  export_converters(v_double);
+</pre>
+
+In the extension module that wraps <tt>class xy</tt> we can now import
+these converters with the <tt>import_converters&lt;&gt;</tt> template.
+For example:
+
+<pre>
+  #include &lt;boost/python/cross_module.hpp&gt;
+  //...
+  import_converters&lt;std::vector&lt;double&gt; &gt; v_double_converters(&quot;std_vector&quot;, &quot;double&quot;);
+</pre>
+
+That is all. All the attributes that are defined for
+<tt>std_vector.double</tt> in the <tt>std_vector</tt> Boost.Python
+module will be available for the returned objects of <tt>xy.x()</tt>
+and <tt>xy.y()</tt>.  Similarly, the constructor for <tt>xy</tt> will
+accept objects that were created by the <tt>std_vector</tt>module.
+
+<hr>
+<h2>Placement of <tt>import_converters&lt;&gt;</tt> template instantiations</h2>
+
+<tt>import_converts&lt;&gt;</tt> can be viewed as a drop-in replacement
+for <tt>class_wrapper&lt;&gt;</tt>, and the recommendations for the
+placement of <tt>class_wrapper&lt;&gt;</tt> template instantiations
+also apply to to <tt>import_converts&lt;&gt;</tt>. In particular, it is
+important that an instantiation of <tt>class_wrapper&lt;&gt;</tt> is
+visible to any code which wraps a C++ function with a <tt>T</tt>,
+<tt>T*</tt>, const <tt>T&amp;</tt>, etc. parameter or return value.
+Therefore you may want to group all <tt>class_wrapper&lt;&gt;</tt> and
+<tt>import_converts&lt;&gt;</tt> instantiations at the top of your
+module's init function, then <tt>def()</tt> the member functions later
+to avoid problems with inter-class dependencies.
+
+<hr>
+<h2>Non-copyable types</h2>
+
+<tt>export_converters()</tt> instantiates C++ template functions that
+invoke the copy constructor of the wrapped type. For a type that is
+non-copyable this will result in compile-time error messages. In such a
+case, <tt>export_converters_noncopyable()</tt> can be used to export
+the converters that do not involve the copy constructor of the wrapped
+type.  For example:
+
+<pre>
+class_builder&lt;store&gt; py_store(your_module, &quot;store&quot;);
+export_converters_noncopyable(py_store);
+</pre>
+
+The corresponding <tt>import_converters&lt;&gt;</tt> statement does not
+need any special attention:
+
+<pre>
+import_converters&lt;store&gt; py_store(&quot;noncopyable_export&quot;, &quot;store&quot;);
+</pre>
+
+<hr>
+<h2>Python module search path</h2>
+
+The <tt>std_vector</tt> and <tt>statistics</tt> modules can now be used
+in the following way:
+
+<pre>
+import std_vector
+import statistics
+x = std_vector.double([1, 2, 3, 4])
+y = std_vector.double([2, 4, 6, 8])
+xy = statistics.xy(x, y)
+xy.correlation()
+</pre>
+
+In this example it is clear that Python has to be able to find both the
+<tt>std_vector</tt> and the <tt>statistics</tt> extension module. In
+other words, both extension modules need to be in the Python module
+search path (<tt>sys.path</tt>).
+
+<p>
+The situation is not always this obvious. Suppose the
+<tt>statistics</tt> module has a <tt>random()</tt> function that
+returns a vector of random numbers with a given length:
+
+<pre>
+import statistics
+x = statistics.random(5)
+y = statistics.random(5)
+xy = statistics.xy(x, y)
+xy.correlation()
+</pre>
+
+A naive user will not easily anticipate that the <tt>std_vector</tt>
+module is used to pass the <tt>x</tt> and <tt>y</tt> vectors around. If
+the <tt>std_vector</tt> module is in the Python module search path,
+this form of ignorance is of no harm.  On the contrary, we are glad
+that we do not have to bother the user with details like this.
+
+<p>
+If the <tt>std_vector</tt> module is not in the Python module search
+path, a Python exception will be raised:
+
+<pre>
+Traceback (innermost last):
+  File &quot;foo.py&quot;, line 2, in ?
+    x = statistics.random(5)
+ImportError: No module named std_vector
+</pre>
+
+As is the case with any system of a non-trivial complexity, it is
+important that the setup is consistent and complete.
+
+<hr>
+<h2>Two-way module dependencies</h2>
+
+Boost.Python supports two-way module dependencies. This is best
+illustrated by a simple example.
+
+<p>
+Suppose there is a module <tt>ivect</tt> that implements vectors of
+integers, and a similar module <tt>dvect</tt> that implements vectors
+of doubles. We want to be able do convert an integer vector to a double
+vector and vice versa. For example:
+
+<pre>
+import ivect
+iv = ivect.ivect((1,2,3,4,5))
+dv = iv.as_dvect()
+</pre>
+
+The last expression will implicitly import the <tt>dvect</tt> module in
+order to enable the conversion of the C++ representation of
+<tt>dvect</tt> to a Python object. The analogous is possible for a
+<tt>dvect</tt>:
+
+<pre>
+import dvect
+dv = dvect.dvect((1,2,3,4,5))
+iv = dv.as_ivect()
+</pre>
+
+Now the <tt>ivect</tt> module is imported implicitly.
+
+<p>
+Note that the two-way dependencies are possible because the
+dependencies are resolved only when needed. This is, the initialization
+of the <tt>ivect</tt> module does not rely on the <tt>dvect</tt>
+module, and vice versa.  Only if <tt>as_dvect()</tt> or
+<tt>as_ivect()</tt> is actually invoked will the corresponding module
+be implicitly imported. This also means that, for example, the
+<tt>dvect</tt> module does not have to be available at all if
+<tt>as_dvect()</tt> is never used.
+
+<hr>
+<h2>Clarification of compile-time and link-time dependencies</h2>
+
+Boost.Python's support for resolving cross-module dependencies at
+runtime does not imply that compile-time dependencies are eliminated.
+For example, the statistics extension module in the example above will
+need to <tt>#include &lt;vector&gt;</tt>. This is immediately obvious
+from the definition of <tt>class xy</tt>.
+
+<p>
+If a library is wrapped that consists of both header files and compiled
+components (e.g. <tt>libdvect.a</tt>, <tt>dvect.lib</tt>, etc.), both
+the Boost.Python extension module with the
+<tt>export_converters()</tt> statement and the module with the
+<tt>import_converters&lt;&gt;</tt> statement need to be linked against
+the object library.  Ideally one would build a shared library (e.g.
+<tt>libdvect.so</tt>, <tt>dvect.dll</tt>, etc.). However, this
+introduces the issue of having to configure the search path for the
+dynamic loading correctly. For small libraries it is therefore often
+more convenient to ignore the fact that the object files are loaded
+into memory more than once.
+
+<hr>
+<h2>Summary of motivation for cross-module support</h2>
+
+The main purpose of Boost.Python's cross-module support is to allow for
+a modular system layout. With this support it is straightforward to
+reflect C++ code organization at the Python level. Without the
+cross-module support, a multi-purpose module like <tt>std_vector</tt>
+would be impractical because the entire wrapper code would somehow have
+to be duplicated in all extension modules that use it, making them
+harder to maintain and harder to build.
+
+<p>
+Another motivation for the cross-module support is that two extension
+modules that wrap the same class cannot both be imported into Python.
+For example, if there are two modules <tt>A</tt> and <tt>B</tt> that
+both wrap a given <tt>class X</tt>, this will work:
+
+<pre>
+import A
+x = A.X()
+</pre>
+
+This will also work:
+
+<pre>
+import B
+x = B.X()
+</pre>
+
+However, this will fail:
+
+<pre>
+import A
+import B
+python: /net/cci/rwgk/boost/boost/python/detail/extension_class.hpp:866:
+static void boost::python::detail::class_registry&lt;X&gt;::register_class(boost::python::detail::extension_class_base *):
+Assertion `static_class_object == 0' failed.
+Abort
+</pre>
+
+A good solution is to wrap <tt>class X</tt> only once. Depending on the
+situation, this could be done by module <tt>A</tt> or <tt>B</tt>, or an
+additional small extension module that only wraps and exports
+<tt>class X</tt>.
+
+<p>
+Finally, there can be important psychological or political reasons for
+using the cross-module support. If a group of classes is lumped
+together with many others in a huge module, the authors will have
+difficulties in being identified with their work. The situation is
+much more transparent if the work is represented by a module with a
+recognizable name. This is not just a question of strong egos, but also
+of getting credit and funding.
+
+<hr>
+<h2>Why not use <tt>export_converters()</tt> universally?</h2>
+
+There is some overhead associated with the Boost.Python cross-module
+support. Depending on the platform, the size of the code generated by
+<tt>export_converters()</tt> is roughly 10%-20% of that generated
+by <tt>class_builder&lt;&gt;</tt>. For a large extension module with
+many wrapped classes, this could mean a significant difference.
+Therefore the general recommendation is to use
+<tt>export_converters()</tt> only for classes that are likely to
+be used as function arguments or return values in other modules.
+
+<hr>
+&copy; Copyright Ralf W. Grosse-Kunstleve 2001. Permission to copy,
+use, modify, sell and distribute this document is granted provided this
+copyright notice appears in all copies. This document is provided "as
+is" without express or implied warranty, and with no claim as to its
+suitability for any purpose.
+
+<p>
+Updated: April 2001
+
+</div>

doc/data_structures.txt

@@ -0,0 +1,192 @@
+Given a real Python class 'A', a wrapped C++ class 'B', and this definition:
+
+    class C(A, B):
+        def __init__(self):
+            B.__init__(self)
+            self.x = 1
+        ...
+
+    c = C()
+
+this diagram describes the internal structure of an instance of 'C', including
+its inheritance relationships. Note that ExtensionClass<B> is derived from
+Class<ExtensionInstance>, and is in fact identical for all intents and purposes.
+
+                                           MetaClass<ExtensionInstance>
+                 +---------+              +---------+                  
+types.ClassType: |         |              |         |                  
+                 |         |              |         |                  
+                 |         |              |         |                  
+                 +---------+              +---------+                    
+                   ^                         ^   ^
+     PyClassObject |       ExtensionClass<B> |   |
+ A: +------------+ |   B: +------------+     |   |
+    |  ob_type  -+-+      |   ob_type -+-----+   |
+    |            |   ()<--+- __bases__ |         |
+    |            |        |  __dict__ -+->{...}  |
+    |            |   'B'<-+- __name__  |         |
+    +------------+        +------------+         |
+         ^                      ^                |
+         |                      |                |
+         +-----+  +-------------+                |
+               |  |                              |
+               |  |     Class<ExtensionInstance> |
+               |  | C: +------------+            |
+               |  |    |   ob_type -+------------+
+        tuple:(*, *)<--+- __bases__ |           
+                       |  __dict__ -+->{__module__, <methods, etc.>}
+                 'C' <-+- __name__  |
+                       +------------+        
+                             ^           (in case of inheritance from more than one   
+                             |            extension class, this vector would contain  
+             +---------------+            a pointer to an instance holder for the data
+             |                            of each corresponding C++ class)            
+             |     ExtensionInstance                
+             | c: +---------------------+   std::vector<InstanceHolderBase> 
+             +----+- __class__          |  +---+--  
+                  |  m_wrapped_objects -+->| * | ...
+        {'x': 1}<-+- __dict__           |  +-|-+--   
+                  +---------------------+    |    InstanceValueHolder<B>                  
+                                             |   +--------------------------------+
+                                             +-->| (contains a C++ instance of B) |
+                                                 +--------------------------------+
+
+
+
+
+
+
+In our inheritance test cases in extclass_demo.cpp/test_extclass.py, we have the
+following C++ inheritance hierarchy:
+
+               +-----+          +----+
+               |  A1 |          | A2 |
+               +-----+          +----+
+                ^ ^ ^            ^  ^  
+                | | |            |  |
+          +-----+ | +---------+-----+
+          |       |           |  |
+          |       +---+----------+
+   .......!......     |       |
+   : A_callback :   +-+--+  +-+--+
+   :............:   | B1 |  | B2 |
+                    +----+  +----+
+                      ^
+                      |
+              +-------+---------+
+              |                 |
+            +-+-+         ......!.......
+            | C |         : B_callback :
+            +---+         :............:
+
+
+A_callback and B_callback are used as part of the wrapping mechanism but not
+represented in Python. C is also not represented in Python but is delivered
+there polymorphically through a smart pointer.
+
+This is the data structure in Python.
+
+       ExtensionClass<A1>
+  A1: +------------+                
+ ()<--+- __bases__ |                                                
+      |  __dict__ -+->{...}                                         
+      +------------+                                                
+        ^                 
+        |          ExtensionInstance                                              
+        |     a1: +---------------------+   vec     InstanceValueHolder<A1,A_callback> 
+        +---------+- __class__          |  +---+   +---------------------+ 
+        |         |  m_wrapped_objects -+->| *-+-->| contains A_callback | 
+        |         +---------------------+  +---+   +---------------------+              
+        |   
+        |          ExtensionInstance                                              
+        | pa1_a1: +---------------------+   vec     InstancePtrHolder<auto_ptr<A1>,A1>
+        +---------+- __class__          |  +---+   +---+ 
+        |         |  m_wrapped_objects -+->| *-+-->| *-+-+   A1    
+        |         +---------------------+  +---+   +---+ |  +---+
+        |                                                +->|   |
+        |          ExtensionInstance                        +---+ 
+        | pb1_a1: +---------------------+   vec     InstancePtrHolder<auto_ptr<A1>,A1>
+        +---------+- __class__          |  +---+   +---+                 
+        |         |  m_wrapped_objects -+->| *-+-->| *-+-+   B1           
+        |         +---------------------+  +---+   +---+ |  +---+        
+        |                                                +->|   |                            
+        |          ExtensionInstance                        +---+                       
+        | pb2_a1: +---------------------+   vec     InstancePtrHolder<auto_ptr<A1>,A1>
+        +---------+- __class__          |  +---+   +---+                 
+        |         |  m_wrapped_objects -+->| *-+-->| *-+-+   B2                   
+        |         +---------------------+  +---+   +---+ |  +---+        
+        |                                                +->|   | 
+        |                                                   +---+                       
+        |       ExtensionClass<A1>                                                          
+        |  A2: +------------+                                                               
+        | ()<--+- __bases__ |                                                               
+        |      |  __dict__ -+->{...}                                                        
+        |      +------------+                                                               
+        |           ^                                                                       
+        |           |  ExtensionInstance                                                    
+        |       a2: | +---------------------+   vec     InstanceValueHolder<A2>             
+        |           +-+- __class__          |  +---+   +-------------+                      
+        |           | |  m_wrapped_objects -+->| *-+-->| contains A2 |                      
+        |           | +---------------------+  +---+   +-------------+                      
+        |           |                                                                       
+        |           |  ExtensionInstance                                                    
+        |   pa2_a2: | +---------------------+   vec     InstancePtrHolder<auto_ptr<A2>,A2>  
+        |           +-+- __class__          |  +---+   +---+                                
+        |           | |  m_wrapped_objects -+->| *-+-->| *-+-+   A2                         
+        |           | +---------------------+  +---+   +---+ |  +---+                       
+        |           |                                        +->|   |                       
+        |           |  ExtensionInstance                        +---+                       
+        |   pb1_a2: | +---------------------+   vec     InstancePtrHolder<auto_ptr<A2>,A2>  
+        |           +-+- __class__          |  +---+   +---+                                
+        |           | |  m_wrapped_objects -+->| *-+-->| *-+-+   B1                         
+        |           | +---------------------+  +---+   +---+ |  +---+                       
+        |           |                                        +->|   |                       
+        |           |                                           +---+                       
+        |           |                                                                       
+        |           +---------------+------------------------------+                             
+        |                           |                              |                             
+ +------+-------------------------+-|----------------------------+ |                             
+ |                                | |                            | |                             
+ |       Class<ExtensionInstance> | |      ExtensionClass<B1>    | |      ExtensionClass<B1>     
+ | DA1: +------------+            | | B1: +------------+         | | B2: +------------+          
+(*,)<---+- __bases__ |           (*,*)<---+- __bases__ |        (*,*)<---+- __bases__ |          
+        |  __dict__ -+->{...}             |  __dict__ -+->{...}          |  __dict__ -+->{...}   
+        +------------+                    +------------+                 +------------+          
+              ^                                ^                                    ^ 
+              |        ExtensionInstance       |                                    |       
+              |  da1: +---------------------+  |    vec     InstanceValueHolder<A1,A_callback>  
+              +-------+- __class__          |  |   +---+   +---------------------+  |          
+                      |  m_wrapped_objects -+--|-->| *-+-->| contains A_callback |  |          
+                      +---------------------+  |   +---+   +---------------------+  |          
+        +--------------------------------------+                                    |
+        |  ExtensionInstance                                                        |
+    b1: | +---------------------+   vec     InstanceValueHolder<B1,B_callback>      |
+        +-+- __class__          |  +---+   +---------------------+                  |
+        | |  m_wrapped_objects -+->| *-+-->| contains B_callback |                  |
+        | +---------------------+  +---+   +---------------------+                  |
+        |                                                                           |
+        |  ExtensionInstance                                                        |
+pb1_b1: | +---------------------+   vec     InstancePtrHolder<auto_ptr<B1>,B1>      |
+        +-+- __class__          |  +---+   +---+                                    |
+        | |  m_wrapped_objects -+->| *-+-->| *-+-+   B1                             |
+        | +---------------------+  +---+   +---+ |  +---+                           |
+        |                                        +->|   |                           |
+        |  ExtensionInstance                        +---+                           |
+ pc_b1: | +---------------------+   vec     InstancePtrHolder<auto_ptr<B1>,B1>      |
+        +-+- __class__          |  +---+   +---+                                    |
+        | |  m_wrapped_objects -+->| *-+-->| *-+-+   C                              |
+        | +---------------------+  +---+   +---+ |  +---+                           |
+        |                                        +->|   |                           |
+        |                                           +---+                           |
+        |                                                                           |
+        |       Class<ExtensionInstance>    +---------------------------------------+
+        | DB1: +------------+               |  ExtensionInstance                                                    
+       (*,)<---+- __bases__ |           a2: | +---------------------+   vec     InstanceValueHolder<A2> 
+               |  __dict__ -+->{...}        +-+- __class__          |  +---+   +-------------+                      
+               +------------+                 |  m_wrapped_objects -+->| *-+-->| contains A2 |                      
+                     ^                        +---------------------+  +---+   +-------------+                      
+                     |  ExtensionInstance      
+                db1: | +---------------------+    vec     InstanceValueHolder<B1,B_callback>  
+                     +-+- __class__          |   +---+   +----------------------+ 
+                       |  m_wrapped_objects -+-->| *-+-->| contains B1_callback |              
+                       +---------------------+   +---+   +----------------------+              

doc/enums.html

@@ -0,0 +1,120 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
+"http://www.w3.org/TR/REC-html40/strict.dtd">
+    <title>
+      Wrapping enums
+    </title>
+    <div>
+      <h1>
+         <img width="277" height="86" id="_x0000_i1025" align="center"
+        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)"><br>
+        Wrapping enums
+      </h1>
+
+<p>Because there is in general no way to deduce that a value of arbitrary type T
+is an enumeration constant, the Boost Python Library cannot automatically
+convert enum values to and from Python. To handle this case, you need to decide
+how you want the enum to show up in Python (since Python doesn't have
+enums). Once you have done that, you can write some simple
+<code>from_python()</code> and <code>to_python()</code> functions.
+
+<p>If you are satisfied with a Python int as a way to represent your enum
+values, we provide a shorthand for these functions. You just need to cause
+<code>boost::python::enum_as_int_converters&lt;EnumType&gt;</code> to be
+instantiated, where
+<code>EnumType</code> is your enumerated type. There are two convenient ways to do this:
+
+<ol>
+<li>Explicit instantiation:
+
+<blockquote><pre>
+  template class boost::python::enum_as_int_converters&lt;my_enum&gt;;
+</blockquote></pre>
+
+Some buggy C++ implementations require a class to be instantiated in the same
+namespace in which it is defined. In that case, the simple incantation above becomes:
+
+<blockquote>
+<pre>
+   ...
+} // close my_namespace
+
+// drop into namespace python and explicitly instantiate
+namespace boost { namespace python {
+  template class enum_as_int_converters&lt;my_enum_type&gt;;
+}} // namespace boost::python
+
+namespace my_namespace { // re-open my_namespace
+   ...
+</pre>
+</blockquote>
+
+
+<li>If you have such an implementation, you may find this technique more convenient 
+<blockquote><pre>
+// instantiate as base class in any namespace
+struct EnumTypeConverters
+    : boost::python::enum_as_int_converters&lt;EnumType&gt;
+{
+};
+</blockquote></pre>
+</ol>
+
+<p>Either of the above is equivalent to the following declarations:
+<blockquote><pre>
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
+
+  MyEnumType from_python(PyObject* x, boost::python::type&lt;MyEnumType&gt;)
+  {
+      return static_cast&lt;MyEnum&gt;(
+        from_python(x, boost::python::type&lt;long&gt;()));
+  }
+
+  MyEnumType from_python(PyObject* x, boost::python::type&lt;const MyEnumType&amp;&gt;)
+  {
+      return static_cast&lt;MyEnum&gt;(
+        from_python(x, boost::python::type&lt;long&gt;()));
+  }
+
+  PyObject* to_python(MyEnumType x)
+  {
+      return to_python(static_cast&lt;long&gt;(x));
+  }
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
+</pre></blockquote>
+
+<p>This technique defines the conversions of
+<code>MyEnumType</code> in terms of the conversions for the built-in
+ <code>long</code> type.
+
+You may also want to add a bunch of lines like this to your module
+initialization. These bind the corresponding enum values to the appropriate
+names so they can be used from Python:
+
+<blockquote><pre>
+mymodule.add(boost::python::make_ref(enum_value_1), "enum_value_1");
+mymodule.add(boost::python::make_ref(enum_value_2), "enum_value_2");
+...
+</pre></blockquote>
+
+You can also add these to an extension class definition, if your enum happens to
+be local to a class and you want the analogous interface in Python:
+
+<blockquote><pre>
+my_class_builder.add(boost::python::to_python(enum_value_1), "enum_value_1");
+my_class_builder.add(boost::python::to_python(enum_value_2), "enum_value_2");
+...
+</pre></blockquote>
+               <p>
+         Next: <a href="pointers.html">Pointers and Smart Pointers</a>
+         Previous: <a href="building.html">Building an Extension Module</a>
+         Up: <a href="index.html">Top</a>
+      <p>
+         &copy; Copyright David Abrahams 2000. Permission to copy, use, modify,
+        sell and distribute this document is granted provided this copyright
+        notice appears in all copies. This document is provided ``as
+        is'' without express or implied warranty, and with no claim as to
+        its suitability for any purpose.
+      <p>
+         Updated: Mar 6, 2001
+    </div>
+

doc/example1.html

@@ -0,0 +1,75 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
+"http://www.w3.org/TR/REC-html40/strict.dtd">
+    <title>
+      A Simple Example
+    </title>
+    <div>
+      <h1>
+         <img width="277" height="86" id="_x0000_i1025" src="../../../c++boost.gif" alt=
+        "c++boost.gif (8819 bytes)">
+      </h1>
+      <h1>
+         A Simple Example
+      </h1>
+      <p>
+         Suppose we have the following C++ API which we want to expose in
+        Python:
+      <blockquote>
+<pre>
+#include &lt;string&gt;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A couple of simple C++ functions that we want to expose to Python.
+  std::string greet() { return "hello, world"; }
+  int square(int number) { return number * number; }
+}
+
+</pre>
+      </blockquote>
+      <p>
+        Here is the C++ code for a python module called <tt>getting_started1</tt>
+        which exposes the API.
+      <blockquote>
+<pre>
+#include &lt;boost/python/class_builder.hpp&gt;
+namespace python = boost::python;
+
+BOOST_PYTHON_MODULE_INIT(getting_started1)
+{
+    // Create an object representing this extension module.
+    python::module_builder this_module("getting_started1");
+
+    // Add regular functions to the module.
+    this_module.def(greet, "greet");
+    this_module.def(square, "square");
+}
+</pre>
+      </blockquote>
+      <p>
+         That's it! If we build this shared library and put it on our <code>
+        PYTHONPATH</code> we can now access our C++ functions from
+        Python.
+      <blockquote>
+<pre>
+&gt;&gt;&gt; import getting_started1
+&gt;&gt;&gt; print getting_started1.greet()
+hello, world
+&gt;&gt;&gt; number = 11
+&gt;&gt;&gt; print number, '*', number, '=', getting_started1.square(number)
+11 * 11 = 121
+</pre>
+      <p>
+        Next: <a href="exporting_classes.html">Exporting Classes</a>
+         Previous: <a href="comparisons.html">Comparisons with other systems</a>  Up:
+        <a href="index.html">Top</a>
+      <p>
+         &copy; Copyright David Abrahams 2000. Permission to copy, use, modify,
+        sell and distribute this document is granted provided this copyright
+        notice appears in all copies. This document is provided "as is" without
+        express or implied warranty, and with no claim as to its suitability
+        for any purpose.
+      <p>
+         Updated: Mar 6, 2000
+    </div>
+

doc/exporting_classes.html

@@ -0,0 +1,143 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
+"http://www.w3.org/TR/REC-html40/strict.dtd">
+    <title>
+      Exporting Classes
+    </title>
+    <div>
+      <h1>
+         <img width="277" height="86" id="_x0000_i1025" src="../../../c++boost.gif" alt=
+        "c++boost.gif (8819 bytes)">
+      </h1>
+      <h1>
+         Exporting Classes
+      </h1>
+      <p>
+         Now let's expose a C++ class to Python:
+
+<blockquote><pre>
+#include &lt;iostream&gt;
+#include &lt;string&gt;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A friendly class.
+  class hello
+  {
+    public:
+      hello(const std::string&amp; country) { this-&gt;country = country; }
+      std::string greet() const { return "Hello from " + country; }
+    private:
+      std::string country;
+  };
+
+  // A function taking a hello object as an argument.
+  std::string invite(const hello&amp; w) {
+    return w.greet() + "! Please come soon!";
+  }
+}
+
+</blockquote></pre>      <p>
+      To expose the class, we use a <tt>class_builder</tt> in addition to the
+      <tt>module_builder</tt> from the previous example. Class member functions
+      are exposed by using the <tt>def()</tt> member function on the
+      <tt>class_builder</tt>:
+<blockquote><pre>
+#include &lt;boost/python/class_builder.hpp&gt;
+namespace python = boost::python;
+
+BOOST_PYTHON_MODULE_INIT(getting_started2)
+{
+    // Create an object representing this extension module.
+    python::module_builder this_module("getting_started2");
+
+    // Create the Python type object for our extension class.
+    python::class_builder&lt;hello&gt; hello_class(this_module, "hello");
+
+    // Add the __init__ function.
+    hello_class.def(python::constructor&lt;std::string&gt;());
+    // Add a regular member function.
+    hello_class.def(&amp;hello::greet, "greet");
+
+    // Add invite() as a regular function to the module.
+    this_module.def(invite, "invite");
+
+    // Even better, invite() can also be made a member of hello_class!!!
+    hello_class.def(invite, "invite");
+}
+</blockquote></pre>
+      <p>
+Now we can use the class normally from Python:
+
+<blockquote><pre>
+&gt;&gt;&gt; from getting_started2 import *
+&gt;&gt;&gt; hi = hello('California')
+&gt;&gt;&gt; hi.greet()
+'Hello from California'
+&gt;&gt;&gt; invite(hi)
+'Hello from California! Please come soon!'
+&gt;&gt;&gt; hi.invite()
+'Hello from California! Please come soon!'
+</blockquote></pre>
+
+Notes:<ul>
+<li> We expose the class' constructor by calling <tt>def()</tt> on the
+      <tt>class_builder</tt> with an argument whose type is
+      <tt>constructor&lt;</tt><i>params</i><tt>&gt;</tt>, where <i>params</i>
+      matches the list of constructor argument types:
+
+
+<li>Regular member functions are defined by calling <tt>def()</tt> with a
+      member function pointer and its Python name:
+
+<li>Any function added to a class whose initial argument matches the class (or
+any base) will act like a member function in Python.
+
+<li>To define a nested class, just pass the enclosing
+<tt>class_builder</tt> (instead of a <tt>module_builder</tt>) as the
+first argument to the nested <tt>class_builder</tt>'s constructor.
+
+
+</ul>
+      <p>
+         We can even make a subclass of <code>hello.world</code>:
+
+<blockquote><pre>
+&gt;&gt;&gt; class wordy(hello):
+...     def greet(self):
+...         return hello.greet(self) + ', where the weather is fine'
+...
+&gt;&gt;&gt; hi2 = wordy('Florida')
+&gt;&gt;&gt; hi2.greet()
+'Hello from Florida, where the weather is fine'
+&gt;&gt;&gt; invite(hi2)
+'Hello from Florida! Please come soon!'
+</blockquote></pre>
+      <p>
+         Pretty cool! You can't do that with an ordinary Python extension type!
+
+         Of course, you may now have a slightly empty feeling in the pit of
+        your little pythonic stomach. Perhaps you wanted to see the following
+        <tt>wordy</tt> invitation:
+
+<blockquote><pre>
+'Hello from Florida, where the weather is fine! Please come soon!'
+</blockquote></pre>
+
+        After all, <tt>invite</tt> calls <tt>hello::greet()</tt>, and you
+        reimplemented that in your Python subclass, <tt>wordy</tt>. If so, <a
+        href= "overriding.html">read on</a>...
+
+      <p>
+        Next: <a href="overriding.html">Overridable virtual functions</a>
+         Previous: <a href="example1.html">A Simple Example</a>  Up:
+        <a href="index.html">Top</a>
+      <p>
+         &copy; Copyright David Abrahams 2000. Permission to copy, use, modify,
+        sell and distribute this document is granted provided this copyright
+        notice appears in all copies. This document is provided "as is" without
+        express or implied warranty, and with no claim as to its suitability
+        for any purpose.
+      <p>
+         Updated: Mar 6, 2001
+    </div>
+

doc/extending.html

@@ -0,0 +1,73 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
+    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+    <title>
+      A Brief Introduction to writing Python extension modules
+    </title>
+    <h1>
+      <img src="../../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center"
+      width="277" height="86">
+    </h1>
+    <h1>
+      A Brief Introduction to writing Python extension modules
+    </h1>
+    <p>
+      Interfacing any language to Python involves building a module which can
+      be loaded by the Python interpreter, but which isn't written in Python.
+      This is known as an <em>extension module</em>. Many of the <a href= 
+      "http://www.python.org/doc/current/lib/lib.html">built-in Python
+      libraries</a> are constructed in 'C' this way; Python even supplies its
+      <a href="http://www.python.org/doc/current/lib/types.html">fundamental
+      types</a> using the same mechanism. An extension module can be statically
+      linked with the Python interpreter, but it more commonly resides in a
+      shared library or DLL.
+    <p>
+      As you can see from <a href= 
+      "http://www.python.org/doc/current/ext/ext.html"> The Python Extending
+      and Embedding Tutorial</a>, writing an extension module normally means
+      worrying about
+    <ul>
+      <li>
+        <a href="http://www.python.org/doc/current/ext/refcounts.html">
+        maintaining reference counts</a>
+      <li>
+        <a href="http://www.python.org/doc/current/ext/callingPython.html"> how
+        to call back into Python</a>
+      <li>
+        <a href="http://www.python.org/doc/current/ext/parseTuple.html">
+        function argument parsing and typechecking</a>
+    </ul>
+    This last item typically occupies a great deal of code in an extension
+    module. Remember that Python is a completely dynamic language. A callable
+    object receives its arguments in a tuple; it is up to that object to extract
+    those arguments from the tuple, check their types, and raise appropriate
+    exceptions. There are numerous other tedious details that need to be
+    managed; too many to mention here. The Boost Python Library is designed to
+    lift most of that burden.<br>
+    <br>
+     
+    <p>
+      Another obstacle that most people run into eventually when extending
+      Python is that there's no way to make a true Python class in an extension
+      module. The typical solution is to create a new Python type in the
+      extension module, and then write an additional module in 100% Python. The
+      Python module defines a Python class which dispatches to an instance of
+      the extension type, which it contains. This allows users to write
+      subclasses of the class in the Python module, almost as though they were
+      sublcassing the extension type. Aside from being tedious, it's not really
+      the same as having a true class, because there's no way for the user to
+      override a method of the extension type which is called from the
+      extension module. Boost.Python solves this problem by taking advantage of <a
+      href="http://www.python.org/doc/essays/metaclasses/">Python's metaclass
+      feature</a> to provide objects which look, walk, and hiss almost exactly
+      like regular Python classes. Boost.Python classes are actually cleaner than
+      Python classes in some subtle ways; a more detailed discussion will
+      follow (someday).</p>
+    <p>Next: <a href="comparisons.html">Comparisons with Other Systems</a> Up: <a
+    href="index.html">Top</a> </p>
+    <p>
+      &copy; Copyright David Abrahams 2000. Permission to copy, use, modify,
+      sell and distribute this document is granted provided this copyright
+      notice appears in all copies. This document is provided "as is" without
+      express or implied warranty, and with no claim as to its suitability for
+      any purpose.</p>
+

doc/index.html

@@ -1,95 +1,205 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
+"http://www.w3.org/TR/REC-html40/strict.dtd">
+    <title>
+      The Boost Python Library (Boost.Python)
+    </title>
+    <h1>
+       <img src="../../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277"
+      align="center" height="86"><br>The Boost Python Library (Boost.Python)
+    </h1>
 
-<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">
+<h2>Synopsis</h2>
+    <p>
+      Use the Boost Python Library to quickly and easily export a C++ library to <a
+      href="http://www.python.org">Python</a> such that the Python interface is
+      very similar to the C++ interface. It is designed to be minimally
+      intrusive on your C++ design. In most cases, you should not have to alter
+      your C++ classes in any way in order to use them with Boost.Python. The system
+      <em>should</em> simply ``reflect'' your C++ classes and functions into
+      Python. 
 
-    <title>Boost.Python</title>
-  </head>
+      <p>
 
-  <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="../../../c++boost.gif" border="0"></a></h3>
-        </td>
+<table border="1">
+<tr><td> <b>Note:</b> this is the last official release of
+Boost.Python v1. Development of this version of the library has
+stopped; it will be retired soon in favor of the redesigned and
+improved version 2. A summary of the development goals is available on
+the Python <a href="http://www.python.org/sigs/c++-sig/">C++-sig</a>
+page, which also serves as a mailing list for users of both versions
+of the library. A preview of the v2 documentation is available <a
+href="http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/*checkout*/boost/boost/libs/python/doc/v2/index.html?rev=HEAD&content-type=text/html">here</a>,
+and instructions for getting started with a prerelease are available
+upon request.
+</table>
 
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+<h2>Supported Platforms</h2>
+<p>Boost.Python is known to have been tested
+against <a href="http://www.python/org/2.2.1">Python 2.2.1</a> using
+the following compilers:
 
-          <h2 align="center">Index</h2>
-        </td>
-      </tr>
-    </table>
-    <hr>
+<ul>
+  <li><a
+  href="http://msdn.microsoft.com/vstudio/downloads/updates/sp/vs6/sp5/default.asp">MSVC++6sp5</a>.
+  All tests pass.
 
-    <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=
-    "http://www.python.org">Python</a> programming language. The new version
-    has been rewritten from the ground up, with a more convenient and
-    flexible interface, and many new capabilities, including support for: 
+  <li><a
+  href="http://msdn.microsoft.com/vstudio/downloads/updates/sp/vs6/sp5/default.asp">MSVC++6sp5</a>
+  with <a href="http://www.stlport.org">STLPort</a>-4.5.3. A compiler bug interferes with
+  <a
+  href="../example/simple_vector.cpp">libs/python/example/simple_vector.cpp</a>. All
+  other tests pass.
 
-    <ul>
-      <li>References and Pointers</li>
+  <p>
+  <li><a href="http://msdn.microsoft.com/visualc/">MSVC++7 (Visual
+       Studio .NET)</a>. All tests pass.
 
-      <li>Globally Registered Type Coercions</li>
+  <p>
+  <li><a href="http://www.metrowerks.com/products/windows/">Metrowerks
+        CodeWarrior Pro7.2 and Pro7.0 for Windows</a>. All tests pass.
 
-      <li>Automatic Cross-Module Type Conversions</li>
+  <p>
+  <li><a href="http://gcc.gnu.org">GCC 3.0.4</a> under <a
+       href="http://www.cygwin.com">Cygwin</a> and
+       <a href="http://www.redhat.com/">RedHat Linux 7.1</a>.
+       All tests pass.
 
-      <li>Efficient Function Overloading</li>
+  <p>
+  <li>Compaq C++ V6.2-024 for Digital UNIX (an <a
+      href="http://www.edg.com/">EDG</a>-based compiler).
+      All tests pass.<br>
+      Note that the Boost.Compatibility
+      library must be included (see e.g. tru64_cxx.mak in the build
+      directory).
 
-      <li>C++ to Python Exception Translation</li>
+  <p>
+  <li>Silicon Graphics MIPSpro Version 7.3.1.2m (an <a
+      href="http://www.edg.com/">EDG</a>-based compiler).
+      All tests pass.<br>
+      Note that the Boost.Compatibility
+      library must be included (see e.g. irix_CC.mak in the build
+      directory).
 
-      <li>Default Arguments</li>
+  <p>
+  <li><a href="http://gcc.gnu.org">GCC 2.95.2</a> under <a
+       href="http://www.mingw.org">MinGW</a> and <a
+       href="http://www.redhat.com/">RedHat Linux 7.1</a>.
+       Compilation succeeds, but some tests fail at runtime due to
+       exception handling bugs. It is therefore highly recommended
+       to use GCC 3.0.4 instead.
 
-      <li>Keyword Arguments</li>
+  <p>
+  <li><a
+        href="http://developer.intel.com/software/products/compilers/c50/">Intel
+        C++ 6.0</a> beta: Comprehensive test fails to link due to a
+        linker bug. Other tests seem to work.
 
-      <li>Manipulating Python objects in C++</li>
+  <p>
+  <li><a
+        href="http://developer.intel.com/software/products/compilers/c50/">Intel
+        C++ 5.0</a> Comprehensive test fails at runtime due to an
+        exception-handling bug. Other tests seem to work.
 
-      <li>Exporting C++ Iterators as Python Iterators</li>
+</ul>
 
-      <li>Documentation Strings</li>
-    </ul>
-    <hr>
+<p>
+Note that pickling doesn't work with Python 2.2
+due to a core language bug. This is fixed in
+<a href="http://www.python/org/2.2.1">2.2.1</a>.
 
-    <h2>Contents</h2>
+<p>
+Boost.Python has also been used with other versions of Python back to
+Python 1.5.2. It is expected that the older Python releases still work,
+but we are not regularly testing for backward compatibility.
 
-    <dl class="index">
-      <dt><a href="tutorial/index.html">Tutorial Introduction</a></dt>
+<h2>Credits</h2>
+<ul>
+      <li><a href="../../../people/dave_abrahams.htm">David Abrahams</a> originated
+      and wrote most of the library, and continues to coordinate development.
 
-      <dt><a href="building.html">Building and Testing</a></dt>
+      <li><a href="mailto:koethe@informatik.uni-hamburg.de">Ullrich Koethe</a>
+      had independently developed a similar system. When he discovered Boost.Python,
+      he generously contributed countless hours of coding and much insight into
+      improving it. He is responsible for an early version of the support for <a
+      href="overloading.html">function overloading</a> and wrote the support for
+      <a href="inheritance.html#implicit_conversion">reflecting C++ inheritance
+      relationships</a>. He has helped to improve error-reporting from both
+      Python and C++, and has designed an extremely easy-to-use way of 
+      exposing <a href="special.html#numeric">numeric operators</a>, including
+      a way to avoid explicit coercion by means of overloading.
+      
+      <li><a href="http://cci.lbl.gov/staff/ralf_grosse-kunstleve.html">Ralf W.
+      Grosse-Kunstleve</a> contributed <a href="pickle.html">pickle support</a>
+      and numerous other small improvements. He's working on a way to allow
+      types exported by multiple modules to interact.
 
-      <dt><a href="v2/reference.html">Reference</a></dt>
+      <li>The members of the boost mailing list and the Python community
+      supplied invaluable early feedback. In particular, Ron Clarke, Mark Evans,
+      Anton Gluck, Chuck Ingold, Prabhu Ramachandran, and Barry Scott took the
+      brave step of trying to use Boost.Python while it was still in early
+      stages of development.
 
-      <dt><a href="v2/configuration.html">Configuration Information</a></dt>
+      <li>The development of Boost.Python wouldn't have been possible without
+      the generous support of <a href="http://www.dragonsys.com/">Dragon
+      Systems/Lernout and Hauspie, Inc</a> who supported its development as an
+      open-source project.
+</ul>
 
-      <dt><a href="v2/platforms.html">Known Working Platforms and
-      Compilers</a></dt>
+    <h2>Table of Contents</h2>
 
-      <dt><a href="v2/definitions.html">Definitions</a></dt>
+    <ol>
+      <li><a href="extending.html">A Brief Introduction to writing Python
+        extension modules</a>
 
-      <dt><a href="v2/faq.html">Frequently Asked Questions (FAQs)</a></dt>
+      <li><a href="comparisons.html">Comparisons between Boost.Python and other
+        systems for extending Python</a>
 
-      <dt><a href="v2/progress_reports.html">Progress Reports</a></dt>
+      <li><a href="example1.html">A Simple Example</a>
 
-      <dt><a href="v2/acknowledgments.html">Acknowledgments</a></dt>
-    </dl>
-    <hr>
+      <li><a href="exporting_classes.html">Exporting Classes</a>
 
-    <p>Revised 
-    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     08 October, 2002 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-    </p>
+      <li><a href="overriding.html">Overridable Virtual Functions</a>
 
-    <p><i>&copy; Copyright <a href="../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. All Rights Reserved.</i></p>
-  </body>
-</html>
+      <li><a href="overloading.html">Function Overloading</a>
+
+      <li><a href="inheritance.html">Inheritance</a>
+
+      <li><a href="special.html">Special Method and Operator Support</a>
+
+      <li><a href="under-the-hood.html">A Peek Under the Hood</a>
+
+      <li><a href="building.html">Building an Extension Module</a>
+
+      <li><a href="pickle.html">Pickle Support</a>
+
+      <li><a href="cross_module.html">Cross-Extension-Module Dependencies</a>
+
+      <li><a href="enums.html">Wrapping Enums</a>
+
+      <li><a href="pointers.html">Pointers and Smart Pointers</a>
+
+      <li><a href="data_structures.txt">Internal Data Structures</a>
+          
+</ol>  
+ 
+    <p>
+      Documentation is a major ongoing project; assistance is greatly
+      appreciated! In the meantime, useful examples of every Boost.Python feature should
+      be evident in the regression test files <code>test/comprehensive.[<a
+      href="../test/comprehensive.py">py</a>/<a
+      href="../test/comprehensive.hpp">hpp</a>/<a
+      href="../test/comprehensive.cpp">cpp</a>]</code>
+
+    <p>
+       Questions should be directed to the <a href= 
+      "http://www.python.org/sigs/c++-sig/">Python C++ SIG</a>.
+
+    <p>
+       &copy; Copyright David Abrahams 2001. Permission to copy, use, modify,
+      sell and distribute this document is granted provided this copyright
+      notice appears in all copies. This document is provided ``as is'' without
+      express or implied warranty, and with no claim as to its suitability for
+      any purpose.
+    <p>
+       Updated: Apr 2002
 

doc/inheritance.html

@@ -0,0 +1,166 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
+"http://www.w3.org/TR/REC-html40/strict.dtd">
+    <title>
+      Inheritance
+    </title>
+    <div>
+      <h1>
+         <img width="277" height="86" id="_x0000_i1025" align="center"
+        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)">Inheritance
+      </h1>
+
+<h2>Inheritance in Python</h2>
+
+      <p>
+         Boost.Python extension classes support single and multiple-inheritance in
+         Python, just like regular Python classes. You can arbitrarily mix
+         built-in Python classes with extension classes in a derived class'
+         tuple of bases. Whenever a Boost.Python extension class is among the bases for a
+         new class in Python, the result is an extension class:
+<blockquote>
+<pre>
+&gt;&gt;&gt; class MyPythonClass:
+...     def f(): return 'MyPythonClass.f()'
+...
+&gt;&gt;&gt; import my_extension_module
+&gt;&gt;&gt; class Derived(my_extension_module.MyExtensionClass, MyPythonClass):
+...     '''This is an extension class'''
+...     pass
+...
+&gt;&gt;&gt; x = Derived()
+&gt;&gt;&gt; x.f()
+'MyPythonClass.f()'
+&gt;&gt;&gt; x.g()
+'MyExtensionClass.g()'
+</pre>
+</blockquote>
+
+<h2><a name="implicit_conversion">Reflecting C++ Inheritance Relationships</a></h2>
+      <p>
+        Boost.Python also allows us to represent C++ inheritance relationships so that
+        wrapped derived classes may be passed where values, pointers, or
+        references to a base class are expected as arguments. The
+        <code>declare_base</code> member function of
+        <code>class_builder&lt;&gt;</code> is used to establish the relationship
+        between base and derived classes:
+
+<blockquote>
+<pre>
+#include &lt;memory&gt; // for std::auto_ptr&lt;&gt;
+
+struct Base {
+    virtual ~Base() {}
+    virtual const char* name() const { return "Base"; }
+};
+
+struct Derived : Base {
+    Derived() : x(-1) {}
+    virtual const char* name() const { return "Derived"; }
+    int x;
+};
+
+std::auto_ptr&lt;Base&gt; derived_as_base() {
+    return std::auto_ptr&lt;Base&gt;(new Derived);
+}
+
+const char* get_name(const Base& b) {
+    return b.name();
+}
+
+int get_derived_x(const Derived& d) {
+    return d.x;
+}
+    <hr>
+#include &lt;boost/python/class_builder.hpp&gt;
+
+// namespace alias for code brevity
+namespace python = boost::python;
+
+BOOST_PYTHON_MODULE_INIT(my_module)
+{
+    python::module_builder my_module("my_module");                            
+                                                                              
+    python::class_builder&lt;Base&gt; base_class(my_module, "Base");          
+    base_class.def(python::constructor&lt;&gt;());                        
+                                                                              
+    python::class_builder&lt;Derived&gt; derived_class(my_module, "Derived"); 
+    derived_class.def(python::constructor&lt;&gt;());                     
+    <b>// Establish the inheritance relationship between Base and Derived     
+    derived_class.declare_base(base_class);</b>                               
+                                                                              
+    my_module.def(derived_as_base, "derived_as_base");                        
+    my_module.def(get_name, "get_name");                                      
+    my_module.def(get_derived_x, "get_derived_x"); 
+}
+</pre>
+</blockquote>
+
+<p>
+   Then, in Python:
+<blockquote>
+<pre>
+&gt;&gt;&gt; from my_module import *
+&gt;&gt;&gt; base = Base()
+&gt;&gt;&gt; derived = Derived()
+&gt;&gt;&gt; get_name(base)
+'Base'
+</pre>
+</blockquote>
+<i>objects of wrapped class Derived may be passed where Base is expected</i>
+<blockquote>
+<pre>
+&gt;&gt;&gt; get_name(derived) 
+'Derived'
+</pre>
+</blockquote>
+<i>objects of wrapped class Derived can be passed where Derived is 
+expected but where type information has been lost.</i>
+<blockquote>
+<pre>
+&gt;&gt;&gt; get_derived_x(derived_as_base()) 
+-1
+</pre>
+</blockquote>
+
+<h2>Inheritance Without Virtual Functions</h2>
+
+<p>
+  If for some reason your base class has no virtual functions but you still want
+  to represent the inheritance relationship between base and derived classes,
+  pass the special symbol <code>boost::python::without_downcast</code> as the 2nd parameter
+  to <code>declare_base</code>:
+
+<blockquote>
+<pre>
+struct Base2 {};
+struct Derived2 { int f(); };
+<hr>
+   ...
+   python::class_builder&lt;Base&gt; base2_class(my_module, "Base2");
+   base2_class.def(python::constructor&lt;&gt;());
+
+   python::class_builder&lt;Derived2&gt; derived2_class(my_module, "Derived2");
+   derived2_class.def(python::constructor&lt;&gt;());
+   derived_class.declare_base(base_class, <b>python::without_downcast</b>);
+</pre>
+</blockquote>
+
+<p>This approach will allow <code>Derived2</code> objects to be passed where
+ <code>Base2</code> is expected, but does not attempt to implicitly convert (downcast)
+ smart-pointers to <code>Base2</code> into <code>Derived2</code> pointers,
+ references, or values.
+
+      <p>
+         Next: <a href="special.html">Special Method and Operator Support</a>
+         Previous: <a href="overloading.html">Function Overloading</a>
+         Up: <a href="index.html">Top</a>
+      <p>
+         &copy; Copyright David Abrahams 2000. Permission to copy, use, modify,
+        sell and distribute this document is granted provided this copyright
+        notice appears in all copies. This document is provided "as is" without
+        express or implied warranty, and with no claim as to its suitability
+        for any purpose.
+      <p>
+         Updated: Nov 26, 2000
+    </div>
+

doc/overloading.html

@@ -0,0 +1,155 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
+"http://www.w3.org/TR/REC-html40/strict.dtd">
+    <title>
+      Function Overloading
+    </title>
+    <div>
+      <h1>
+         <img width="277" height="86" id="_x0000_i1025" align="center"
+        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)">Function Overloading
+      </h1>
+
+<h2>An Example</h2>
+      <p>
+        To expose overloaded functions in Python, simply <code>def()</code> each
+        one with the same Python name:
+<blockquote>
+<pre>
+inline int f1() { return 3; }
+inline int f2(int x) { return x + 1; }
+
+class X {
+public:
+    X() : m_value(0) {}
+    X(int n) : m_value(n) {}
+    int value() const { return m_value; }
+    void value(int v) { m_value = v; }
+private:
+    int m_value;
+};
+  ...
+
+BOOST_PYTHON_MODULE_INIT(overload_demo)
+{
+    try
+    {
+        boost::python::module_builder overload_demo("overload_demo");
+        // Overloaded functions at module scope
+        overload_demo.def(f1, "f");
+        overload_demo.def(f2, "f");
+
+        boost::python::class_builder&lt;X&gt; x_class(overload_demo, "X");
+        // Overloaded constructors
+        x_class.def(boost::python::constructor&lt;&gt;());
+        x_class.def(boost::python::constructor&lt;int&gt;());
+
+        // Overloaded member functions
+        x_class.def((int (X::*)() const)&amp;X::value, "value");
+        x_class.def((void (X::*)(int))&amp;X::value, "value");
+  ...
+</pre>
+</blockquote>
+
+      <p>
+        Now in Python:
+<blockquote>
+<pre>
+>>> from overload_demo import *
+>>> x0 = X()
+>>> x1 = X(1)
+>>> x0.value()
+0
+>>> x1.value()
+1
+>>> x0.value(3)
+>>> x0.value()
+3
+>>> X('hello')
+TypeError: No overloaded functions match (X, string). Candidates are:
+void (*)()
+void (*)(int)
+>>> f()
+3
+>>> f(4)
+5
+</pre>
+</blockquote>
+
+<h2>Discussion</h2>
+      <p>
+        Notice that overloading in the Python module was produced three ways:<ol>
+        <li>by combining the non-overloaded C++ functions <code>int f1()</code>
+        and <code>int f2(int)</code> and exposing them as <code>f</code> in Python.
+        <li>by exposing the overloaded constructors of <code>class X</code>
+        <li>by exposing the overloaded member functions <code>X::value</code>.
+        </ol>
+      <p>
+        Techniques 1. and 3. above are really alternatives. In case 3, you need
+        to form a pointer to each of the overloaded functions. The casting
+        syntax shown above is one way to do that in C++. Case 1 does not require
+        complicated-looking casts, but may not be viable if you can't change
+        your C++ interface. N.B. There's really nothing unsafe about casting an
+        overloaded (member) function address this way: the compiler won't let
+        you write it at all unless you get it right.
+
+<h2>An Alternative to Casting</h2>
+      <p>
+        This approach is not neccessarily better, but may be preferable for some
+        people who have trouble writing out the types of (member) function
+        pointers or simply prefer to avoid all casts as a matter of principle:
+<blockquote>
+<pre>
+// Forwarding functions for X::value
+inline void set_x_value(X&amp; self, int v) { self.value(v); }
+inline int get_x_value(X&amp; self) { return self.value(); }
+   ...
+        // Overloaded member functions
+        x_class.def(set_x_value, "value");
+        x_class.def(get_x_value, "value");
+</pre>
+</blockquote>
+<p>Here we are taking advantage of the ability to expose C++ functions at
+namespace scope as Python member functions.
+
+<h2>Overload Resolution</h2>
+      <p>
+        The function overload resolution mechanism  works as follows:
+
+        <ul>
+
+        <li>Attribute lookup for extension classes proceeds in <a
+        href="http://www.python.org/doc/current/tut/node11.html#SECTION0011510000000000000000">the
+        usual Python way</a> using a depth-first, left-to-right search. When a
+        class is found which has a matching attribute, only functions overloaded
+        in the context of that class are candidates for overload resolution. In
+        this sense, overload resolution mirrors the C++ mechanism, where a name
+        in a derived class ``hides'' all functions with the same name from a base
+        class.
+        <p>
+
+        <li>Within a name-space context (extension class or module), overloaded
+        functions are tried in the same order they were
+        <code>def()</code>ed. The first function whose signature can be made to
+        match each argument passed is the one which is ultimately called. 
+        This means in particular that you cannot overload the same function on 
+        both ``<code>int</code>'' and ``<code>float</code>'' because Python 
+        automatically converts either of the two types into the other one. 
+        If the ``<code>float</code>'' overload is found first, it is used 
+        also used for arguments of type ``<code>int</code>'' as well, and the 
+        ``<code>int</code>'' version of the function is never invoked.
+        </ul>
+
+      <p>
+         Next: <a href="inheritance.html">Inheritance</a>
+         Previous: <a href="overriding.html">Overridable Virtual Functions</a>
+         Up: <a href="index.html">Top</a>
+      <p>
+         &copy; Copyright David Abrahams 2001. Permission to copy, use, modify,
+        sell and distribute this document is granted provided this copyright
+        notice appears in all copies. This document is provided ``as
+        is'' without express or implied warranty, and with no claim as to
+        its suitability for any purpose.
+      <p>
+         Updated: Mar 6, 2001
+    </div>
+

doc/overriding.html

@@ -0,0 +1,208 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
+    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+
+    <title>Overridable Virtual Functions</title>
+
+    <img src="../../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center"
+    width="277" height="86"> 
+
+    <h1>Overridable Virtual Functions</h1>
+
+<p> 
+  In the <a href="exporting_classes.html">previous example</a> we exposed a simple
+  C++ class in Python and showed that we could write a subclass. We even
+  redefined one of the functions in our derived class. Now we will learn
+  how to make the function behave virtually <em>when called from C++</em>. 
+
+
+<h2><a name="overriding_example">Example</a></h2>
+
+<p>In this example, it is assumed that <code>hello::greet()</code> is a virtual
+member function:
+
+<blockquote><pre>
+class hello
+{
+ public:
+    hello(const std::string&amp; country) { this-&gt;country = country; }
+    <b>virtual</b> std::string greet() const { return "Hello from " + country; }
+    virtual ~hello(); // Good practice 
+    ...
+};
+</pre></blockquote>
+
+<p>
+  We'll need a derived class<a href="#why_derived">*</a> to help us
+  dispatch the call to Python. In our derived class, we need the following
+  elements:
+
+<ol>
+
+  <li><a name="derived_1">A</a> <code>PyObject*</code> data member (usually
+  called <tt>self</tt>) that holds a pointer to the Python object corresponding
+  to our C++ <tt>hello</tt> instance.
+
+  <li><a name="derived_2">For</a>  each exposed constructor of the
+  base class <tt>T</tt>, a constructor which takes the same parameters preceded by an initial
+  <code>PyObject*</code> argument. The initial argument should be stored in the <tt>self</tt> data
+  member described above. 
+
+  <li><a name="derived_3">If</a> the class being wrapped is ever returned <i>by
+  value</i> from a wrapped function, be sure you do the same for the
+  <tt>T</tt>'s copy constructor: you'll need a constructor taking arguments
+  <tt>(PyObject*,&nbsp;const&nbsp;T&amp;)</tt>.
+
+  <li><a name="derived_4">An</a> implementation of each virtual function you may
+  wish to override in Python which uses
+  <tt>callback&lt</tt><i>return-type</i><tt>&gt;::call_method(self,&nbsp;&quot;</tt><i>name</i><tt>&quot;,&nbsp;</tt><i>args...</i><tt>)</tt> to call
+  the Python override.
+
+  <li><a name="derived_5">For</a> each non-pure virtual function meant to be
+  overridable from Python, a static member function (or a free function) taking
+  a reference or pointer to the <tt>T</tt> as the first parameter and which
+  forwards any additional parameters neccessary to the <i>default</i>
+  implementation of the virtual function. See also <a href="#private">this
+  note</a> if the base class virtual function is private.
+
+</ol>
+
+<blockquote><pre>
+struct hello_callback : hello
+{
+    // hello constructor storing initial self_ parameter
+    hello_callback(PyObject* self_, const std::string&amp; x) // <a href="#derived_2">2</a>
+        : hello(x), self(self_) {}
+
+    // In case hello is returned by-value from a wrapped function
+    hello_callback(PyObject* self_, const hello&amp; x) // <a href="#derived_3">3</a>
+        : hello(x), self(self_) {}
+
+    // Override greet to call back into Python
+    std::string greet() const // <a href="#derived_4">4</a>
+        { return boost::python::callback&lt;std::string&gt;::call_method(self, "greet"); }
+
+    // Supplies the default implementation of greet
+    static std::string <a name= "default_implementation">default_greet</a>(const hello& self_) const // <a href="#derived_5">5</a>
+        { return self_.hello::greet(); }
+ private:
+    PyObject* self; // <a href="#derived_1">1</a>
+};
+</pre></blockquote>
+
+<p>
+  Finally, we add <tt>hello_callback</tt> to the <tt>
+  class_builder&lt;&gt;</tt> declaration in our module initialization
+  function, and when we define the function, we must tell Boost.Python about the default
+  implementation:
+
+<blockquote><pre>
+// Create the <a name=
+"hello_class">Python type object</a> for our extension class
+boost::python::class_builder&lt;hello<strong>,hello_callback&gt;</strong> hello_class(hello, "hello");
+// Add a virtual member function
+hello_class.def(&amp;hello::greet, "greet", &amp;<b>hello_callback::default_greet</b>);
+</pre></blockquote>
+
+<p>
+ Now our Python subclass of <tt>hello</tt> behaves as expected:
+
+<blockquote><pre>
+&gt;&gt;&gt; class wordy(hello):
+...     def greet(self):
+...         return hello.greet(self) + ', where the weather is fine'
+...
+&gt;&gt;&gt; hi2 = wordy('Florida')
+&gt;&gt;&gt; hi2.greet()
+'Hello from Florida, where the weather is fine'
+&gt;&gt;&gt; invite(hi2)
+'Hello from Florida, where the weather is fine! Please come soon!'
+</pre></blockquote>
+    <p>
+      <a name="why_derived">*</a>You may ask, "Why do we need this derived
+      class? This could have been designed so that everything gets done right
+      inside of <tt>hello</tt>." One of the goals of Boost.Python is to be
+      minimally intrusive on an existing C++ design. In principle, it should be
+      possible to expose the interface for a 3rd party library without changing
+      it. To unintrusively hook into the virtual functions so that a Python
+      override may be called, we must use a derived class.
+
+<h2>Pure Virtual Functions</h2>
+
+    <p>
+      A pure virtual function with no implementation is actually a lot easier to
+      deal with than a virtual function with a default implementation. First of
+      all, you obviously don't need to <a href="#default_implementation"> supply
+      a default implementation</a>. Secondly, you don't need to call
+      <tt>def()</tt> on the <tt>extension_class&lt;&gt;</tt> instance
+      for the virtual function. In fact, you wouldn't <em>want</em> to: if the
+      corresponding attribute on the Python class stays undefined, you'll get an
+      <tt>AttributeError</tt> in Python when you try to call the function,
+      indicating that it should have been implemented. For example:
+    <blockquote>
+<pre>
+struct baz {
+    <strong>virtual</strong> int pure(int) = 0;
+    int calls_pure(int x) { return pure(x) + 1000; }
+};
+
+struct baz_callback {
+    int pure(int x) { boost::python::callback&lt;int&gt;::call_method(m_self, "pure", x); }
+};
+
+BOOST_PYTHON_MODULE_INIT(foobar)
+{
+     boost::python::module_builder foobar("foobar");                          
+     boost::python::class_builder&lt;baz,baz_callback&gt; baz_class("baz");   
+     baz_class.def(&amp;baz::calls_pure, "calls_pure"); 
+}
+</pre>
+    </blockquote>
+    <p>
+      Now in Python:
+    <blockquote>
+<pre>
+&gt;&gt;&gt; from foobar import baz
+&gt;&gt;&gt; x = baz()
+&gt;&gt;&gt; x.pure(1)
+Traceback (innermost last):
+  File "&lt;stdin&gt;", line 1, in ?
+AttributeError: pure
+&gt;&gt;&gt; x.calls_pure(1)
+Traceback (innermost last):
+  File "&lt;stdin&gt;", line 1, in ?
+AttributeError: pure
+&gt;&gt;&gt; class mumble(baz):
+...    def pure(self, x): return x + 1
+...
+&gt;&gt;&gt; y = mumble()
+&gt;&gt;&gt; y.pure(99)
+100
+&gt;&gt;&gt; y.calls_pure(99)
+1100
+</pre></blockquote>
+
+<a name="private"><h2>Private Non-Pure Virtual Functions</h2></a>
+
+<p>This is one area where some minor intrusiveness on the wrapped library is
+required. Once it has been overridden, the only way to call the base class
+implementation of a private virtual function is to make the derived class a
+friend of the base class. You didn't hear it from me, but most C++
+implementations will allow you to change the declaration of the base class in
+this limited way without breaking binary compatibility (though it will certainly
+break the <a
+href="http://cs.calvin.edu/c++/C++Standard-Nov97/basic.html#basic.def.odr">ODR</a>).
+
+<hr>
+    <p>
+      Next: <a href="overloading.html">Function Overloading</a>
+      Previous: <a href="exporting_classes.html">Exporting Classes</a>
+      Up: <a href="index.html">Top</a>
+    <p>
+      &copy; Copyright David Abrahams 2001. Permission to copy, use, modify,
+      sell and distribute this document is granted provided this copyright
+      notice appears in all copies. This document is provided "as is" without
+      express or implied warranty, and with no claim as to its suitability for
+      any purpose.
+    <p>
+      Updated: Mar 21, 2001
+

doc/pickle.html

@@ -5,7 +5,7 @@
 
 <div>
 
-<img src="../../../../c++boost.gif"
+<img src="../../../c++boost.gif"
      alt="c++boost.gif (8819 bytes)"
      align="center"
      width="277" height="86">
@@ -26,14 +26,16 @@ converts nearly arbitrary Python objects into a stream of bytes that
 can be written to a file.
 
 <p>
-The Boost Python Library supports the pickle module
-through the interface as described in detail in the
+The Boost Python Library supports the pickle module by emulating the
+interface implemented by Jim Fulton's ExtensionClass module that is
+included in the
+<a href="http://www.zope.org/"
+>ZOPE</a>
+distribution.
+This interface is similar to that for regular Python classes as
+described in detail in the
 <a href="http://www.python.org/doc/current/lib/module-pickle.html"
->Python Library Reference for pickle.</a> This interface
-involves the special methods <tt>__getinitargs__</tt>,
-<tt>__getstate__</tt> and <tt>__setstate__</tt> as described
-in the following. Note that Boost.Python is also fully compatible
-with Python's cPickle module.
+>Python Library Reference for pickle.</a>
 
 <hr>
 <h2>The Boost.Python Pickle Interface</h2>
@@ -53,9 +55,8 @@ methods:
   the class constructor.
 
   <p>
-  If <tt>__getinitargs__</tt> is not defined, <tt>pickle.load</tt>
-  will call the constructor (<tt>__init__</tt>) without arguments;
-  i.e., the object must be default-constructible.
+  If <tt>__getinitargs__</tt> is not defined, the class constructor
+  will be called without arguments.
 
 <p>
 <dt>
@@ -67,137 +68,94 @@ methods:
   This method should return a Python object representing the state of
   the instance.
 
+  <p>
+  If <tt>__getstate__</tt> is not defined, the instance's
+  <tt>__dict__</tt> is pickled (if it is not empty).
+
 <p>
 <dt>
 <strong><tt>__setstate__</tt></strong>
 
 <dd>
   When an instance of a Boost.Python extension class is restored by the
-  unpickler (<tt>pickle.load</tt>), it is first constructed using the
-  result of <tt>__getinitargs__</tt> as arguments (see above). Subsequently
-  the unpickler tests if the new instance has a <tt>__setstate__</tt>
+  unpickler, it is first constructed using the result of
+  <tt>__getinitargs__</tt> as arguments (see above). Subsequently the
+  unpickler tests if the new instance has a <tt>__setstate__</tt>
   method. If so, this method is called with the result of
   <tt>__getstate__</tt> (a Python object) as the argument.
 
+  <p>
+  If <tt>__setstate__</tt> is not defined, the result of
+  <tt>__getstate__</tt> must be a Python dictionary. The items of this
+  dictionary are added to the instance's <tt>__dict__</tt>.
+
 </dl>
 
-The three special methods described above may be <tt>.def()</tt>'ed
-individually by the user. However, Boost.Python provides an easy to use
-high-level interface via the
-<strong><tt>boost::python::pickle_suite</tt></strong> class that also
-enforces consistency: <tt>__getstate__</tt> and <tt>__setstate__</tt>
-must be defined as pairs. Use of this interface is demonstrated by the
-following examples.
+If both <tt>__getstate__</tt> and <tt>__setstate__</tt> are defined,
+the Python object returned by <tt>__getstate__</tt> need not be a
+dictionary. The <tt>__getstate__</tt> and <tt>__setstate__</tt> methods
+can do what they want.
 
 <hr>
-<h2>Examples</h2>
+<h2>Pitfalls and Safety Guards</h2>
 
-There are three files in <a href="../../test/"
-><tt>boost/libs/python/test</tt></a> that show how to
-provide pickle support.
+In Boost.Python extension modules with many extension classes,
+providing complete pickle support for all classes would be a
+significant overhead. In general complete pickle support should only be
+implemented for extension classes that will eventually be pickled.
+However, the author of a Boost.Python extension module might not
+anticipate correctly which classes need support for pickle.
+Unfortunately, the pickle protocol described above has two important
+pitfalls that the end user of a Boost.Python extension module might not
+be aware of:
 
-<hr>
-<h3><a href="../../test/pickle1.cpp"><tt>pickle1.cpp</tt></a></h3>
+<dl>
+<dt>
+<strong>Pitfall 1:</strong>
+Both <tt>__getinitargs__</tt> and <tt>__getstate__</tt> are not defined.
 
-    The C++ class in this example can be fully restored by passing the
-    appropriate argument to the constructor. Therefore it is sufficient
-    to define the pickle interface method <tt>__getinitargs__</tt>.
-    This is done in the following way:
+<dd>
+  In this situation the unpickler calls the class constructor without
+  arguments and then adds the <tt>__dict__</tt> that was pickled by
+  default to that of the new instance.
+
+  <p>
+  However, most C++ classes wrapped with Boost.Python will have member
+  data that are not restored correctly by this procedure. To alert the
+  user to this problem, a safety guard is provided. If both
+  <tt>__getinitargs__</tt> and <tt>__getstate__</tt> are not defined,
+  Boost.Python tests if the class has an attribute
+  <tt>__dict_defines_state__</tt>. An exception is raised if this
+  attribute is not defined:
 
-<ul>
-<li>1. Definition of the C++ pickle function:
 <pre>
-  struct world_pickle_suite : boost::python::pickle_suite
-  {
-    static
-    boost::python::tuple
-    getinitargs(world const&amp; w)
-    {
-        return boost::python::make_tuple(w.get_country());
-    }
-  };
+    RuntimeError: Incomplete pickle support (__dict_defines_state__ not set)
 </pre>
-<li>2. Establishing the Python binding:
+
+  In the rare cases where this is not the desired behavior, the safety
+  guard can deliberately be disabled. The corresponding C++ code for
+  this is, e.g.:
+
 <pre>
-  class_&lt;world&gt;("world", args&lt;const std::string&amp;&gt;())
-      // ...
-      .def_pickle(world_pickle_suite())
-      // ...
+    class_builder&lt;your_class&gt; py_your_class(your_module, "your_class");
+    py_your_class.dict_defines_state();
 </pre>
-</ul>
 
-<hr>
-<h3><a href="../../test/pickle2.cpp"><tt>pickle2.cpp</tt></a></h3>
+  It is also possible to override the safety guard at the Python level.
+  E.g.:
 
-    The C++ class in this example contains member data that cannot be
-    restored by any of the constructors. Therefore it is necessary to
-    provide the <tt>__getstate__</tt>/<tt>__setstate__</tt> pair of
-    pickle interface methods:
-
-<ul>
-<li>1. Definition of the C++ pickle functions:
 <pre>
-  struct world_pickle_suite : boost::python::pickle_suite
-  {
-    static
-    boost::python::tuple
-    getinitargs(const world&amp; w)
-    {
-      // ...
-    }
-
-    static
-    boost::python::tuple
-    getstate(const world&amp; w)
-    {
-      // ...
-    }
-
-    static
-    void
-    setstate(world&amp; w, boost::python::tuple state)
-    {
-      // ...
-    }
-  };
+    import your_bpl_module
+    class your_class(your_bpl_module.your_class):
+      __dict_defines_state__ = 1
 </pre>
-<li>2. Establishing the Python bindings for the entire suite:
-<pre>
-  class_&lt;world&gt;("world", args&lt;const std::string&amp;&gt;())
-      // ...
-      .def_pickle(world_pickle_suite())
-      // ...
-</pre>
-</ul>
 
-    <p>
-    For simplicity, the <tt>__dict__</tt> is not included in the result
-    of <tt>__getstate__</tt>. This is not generally recommended, but a
-    valid approach if it is anticipated that the object's
-    <tt>__dict__</tt> will always be empty. Note that the safety guard
-    described below will catch the cases where this assumption is violated.
-
-<hr>
-<h3><a href="../../test/pickle3.cpp"><tt>pickle3.cpp</tt></a></h3>
-
-    This example is similar to <a
-    href="../../test/pickle2.cpp"><tt>pickle2.cpp</tt></a>. However, the
-    object's <tt>__dict__</tt> is included in the result of
-    <tt>__getstate__</tt>.  This requires a little more code but is
-    unavoidable if the object's <tt>__dict__</tt> is not always empty.
-
-<hr>
-<h2>Pitfall and Safety Guard</h2>
-
-The pickle protocol described above has an important pitfall that the
-end user of a Boost.Python extension module might not be aware of:
-<p>
-<strong>
-<tt>__getstate__</tt> is defined and the instance's <tt>__dict__</tt>
-is not empty.
-</strong>
 <p>
+<dt>
+<strong>Pitfall 2:</strong>
+<tt>__getstate__</tt> is defined and the instance's <tt>__dict__</tt> is not empty.
 
+<dd>
   The author of a Boost.Python extension class might provide a
   <tt>__getstate__</tt> method without considering the possibilities
   that:
@@ -231,20 +189,15 @@ is not empty.
   To resolve this problem, it should first be established that the
   <tt>__getstate__</tt> and <tt>__setstate__</tt> methods manage the
   instances's <tt>__dict__</tt> correctly. Note that this can be done
-  either at the C++ or the Python level. Finally, the safety guard
-  should intentionally be overridden. E.g. in C++ (from
-  <a href="../../test/pickle3.cpp"><tt>pickle3.cpp</tt></a>):
+  both at the C++ and the Python level. Finally, the safety guard
+  should intentionally be overridden.  E.g. in C++:
 
 <pre>
-  struct world_pickle_suite : boost::python::pickle_suite
-  {
-    // ...
-
-    static bool getstate_manages_dict() { return true; }
-  };
+    class_builder&lt;your_class&gt; py_your_class(your_module, "your_class");
+    py_your_class.getstate_manages_dict();
 </pre>
 
-  Alternatively in Python:
+  In Python:
 
 <pre>
     import your_bpl_module
@@ -255,23 +208,16 @@ is not empty.
       def __setstate__(self, state):
         # your code here
 </pre>
+</dl>
 
 <hr>
 <h2>Practical Advice</h2>
 
 <ul>
-<li>
-  In Boost.Python extension modules with many extension classes,
-  providing complete pickle support for all classes would be a
-  significant overhead. In general complete pickle support should
-  only be implemented for extension classes that will eventually
-  be pickled.
-
-<p>
 <li>
   Avoid using <tt>__getstate__</tt> if the instance can also be
   reconstructed by way of <tt>__getinitargs__</tt>. This automatically
-  avoids the pitfall described above.
+  avoids Pitfall 2.
 
 <p>
 <li>
@@ -281,13 +227,46 @@ is not empty.
 </ul>
 
 <hr>
+<h2>Examples</h2>
 
-&copy; Copyright Ralf W. Grosse-Kunstleve 20012-2002. Permission to copy,
+There are three files in <tt>boost/libs/python/example</tt> that
+show how so provide pickle support.
+
+<h3><a href="../example/pickle1.cpp"><tt>pickle1.cpp</tt></a></h3>
+
+    The C++ class in this example can be fully restored by passing the
+    appropriate argument to the constructor. Therefore it is sufficient
+    to define the pickle interface method <tt>__getinitargs__</tt>.
+
+<h3><a href="../example/pickle2.cpp"><tt>pickle2.cpp</tt></a></h3>
+
+    The C++ class in this example contains member data that cannot be
+    restored by any of the constructors. Therefore it is necessary to
+    provide the <tt>__getstate__</tt>/<tt>__setstate__</tt> pair of
+    pickle interface methods.
+
+    <p>
+    For simplicity, the <tt>__dict__</tt> is not included in the result
+    of <tt>__getstate__</tt>. This is not generally recommended, but a
+    valid approach if it is anticipated that the object's
+    <tt>__dict__</tt> will always be empty. Note that the safety guards
+    will catch the cases where this assumption is violated.
+
+<h3><a href="../example/pickle3.cpp"><tt>pickle3.cpp</tt></a></h3>
+
+    This example is similar to <a
+    href="../example/pickle2.cpp"><tt>pickle2.cpp</tt></a>. However, the
+    object's <tt>__dict__</tt> is included in the result of
+    <tt>__getstate__</tt>.  This requires more code but is unavoidable
+    if the object's <tt>__dict__</tt> is not always empty.
+
+<hr>
+&copy; Copyright Ralf W. Grosse-Kunstleve 2001. Permission to copy,
 use, modify, sell and distribute this document is granted provided this
 copyright notice appears in all copies. This document is provided "as
 is" without express or implied warranty, and with no claim as to its
 suitability for any purpose.
 
 <p>
-Updated: Aug 2002.
+Updated: March 21, 2001
 </div>

doc/pointers.html

@@ -0,0 +1,148 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
+"http://www.w3.org/TR/REC-html40/strict.dtd">
+    <title>
+      Pointers
+    </title>
+    <div>
+      <h1>
+         <img width="277" height="86" id="_x0000_i1025" align="center"
+        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)">Pointers
+      </h1>
+
+<h2><a name="problem">The Problem With Pointers</a></h2>
+
+      <p>
+In general, raw pointers passed to or returned from functions are problematic
+for Boost.Python because pointers have too many potential meanings. Is it an iterator?
+A pointer to a single element? An array? When used as a return value, is the
+caller expected to manage (delete) the pointed-to object or is the pointer
+really just a reference? If the latter, what happens to Python references to the
+referent when some C++ code deletes it?
+<p>
+There are a few cases in which pointers are converted automatically:
+<ul>
+
+<li>Both const- and non-const pointers to wrapped class instances can be passed
+<i>to</i> C++ functions. 
+
+<li>Values of type <code>const char*</code> are interpreted as
+null-terminated 'C' strings and when passed to or returned from C++ functions are
+converted from/to Python strings.
+
+</ul>
+
+<h3>Can you avoid the problem?</h3>
+
+<p>My first piece of advice to anyone with a case not covered above is
+``find a way to avoid the problem.'' For example, if you have just one
+or two functions that return a pointer to an individual <code>const
+T</code>, and <code>T</code> is a wrapped class, you may be able to write a ``thin
+converting wrapper'' over those two functions as follows:
+
+<blockquote><pre>
+const Foo* f(); // original function
+const Foo& f_wrapper() { return *f(); }
+  ...
+my_module.def(f_wrapper, "f");
+</pre></blockquote>
+<p>
+Foo must have a public copy constructor for this technique to work, since Boost.Python
+converts <code>const T&</code> values <code>to_python</code> by copying the <code>T</code>
+value into a new extension instance.
+
+<h2>Dealing with the problem</h2>
+
+<p>The first step in handling the remaining cases is to figure out what the pointer
+means. Several potential solutions are provided in the examples that follow:
+
+<h3>Returning a pointer to a wrapped type</h3>
+
+<h4>Returning a const pointer</h4>
+
+<p>If you have lots of functions returning a <code>const T*</code> for some
+wrapped <code>T</code>, you may want to provide an automatic
+<code>to_python</code> conversion function so you don't have to write lots of
+thin wrappers. You can do this simply as follows:
+
+<blockquote><pre>
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
+  PyObject* to_python(const Foo* p) {
+     return to_python(*p); // convert const Foo* in terms of const Foo&
+  }
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
+</pre></blockquote>
+
+<h4>If you can't (afford to) copy the referent, or the pointer is non-const</h4>
+
+<p>If the wrapped type doesn't have a public copy constructor, if copying is
+<i>extremely</i> costly (remember, we're dealing with Python here), or if the
+pointer is non-const and you really need to be able to modify the referent from
+Python, you can use the following dangerous trick. Why dangerous? Because python
+can not control the lifetime of the referent, so it may be destroyed by your C++
+code before the last Python reference to it disappears:
+
+<blockquote><pre>
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
+  PyObject* to_python(Foo* p)
+  {
+      return boost::python::python_extension_class_converters&lt;Foo&gt;::smart_ptr_to_python(p);
+  }
+
+  PyObject* to_python(const Foo* p)
+  {
+      return to_python(const_cast&lt;Foo*&gt;(p));
+  }
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
+</pre></blockquote>
+
+This will cause the Foo* to be treated as though it were an owning smart
+pointer, even though it's not. Be sure you don't use the reference for anything
+from Python once the pointer becomes invalid, though. Don't worry too much about
+the <code>const_cast&lt;&gt;</code> above: Const-correctness is completely lost
+to Python anyway!
+
+<h3>[In/]Out Parameters and Immutable Types</h3>
+
+<p>If you have an interface that uses non-const pointers (or references) as
+in/out parameters to types which in Python are immutable (e.g. int, string),
+there simply is <i>no way</i> to get the same interface in Python. You must
+resort to transforming your interface with simple thin wrappers as shown below:
+<blockquote><pre>
+const void f(int* in_out_x); // original function
+const int f_wrapper(int in_x) { f(in_x); return in_x; }
+  ...
+my_module.def(f_wrapper, "f");
+</pre></blockquote>
+
+<p>Of course, [in/]out parameters commonly occur only when there is already a
+return value. You can handle this case by returning a Python tuple:
+<blockquote><pre>
+typedef unsigned ErrorCode;
+const char* f(int* in_out_x); // original function
+ ...
+#include &lt;boost/python/objects.hpp&gt;
+const boost::python::tuple f_wrapper(int in_x) { 
+  const char* s = f(in_x); 
+  return boost::python::tuple(s, in_x);
+}
+  ...
+my_module.def(f_wrapper, "f");
+</pre></blockquote>
+<p>Now, in Python:
+<blockquote><pre>
+&gt;&gt;&gt; str,out_x = f(3)
+</pre></blockquote>
+
+<p>
+         Previous: <a href="enums.html">Enums</a>
+         Up: <a href="index.html">Top</a>
+      <p>
+         &copy; Copyright David Abrahams 2000. Permission to copy, use, modify,
+        sell and distribute this document is granted provided this copyright
+        notice appears in all copies. This document is provided "as is" without
+        express or implied warranty, and with no claim as to its suitability
+        for any purpose.
+      <p>
+         Updated: Nov 26, 2000
+    </div>
+

doc/richcmp.html

@@ -0,0 +1,106 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
+"http://www.w3.org/TR/REC-html40/strict.dtd">
+
+<title>Rich Comparisons</title>
+
+<div>
+
+<img src="../../../c++boost.gif"
+     alt="c++boost.gif (8819 bytes)"
+     align="center"
+     width="277" height="86">
+
+<hr>
+<h1>Rich Comparisons</h1>
+
+<hr>
+In Python versions up to and including Python 2.0, support for
+implementing comparisons on user-defined classes and extension types
+was quite simple. Classes could implement a <tt>__cmp__</tt> method
+that was given two instances of a class as arguments, and could only
+return <tt>0</tt> if they were equal or <tt>+1</tt> or <tt>-1</tt> if
+they were not. The method could not raise an exception or return
+anything other than an integer value.
+In Python 2.1, <b>Rich Comparisons</b> were added (see
+<a href="http://python.sourceforge.net/peps/pep-0207.html">PEP 207</a>).
+Python classes can now individually overload each of the &lt;, &lt;=,
+&gt;, &gt;=, ==, and != operations.
+
+<p>
+For more detailed information, search for "rich comparison"
+<a href="http://www.python.org/doc/current/ref/customization.html"
+>here</a>.
+
+<p>
+Boost.Python supports both automatic overloading and manual overloading
+of the Rich Comparison operators. The <b>compile-time</b> support is
+independent of the Python version that is used when compiling
+Boost.Python extension modules. That is, <tt>op_lt</tt> for example can
+always be used, and the C++ <tt>operator&lt;</tt> will always be bound
+to the Python method <tt>__lt__</tt>. However, the <b>run-time</b>
+behavior will depend on the Python version.
+
+<p>
+With Python versions before 2.1, the Rich Comparison operators will not
+be called by Python when any of the six comparison operators
+(<tt>&lt;</tt>, <tt>&lt;=</tt>, <tt>==</tt>, <tt>!=</tt>,
+<tt>&gt;</tt>, <tt>&gt;=</tt>) is used in an expression. The only way
+to access the corresponding methods is to call them explicitly, e.g.
+<tt>a.__lt__(b)</tt>. Only with Python versions 2.1 or higher will
+expressions like <tt>a &lt; b</tt> work as expected.
+
+<p>
+To support Rich Comparisions, the Python C API was modified between
+Python versions 2.0 and 2.1. A new slot was introduced in the
+<tt>PyTypeObject</tt> structure: <tt>tp_richcompare</tt>. For backwards
+compatibility, a flag (<tt>Py_TPFLAGS_HAVE_RICHCOMPARE</tt>) has to be
+set to signal to the Python interpreter that Rich Comparisions are
+supported by a particular type.
+There is only one flag for all the six comparison operators.
+When any of the six operators is wrapped automatically or
+manually, Boost.Python will set this flag. Attempts to use comparison
+operators at the Python level that are not defined at the C++ level
+will then lead to an <tt>AttributeError</tt> when the Python 2.1
+(or higher) interpreter tries, e.g., <tt>a.__lt__(b)</tt>. That
+is, in general all six operators should be supplied. Automatically
+wrapped operators and manually wrapped operators can be mixed. For
+example:<pre>
+    boost::python::class_builder&lt;code&gt; py_code(this_module, "code");
+
+    py_code.def(boost::python::constructor&lt;&gt;());
+    py_code.def(boost::python::constructor&lt;int&gt;());
+    py_code.def(boost::python::operators&lt;(  boost::python::op_eq
+                                          | boost::python::op_ne)&gt;());
+    py_code.def(NotImplemented, "__lt__");
+    py_code.def(NotImplemented, "__le__");
+    py_code.def(NotImplemented, "__gt__");
+    py_code.def(NotImplemented, "__ge__");
+</pre>
+
+<tt>NotImplemented</tt> is a simple free function that (currently) has
+to be provided by the user. For example:<pre>
+  boost::python::ref
+  NotImplemented(const code&amp;, const code&amp;) {
+    return
+    boost::python::ref(Py_NotImplemented, boost::python::ref::increment_count);
+  }
+</pre>
+
+See also:
+<ul>
+<li><a href="../example/richcmp1.cpp"><tt>../example/richcmp1.cpp</tt></a>
+<li><a href="../example/richcmp2.cpp"><tt>../example/richcmp2.cpp</tt></a>
+<li><a href="../example/richcmp3.cpp"><tt>../example/richcmp3.cpp</tt></a>
+</ul>
+
+<hr>
+&copy; Copyright Nicholas K. Sauter &amp; Ralf W. Grosse-Kunstleve 2001.
+Permission to copy, use, modify, sell and distribute this document is
+granted provided this copyright notice appears in all copies. This
+document is provided "as is" without express or implied warranty, and
+with no claim as to its suitability for any purpose.
+
+<p>
+Updated: July 2001
+
+</div>

doc/special.html

@@ -0,0 +1,973 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+    <title>
+      Special Method and Operator Support
+    </title>
+    <div>
+      <h1>
+         <img width="277" height="86" id="_x0000_i1025" align="middle" src= 
+        "../../../c++boost.gif" alt="c++boost.gif (8819 bytes)">Special Method and
+        Operator Support
+      </h1>
+      <h2>
+         Overview
+      </h2>
+      <p>
+         Boost.Python supports all of the standard <a href=
+        "http://www.python.org/doc/current/ref/specialnames.html">
+        special method names</a> supported by real Python class instances <em>
+        except</em> <code>__complex__</code> (more on the reasons <a href=
+        "#reasons">below</a>). In addition, it can quickly and easily expose
+        suitable C++ functions and operators as Python operators. The following
+        categories of special method names are supported:
+<ul>
+<li><a href="#general">Basic Customization</a>
+<li><a href="#numeric">Numeric Operators</a>
+<li><a href="#sequence_and_mapping">Sequence and Mapping protocols</a>
+<li><a href="#getter_setter">Attribute Getters and Setters</a>
+</ul>
+
+<h2><a name="general">Basic Customization</a></h2>
+
+
+<p>
+      Python provides a number of special operators for basic customization of a
+      class. Only a brief description is provided below; more complete
+      documentation can be found <a
+      href="http://www.python.org/doc/current/ref/customization.html">here</a>.
+
+      <dl>
+        <dt>
+          <b><tt class='method'>__init__</tt></b>(<i>self</i>)
+        <dd>
+          Initialize the class instance. For extension classes not subclassed in
+          Python, <code> __init__</code> is defined by 
+          
+          <pre>    my_class.def(boost::python::constructor<...>())</pre> 
+          
+          (see section <a href="example1.html">"A Simple Example Using Boost.Python"</a>).<p>
+        <dt>
+          <b><tt class='method'>__del__</tt></b>(<i>self</i>)
+        <dd>
+          Called when the extension instance is about to be destroyed. For extension classes 
+          not subclassed in Python, <code> __del__</code> is always defined automatically by 
+          means of the class' destructor.
+        <dt>
+          <b><tt class='method'>__repr__</tt></b>(<i>self</i>)
+        <dd>
+          Create a string representation from which the object can be
+          reconstructed.
+        <dt>
+          <b><tt class='method'>__str__</tt></b>(<i>self</i>)
+        <dd>
+          Create a string representation which is suitable for printing.
+        <dt>
+          <b><tt class='method'>__lt__</tt></b>(<i>self, other</i>)
+        <dt>
+          <b><tt class='method'>__le__</tt></b>(<i>self, other</i>)
+        <dt>
+          <b><tt class='method'>__eq__</tt></b>(<i>self, other</i>)
+        <dt>
+          <b><tt class='method'>__ne__</tt></b>(<i>self, other</i>)
+        <dt>
+          <b><tt class='method'>__gt__</tt></b>(<i>self, other</i>)
+        <dt>
+          <b><tt class='method'>__ge__</tt></b>(<i>self, other</i>)
+        <dd>
+	  Rich Comparison methods.
+          New in Python 2.1.
+          See <a href="richcmp.html">Rich Comparisons</a>.
+        <dt>
+          <b><tt class='method'>__cmp__</tt></b>(<i>self, other</i>)
+        <dd>
+	  Three-way compare function.
+          See <a href="richcmp.html">Rich Comparisons</a>.
+        <dt>
+          <b><tt class='method'>__hash__</tt></b>(<i>self</i>)
+        <dd>
+          Called for the key object for dictionary operations, and by the
+          built-in function hash(). Should return a 32-bit integer usable as a
+          hash value for dictionary operations (only allowed if __cmp__ is also
+          defined)
+        <dt>
+          <b><tt class='method'>__nonzero__</tt></b>(<i>self</i>)
+        <dd>
+          called if the object is used as a truth value (e.g. in an if
+          statement)
+        <dt>
+        <b><tt class='method'>__call__</tt></b> (<var>self</var><big>[</big><var>, args...</var><big>]</big>)
+<dd>
+Called when the instance is ``called'' as a function; if this method
+is defined, <code><var>x</var>(arg1, arg2, ...)</code> is a shorthand for
+<code><var>x</var>.__call__(arg1, arg2, ...)</code>.
+      </dl>
+
+      If we have a suitable C++ function that supports any of these features,
+      we can export it like any other function, using its Python special name.
+      For example, suppose that class <code>Foo</code> provides a string
+      conversion function: 
+<blockquote><pre>
+std::string to_string(Foo const&amp; f)
+{
+    std::ostringstream s;
+    s &lt;&lt; f;
+    return s.str();
+}
+</pre></blockquote>
+      This function would be wrapped like this: 
+<blockquote><pre>
+boost::python::class_builder&lt;Foo&gt; foo_class(my_module, "Foo");
+foo_class.def(&amp;to_string, "__str__");
+</pre></blockquote>
+      Note that Boost.Python also supports <em>automatic wrapping</em> of
+      <code>__str__</code> and <code>__cmp__</code>. This is explained in the <a
+      href="#numeric">next section</a> and the <a href="#numeric_table">Table of
+      Automatically Wrapped Methods</a>.
+
+<h2><a name="numeric">Numeric Operators</a></h2>
+
+<p>
+      Numeric operators can be exposed manually, by <code>def</code>ing C++
+      [member] functions that support the standard Python <a
+      href="http://www.python.org/doc/current/ref/numeric-types.html">numeric
+      protocols</a>. This is the same basic technique used to expose
+      <code>to_string()</code> as <code>__str__()</code> above, and is <a
+      href="#numeric_manual">covered in detail below</a>.  Boost.Python also supports
+      <i>automatic wrapping</i> of numeric operators whenever they have already
+      been defined in C++.
+
+<h3><a name="numeric_auto">Exposing C++ Operators Automatically</a></h3>
+
+<p>
+Supose we wanted to expose a C++ class
+      <code>BigNum</code> which supports addition. That is, in C++ we can write:
+<blockquote><pre>
+BigNum a, b, c;
+...
+c = a + b;
+</pre></blockquote>
+<p>
+      To enable the same functionality in Python, we first wrap the <code>
+      BigNum</code> class as usual: 
+<blockquote><pre>
+boost::python::class_builder&lt;BigNum&gt; bignum_class(my_module, "BigNum");
+bignum_class.def(boost::python::constructor&lt;&gt;());
+...
+</pre></blockquote>
+      Then we export the addition operator like this: 
+
+<blockquote><pre>
+bignum_class.def(boost::python::operators&lt;boost::python::op_add&gt;());
+</pre></blockquote>
+
+      Since BigNum also supports subtraction, multiplication, and division, we
+      want to export those also. This can be done in a single command by
+      ``or''ing the operator identifiers together (a complete list of these
+      identifiers and the corresponding operators can be found in the <a href= 
+      "#numeric_table">Table of Automatically Wrapped Methods</a>):
+<blockquote><pre>
+bignum_class.def(boost::python::operators&lt;(boost::python::op_sub | boost::python::op_mul | boost::python::op_div)&gt;());
+</pre></blockquote>
+      [Note that the or-expression must be enclosed in parentheses.]
+
+<p>This form of operator definition can be used to wrap unary and
+      homogeneous binary operators (a <i>homogeneous</i> operator has left and
+      right operands of the same type). Now suppose that our C++ library also
+      supports addition of BigNums and plain integers:
+
+<blockquote><pre>
+BigNum a, b;
+int i;
+...
+a = b + i;
+a = i + b;
+</pre></blockquote>
+      To wrap these heterogeneous operators, we need to specify a different type for
+      one of the operands. This is done using the <code>right_operand</code>
+      and <code>left_operand</code> templates: 
+<blockquote><pre>
+bignum_class.def(boost::python::operators&lt;boost::python::op_add&gt;(), boost::python::right_operand&lt;int&gt;());
+bignum_class.def(boost::python::operators&lt;boost::python::op_add&gt;(), boost::python::left_operand&lt;int&gt;());
+</pre></blockquote>
+      Boost.Python uses overloading to register several variants of the same
+      operation (more on this in the context of <a href="#coercion">
+      coercion</a>). Again, several operators can be exported at once: 
+<blockquote><pre>
+bignum_class.def(boost::python::operators&lt;(boost::python::op_sub | boost::python::op_mul | boost::python::op_div)&gt;(),
+                 boost::python::right_operand&lt;int&gt;());
+bignum_class.def(boost::python::operators&lt;(boost::python::op_sub | boost::python::op_mul | boost::python::op_div)&gt;(), 
+                 boost::python::left_operand&lt;int&gt;());
+</pre></blockquote>
+      The type of the operand not mentioned is taken from the class being wrapped. In
+      our example, the class object is <code>bignum_class</code>, and thus the
+      other operand's type is ``<code>BigNum const&amp;</code>''. You can override
+      this default by explicitly specifying a type in the <code>
+      operators</code> template: 
+<blockquote><pre>
+bignum_class.def(boost::python::operators&lt;boost::python::op_add, BigNum&gt;(), boost::python::right_operand&lt;int&gt;());
+</pre></blockquote>
+      <p>
+        Note that automatic wrapping uses the <em>expression</em>
+        ``<code>left + right</code>'' and can be used uniformly
+        regardless of whether the C++ operators are supplied as free functions
+
+ <blockquote><pre>
+BigNum operator+(BigNum, BigNum)
+</pre></blockquote>
+
+        or as member functions
+
+<blockquote><pre>
+BigNum::operator+(BigNum).
+</pre></blockquote>
+
+      <p>
+        For the Python built-in functions <code>pow()</code> and
+        <code>abs()</code>, there is no corresponding C++ operator. Instead,
+        automatic wrapping attempts to wrap C++ functions of the same name. This
+        only works if those functions are known in namespace
+        <code>python</code>.  On some compilers (e.g. MSVC) it might be
+        necessary to add a using declaration prior to wrapping:
+
+<blockquote><pre>
+namespace boost { namespace python { 
+  using my_namespace::pow;
+  using my_namespace::abs;
+}
+</pre></blockquote>
+
+<h3><a name="numeric_manual">Wrapping Numeric Operators Manually</a></h3>
+      <p>
+        In some cases, automatic wrapping of operators may be impossible or
+        undesirable. Suppose, for example, that the modulo operation for BigNums
+        is defined by a set of functions called <code>mod()</code>:
+
+<blockquote><pre>
+BigNum mod(BigNum const&amp; left, BigNum const&amp; right);
+BigNum mod(BigNum const&amp; left, int right);
+BigNum mod(int left, BigNum const&amp; right);
+</pre></blockquote>
+
+     <p>
+        For automatic wrapping of the modulo function, <code>operator%()</code> would be needed.
+        Therefore, the <code>mod()</code>-functions must be wrapped manually. That is, we have 
+        to export them explicitly with the Python special name "__mod__":
+
+<blockquote><pre>
+bignum_class.def((BigNum (*)(BigNum const&amp;, BigNum const&amp;))&amp;mod, "__mod__");
+bignum_class.def((BigNum (*)(BigNum const&amp;, int))&amp;mod, "__mod__");
+</pre></blockquote>
+
+<p>
+      The third form of <code>mod()</code> (with <code>int</code> as left operand) cannot 
+      be wrapped directly. We must first create a function <code>rmod()</code> with the
+      operands reversed: 
+
+<blockquote><pre>
+BigNum rmod(BigNum const&amp; right, int left)
+{
+    return mod(left, right);
+}
+</pre></blockquote>
+
+      This function must be wrapped under the name "__rmod__" (standing for "reverse mod"): 
+
+<blockquote><pre>
+bignum_class.def(&amp;rmod,  "__rmod__");
+</pre></blockquote>
+
+      Many of the possible operator names can be found in the <a href=
+      "#numeric_table">Table of Automatically Wrapped Methods</a>. Special treatment is
+      necessary to export the <a href="#ternary_pow">ternary pow</a> operator.
+
+      <p>
+        Automatic and manual wrapping can be mixed arbitrarily. Note that you
+        cannot overload the same operator for a given extension class on both
+        ``<code>int</code>'' and ``<code>float</code>'', because Python implicitly
+        converts these types into each other. Thus, the overloaded variant
+        found first (be it ``<code>int</code>`` or ``<code>float</code>'') will be
+        used for either of the two types.
+
+<h3><a name="inplace">Inplace Operators</a></h3>
+<p>
+        Boost.Python can also be used to expose inplace numeric operations
+        (i.e., <code>+=</code> and so forth).  These operators must be wrapped
+        manually, as described in the previous section.  For example, suppose
+        the class BigNum has an <code>operator+=</code>:
+
+<blockquote><pre>
+BigNum& operator+= (BigNum const&amp; right);
+</pre></blockquote>
+
+      This can be exposed by first writing a wrapper function:
+
+<blockquote><pre>
+BigNum& iadd (BigNum&amp; self, const BigNum&amp; right)
+{
+  return self += right;
+}
+</pre></blockquote>
+
+      and then exposing the wrapper with
+
+<blockquote><pre>
+bignum_class.def(&amp;iadd, "__iadd__");
+</pre></blockquote>
+
+
+
+
+<h3><a name="coercion">Coercion</a></h3>
+
+
+      Plain Python can only execute operators with identical types on the left
+      and right hand side. If it encounters an expression where the types of
+      the left and right operand differ, it tries to coerce these types to a
+      common type before invoking the actual operator. Implementing good
+      coercion functions can be difficult if many type combinations must be
+      supported. 
+      <p>
+        Boost.Python solves this problem the same way that C++ does: with <em><a
+        href="overloading.html">overloading</a></em>. This technique drastically
+        simplifies the code neccessary to support operators: you just register
+        operators for all desired type combinations, and Boost.Python automatically
+        ensures that the correct function is called in each case; there is no
+        need for user-defined coercion functions. To enable operator
+        overloading, Boost.Python provides a standard coercion which is <em>implicitly
+        registered</em> whenever automatic operator wrapping is used.
+      <p>
+        If you wrap all operator functions manually, but still want to use
+        operator overloading, you have to register the standard coercion
+        function explicitly:
+
+<blockquote><pre>
+// this is not necessary if automatic operator wrapping is used
+bignum_class.def_standard_coerce();
+</pre></blockquote>
+
+      If you encounter a situation where you absolutely need a customized
+      coercion, you can still define the "__coerce__" operator manually. The signature
+      of a coercion function should look like one of the following (the first is
+      the safest):
+
+<blockquote><pre>
+boost::python::tuple custom_coerce(boost::python::reference left, boost::python::reference right);
+boost::python::tuple custom_coerce(PyObject* left, PyObject* right);
+PyObject* custom_coerce(PyObject* left, PyObject* right);
+</pre></blockquote>
+
+      The resulting <code>tuple</code> must contain two elements which
+      represent the values of <code>left</code> and <code>right</code>
+      converted to the same type. Such a function is wrapped as usual: 
+
+<blockquote><pre>
+// this must be called before any use of automatic operator  
+// wrapping or a call to some_class.def_standard_coerce()
+some_class.def(&amp;custom_coerce, "__coerce__");
+</pre></blockquote>
+
+     Note that the standard coercion (defined by use of automatic 
+     operator wrapping on a <code>class_builder</code> or a call to
+     <code>class_builder::def_standard_coerce()</code>) will never be applied if
+     a custom coercion function has been registered. Therefore, in 
+     your coercion function you should call 
+
+<blockquote><pre>
+boost::python::standard_coerce(left, right);
+</pre></blockquote>
+
+     for all cases that you don't want to handle yourself.
+
+<h3><a name="ternary_pow">The Ternary <code>pow()</code> Operator</a></h3>
+
+    <p>
+      In addition to the usual binary <code>pow(x, y)</code> operator (meaning
+      <i>x<sup>y</sup></i>), Python also provides a ternary variant that implements
+      <i>x<sup>y</sup> <b>mod</b> z</i>, presumably using a more efficient algorithm than
+      concatenation of power and modulo operators. Automatic operator wrapping
+      can only be used with the binary variant. Ternary <code>pow()</code> must
+      always be wrapped manually. For a homgeneous ternary <code>pow()</code>,
+      this is done as usual: 
+
+<blockquote><pre>
+BigNum power(BigNum const&amp; first, BigNum const&amp; second, BigNum const&amp; modulus);
+typedef BigNum (ternary_function1)(const BigNum&amp;, const BigNum&amp;, const BigNum&amp;);
+...
+bignum_class.def((ternary_function1)&amp;power,  "__pow__");
+</pre></blockquote>
+
+      If you want to support this function with non-uniform argument
+      types, wrapping is a little more involved. Suppose you have to wrap: 
+
+<blockquote><pre>
+BigNum power(BigNum const&amp; first, int second, int modulus);
+BigNum power(int first, BigNum const&amp; second, int modulus);
+BigNum power(int first, int second, BigNum const&amp; modulus);
+</pre></blockquote>
+
+      The first variant can be wrapped as usual: 
+
+<blockquote><pre>
+typedef BigNum (ternary_function2)(const BigNum&amp;, int, int);
+bignum_class.def((ternary_function2)&amp;power,  "__pow__");
+</pre></blockquote>
+
+      In the second variant, however, <code>BigNum</code> appears only as second
+      argument, and in the last one it's the third argument. These functions
+      must be presented to Boost.Python such that that the <code>BigNum</code>
+      argument appears in first position:
+
+<blockquote><pre>
+BigNum rpower(BigNum const&amp; second, int first, int modulus)
+{
+    return power(first, second, modulus);
+}
+
+BigNum rrpower(BigNum const&amp; modulus, int first, int second)
+{
+    return power(first, second, modulus);
+}
+</pre></blockquote>
+
+<p>These functions must be wrapped under the names "__rpow__" and "__rrpow__"
+ respectively:
+
+<blockquote><pre>
+bignum_class.def((ternary_function2)&amp;rpower,  "__rpow__");
+bignum_class.def((ternary_function2)&amp;rrpower,  "__rrpow__");
+</pre></blockquote>
+
+Note that "__rrpow__" is an extension not present in plain Python. 
+
+<h2><a name="numeric_table">Table of Automatically Wrapped Methods</a></h2>
+      <p>
+         Boost.Python can automatically wrap the following <a href=
+         "http://www.python.org/doc/current/ref/specialnames.html">
+         special methods</a>:
+
+      <p>
+      <table summary="special numeric methods" cellpadding="5" border="1"
+      width="100%">
+        <tr>
+          <td align="center">
+            <b>Python Operator Name</b>
+          <td align="center">
+            <b>Python Expression</b>
+          <td align="center">
+            <b>C++ Operator Id</b>
+          <td align="center">
+            <b>C++ Expression Used For Automatic Wrapping</b><br>
+             with <code>cpp_left = from_python(left,
+            type&lt;Left&gt;())</code>,<br>
+             <code>cpp_right = from_python(right,
+            type&lt;Right&gt;())</code>,<br>
+             and <code>cpp_oper = from_python(oper, type&lt;Oper&gt;())</code>
+        <tr>
+          <td>
+            <code>__add__, __radd__</code>
+          <td>
+            <code>left + right</code>
+          <td>
+            <code>op_add</code>
+          <td>
+            <code>cpp_left + cpp_right</code>
+        <tr>
+          <td>
+            <code>__sub__, __rsub__</code>
+          <td>
+            <code>left - right</code>
+          <td>
+            <code>op_sub</code>
+          <td>
+            <code>cpp_left - cpp_right</code>
+        <tr>
+          <td>
+            <code>__mul__, __rmul__</code>
+          <td>
+            <code>left * right</code>
+          <td>
+            <code>op_mul</code>
+          <td>
+            <code>cpp_left * cpp_right</code>
+        <tr>
+          <td>
+            <code>__div__, __rdiv__</code>
+          <td>
+            <code>left / right</code>
+          <td>
+            <code>op_div</code>
+          <td>
+            <code>cpp_left / cpp_right</code>
+        <tr>
+          <td>
+            <code>__mod__, __rmod__</code>
+          <td>
+            <code>left % right</code>
+          <td>
+            <code>op_mod</code>
+          <td>
+            <code>cpp_left % cpp_right</code>
+        <tr>
+          <td>
+            <code>__divmod__, __rdivmod__</code>
+          <td>
+            <code>(quotient, remainder)<br>
+            = divmod(left, right)</code>
+          <td>
+            <code>op_divmod</code>
+          <td>
+            <code>cpp_left / cpp_right</code>
+        <br><code>cpp_left % cpp_right</code>
+        <tr>
+          <td>
+            <code>__pow__, __rpow__</code>
+          <td>
+            <code>pow(left, right)</code><br>
+             (binary power)
+          <td>
+            <code>op_pow</code>
+          <td>
+            <code>pow(cpp_left, cpp_right)</code>
+        <tr>
+          <td>
+            <code>__rrpow__</code>
+          <td>
+            <code>pow(left, right, modulo)</code><br>
+             (ternary power modulo)
+          <td colspan="2">
+            no automatic wrapping, <a href="#ternary_pow">special treatment</a>
+            required
+        <tr>
+          <td>
+            <code>__lshift__, __rlshift__</code>
+          <td>
+            <code>left &lt;&lt; right</code>
+          <td>
+            <code>op_lshift</code>
+          <td>
+            <code>cpp_left &lt;&lt; cpp_right</code>
+        <tr>
+          <td>
+            <code>__rshift__, __rrshift__</code>
+          <td>
+            <code>left &gt;&gt; right</code>
+          <td>
+            <code>op_rshift</code>
+          <td>
+            <code>cpp_left &gt;&gt; cpp_right</code>
+        <tr>
+          <td>
+            <code>__and__, __rand__</code>
+          <td>
+            <code>left &amp; right</code>
+          <td>
+            <code>op_and</code>
+          <td>
+            <code>cpp_left &amp; cpp_right</code>
+        <tr>
+          <td>
+            <code>__xor__, __rxor__</code>
+          <td>
+            <code>left ^ right</code>
+          <td>
+            <code>op_xor</code>
+          <td>
+            <code>cpp_left ^ cpp_right</code>
+        <tr>
+          <td>
+            <code>__or__, __ror__</code>
+          <td>
+            <code>left | right</code>
+          <td>
+            <code>op_or</code>
+          <td>
+            <code>cpp_left | cpp_right</code>
+
+        <tr>
+          <td>
+            <code>__cmp__, __rcmp__</code>
+          <td>
+            <code>cmp(left, right)</code><br>
+            <br>See <a href="richcmp.html">Rich Comparisons</a>.
+          <td>
+            <code>op_cmp</code>
+          <td>
+            <code>cpp_left &lt; cpp_right </code>
+        <br><code>cpp_right &lt; cpp_left</code>
+        <tr>
+          <td>
+                <code>__lt__</code>
+            <br><code>__le__</code>
+            <br><code>__eq__</code>
+            <br><code>__ne__</code>
+            <br><code>__gt__</code>
+            <br><code>__ge__</code>
+          <td>
+                <code>left &lt; right</code>
+            <br><code>left &lt;= right</code>
+            <br><code>left == right</code>
+            <br><code>left != right</code>
+            <br><code>left &gt; right</code>
+            <br><code>left &gt;= right</code>
+            <br>See <a href="richcmp.html">Rich Comparisons</a>
+          <td>
+                <code>op_lt</code>
+            <br><code>op_le</code>
+            <br><code>op_eq</code>
+            <br><code>op_ne</code>
+            <br><code>op_gt</code>
+            <br><code>op_ge</code>
+          <td>
+                <code>cpp_left &lt; cpp_right </code>
+            <br><code>cpp_left &lt;= cpp_right </code>
+            <br><code>cpp_left == cpp_right </code>
+            <br><code>cpp_left != cpp_right </code>
+            <br><code>cpp_left &gt; cpp_right </code>
+            <br><code>cpp_left &gt;= cpp_right </code>
+
+        <tr>
+          <td>
+            <code>__neg__</code>
+          <td>
+            <code>-oper </code> (unary negation)
+          <td>
+            <code>op_neg</code>
+          <td>
+            <code>-cpp_oper</code>
+        <tr>
+          <td>
+            <code>__pos__</code>
+          <td>
+            <code>+oper </code> (identity)
+          <td>
+            <code>op_pos</code>
+          <td>
+            <code>+cpp_oper</code>
+        <tr>
+          <td>
+            <code>__abs__</code>
+          <td>
+            <code>abs(oper) </code> (absolute value)
+          <td>
+            <code>op_abs</code>
+          <td>
+            <code>abs(cpp_oper)</code>
+        <tr>
+          <td>
+            <code>__invert__</code>
+          <td>
+            <code>~oper </code> (bitwise inversion)
+          <td>
+            <code>op_invert</code>
+          <td>
+            <code>~cpp_oper</code>
+        <tr>
+          <td>
+            <code>__int__</code>
+          <td>
+            <code>int(oper) </code> (integer conversion)
+          <td>
+            <code>op_int</code>
+          <td>
+            <code>long(cpp_oper)</code>
+        <tr>
+          <td>
+            <code>__long__</code>
+          <td>
+            <code>long(oper) </code><br>
+             (infinite precision integer conversion)
+          <td>
+            <code>op_long</code>
+          <td>
+            <code>PyLong_FromLong(cpp_oper)</code>
+        <tr>
+          <td>
+            <code>__float__</code>
+          <td>
+            <code>float(oper) </code> (float conversion)
+          <td>
+            <code>op_float</code>
+          <td>
+            <code>double(cpp_oper)</code>
+        <tr>
+          <td>
+            <code>__str__</code>
+          <td>
+            <code>str(oper) </code> (string conversion)
+          <td>
+            <code>op_str</code>
+          <td>
+            <code>std::ostringstream s; s &lt;&lt; oper;</code>
+        <tr>
+          <td>
+            <code>__coerce__</code>
+          <td>
+            <code>coerce(left, right)</code>
+          <td colspan="2">
+            usually defined automatically, otherwise <a href="#coercion">
+            special treatment</a> required
+      </table>
+
+<h2><a name="sequence_and_mapping">Sequence and Mapping Operators</a></h2>
+
+<p>
+      Sequence and mapping operators let wrapped objects behave in accordance
+      to Python's iteration and access protocols. These protocols differ
+      considerably from the ones found in C++. For example, Python's typical
+      iteration idiom looks like
+
+<blockquote><pre>
+for i in S:
+</pre></blockquote>
+
+      while in C++ one writes
+
+<blockquote><pre>
+for (iterator i = S.begin(), end = S.end(); i != end; ++i)
+</pre></blockquote>
+
+<p>One could try to wrap C++ iterators in order to carry the C++ idiom into
+      Python. However, this does not work very well because 
+
+<ol>
+<li>It leads to
+      non-uniform Python code (wrapped sequences support a usage different from 
+      Python built-in sequences) and 
+
+<li>Iterators (e.g. <code>std::vector::iterator</code>) are often implemented as plain C++
+      pointers which are <a href="pointers.html#problem">problematic</a> for any automatic
+      wrapping system.
+</ol>
+
+      <p>
+        It is a better idea to support the standard <a
+        href="http://www.python.org/doc/current/ref/sequence-types.html">Python
+        sequence and mapping protocols</a> for your wrapped containers. These
+        operators have to be wrapped manually because there are no corresponding
+        C++ operators that could be used for automatic wrapping. The Python
+        documentation lists the relevant <a href=
+        "http://www.python.org/doc/current/ref/sequence-types.html">
+        container operators</a>. In particular, expose __getitem__, __setitem__
+        and remember to raise the appropriate Python exceptions
+        (<code>PyExc_IndexError</code> for sequences,
+        <code>PyExc_KeyError</code> for mappings) when the requested item is not
+        present.
+
+      <p>
+        In the following example, we expose <code>std::map&lt;std::size_t,std::string&gt;</code>:
+      <blockquote>
+<pre>
+typedef std::map&lt;std::size_t, std::string&gt; StringMap;
+
+// A helper function for dealing with errors. Throw a Python exception
+// if p == m.end().
+void throw_key_error_if_end(
+        const StringMap&amp; m, 
+        StringMap::const_iterator p, 
+        std::size_t key)
+{
+    if (p == m.end())
+    {
+        PyErr_SetObject(PyExc_KeyError, boost::python::converters::to_python(key));
+        boost::python::throw_error_already_set();
+    }
+}
+
+// Define some simple wrapper functions which match the Python  protocol
+// for __getitem__, __setitem__, and __delitem__.  Just as in Python, a
+// free function with a ``self'' first parameter makes a fine class method.
+
+const std::string&amp; get_item(const StringMap&amp; self, std::size_t key)
+{
+    const StringMap::const_iterator p = self.find(key);
+    throw_key_error_if_end(self, p, key);
+    return p-&gt;second;
+}
+
+// Sets the item corresponding to key in the map.
+void StringMapPythonClass::set_item(StringMap&amp; self, std::size_t key, const std::string&amp; value)
+{
+    self[key] = value;
+}
+
+// Deletes the item corresponding to key from the map.
+void StringMapPythonClass::del_item(StringMap&amp; self, std::size_t key)
+{
+    const StringMap::iterator p = self.find(key);
+    throw_key_error_if_end(self, p, key);
+    self.erase(p);
+}
+
+class_builder&lt;StringMap&gt; string_map(my_module, "StringMap");
+string_map.def(boost::python::constructor&lt;&gt;());
+string_map.def(&amp;StringMap::size, "__len__");
+string_map.def(get_item, "__getitem__");
+string_map.def(set_item, "__setitem__");
+string_map.def(del_item, "__delitem__");
+</pre>
+      </blockquote>
+      <p>
+         Then in Python:
+      <blockquote>
+<pre>
+&gt;&gt;&gt; m = StringMap()
+&gt;&gt;&gt; m[1]
+Traceback (innermost last):
+  File "&lt;stdin&gt;", line 1, in ?
+KeyError: 1
+&gt;&gt;&gt; m[1] = 'hello'
+&gt;&gt;&gt; m[1]
+'hello'
+&gt;&gt;&gt; del m[1]
+&gt;&gt;&gt; m[1]            # prove that it's gone
+Traceback (innermost last):
+  File "&lt;stdin&gt;", line 1, in ?
+KeyError: 1
+&gt;&gt;&gt; del m[2]
+Traceback (innermost last):
+  File "&lt;stdin&gt;", line 1, in ?
+KeyError: 2
+&gt;&gt;&gt; len(m)
+0
+&gt;&gt;&gt; m[0] = 'zero'
+&gt;&gt;&gt; m[1] = 'one'
+&gt;&gt;&gt; m[2] = 'two'
+&gt;&gt;&gt; m[3] = 'three'
+&gt;&gt;&gt; len(m)
+4
+</pre>
+      </blockquote>
+
+<h2><a name="getter_setter">Customized Attribute Access</a></h2>
+
+      <p>
+        Just like built-in Python classes, Boost.Python extension classes support <a
+        href="http://www.python.org/doc/current/ref/attribute-access.html">special
+        the usual attribute access methods</a> <code>__getattr__</code>,
+        <code>__setattr__</code>, and <code>__delattr__</code>.
+        Because writing these functions can
+        be tedious in the common case where the attributes being accessed are
+        known statically, Boost.Python checks the special names
+
+      <ul>
+        <li>
+          <code>__getattr__<em>&lt;name&gt;</em>__</code>
+        <li>
+          <code>__setattr__<em>&lt;name&gt;</em>__</code>
+        <li>
+          <code>__delattr__<em>&lt;name&gt;</em>__</code>
+      </ul>
+
+      to provide functional access to the attribute <em>&lt;name&gt;</em>. This
+      facility can be used from C++ or entirely from Python. For example, the
+      following shows how we can implement a ``computed attribute'' in Python: 
+      <blockquote>
+<pre>
+&gt;&gt;&gt; class Range(AnyBoost.PythonExtensionClass):
+...    def __init__(self, start, end):
+...        self.start = start
+...        self.end = end
+...    def __getattr__length__(self):
+...        return self.end - self.start
+...
+&gt;&gt;&gt; x = Range(3, 9)
+&gt;&gt;&gt; x.length
+6
+</pre>
+      </blockquote>
+      <h4>
+         Direct Access to Data Members
+      </h4>
+      <p>
+         Boost.Python uses the special <code>
+        __xxxattr__<em>&lt;name&gt;</em>__</code> functionality described above
+        to allow direct access to data members through the following special
+        functions on <code>class_builder&lt;&gt;</code> and <code>
+        extension_class&lt;&gt;</code>:
+      <ul>
+        <li>
+          <code>def_getter(<em>pointer-to-member</em>, <em>name</em>)</code> //
+          read access to the member via attribute <em>name</em>
+        <li>
+          <code>def_setter(<em>pointer-to-member</em>, <em>name</em>)</code> //
+          write access to the member via attribute <em>name</em>
+        <li>
+          <code>def_readonly(<em>pointer-to-member</em>, <em>name</em>)</code>
+          // read-only access to the member via attribute <em>name</em>
+        <li>
+          <code>def_read_write(<em>pointer-to-member</em>, <em>
+          name</em>)</code> // read/write access to the member via attribute
+          <em>name</em>
+      </ul>
+      <p>
+         Note that the first two functions, used alone, may produce surprising
+        behavior. For example, when <code>def_getter()</code> is used, the
+        default functionality for <code>setattr()</code> and <code>
+        delattr()</code> remains in effect, operating on items in the extension
+        instance's name-space (i.e., its <code>__dict__</code>). For that
+        reason, you'll usually want to stick with <code>def_readonly</code> and
+        <code>def_read_write</code>.
+      <p>
+         For example, to expose a <code>std::pair&lt;int,long&gt;</code> we
+        might write:
+      <blockquote>
+<pre>
+typedef std::pair&lt;int,long&gt; Pil;
+int first(const Pil&amp; x) { return x.first; }
+long second(const Pil&amp; x) { return x.second; }
+   ...
+my_module.def(first, "first");
+my_module.def(second, "second");
+
+class_builder&lt;Pil&gt; pair_int_long(my_module, "Pair");
+pair_int_long.def(boost::python::constructor&lt;&gt;());
+pair_int_long.def(boost::python::constructor&lt;int,long&gt;());
+pair_int_long.def_read_write(&amp;Pil::first, "first");
+pair_int_long.def_read_write(&amp;Pil::second, "second");
+</pre>
+      </blockquote>
+      <p>
+         Now your Python class has attributes <code>first</code> and <code>
+        second</code> which, when accessed, actually modify or reflect the
+        values of corresponding data members of the underlying C++ object. Now
+        in Python:
+      <blockquote>
+<pre>
+&gt;&gt;&gt; x = Pair(3,5)
+&gt;&gt;&gt; x.first
+3
+&gt;&gt;&gt; x.second
+5
+&gt;&gt;&gt; x.second = 8
+&gt;&gt;&gt; x.second
+8
+&gt;&gt;&gt; second(x) # Prove that we're not just changing the instance __dict__
+8
+</pre>
+      </blockquote>
+      <h2>
+        <a name="reasons">And what about <code>__complex__</code>?</a>
+      </h2>
+      <p>
+        That, dear reader, is one problem we don't know how to solve. The
+        Python source contains the following fragment, indicating the
+        special-case code really is hardwired:
+      <blockquote>
+<pre>
+/* XXX Hack to support classes with __complex__ method */
+if (PyInstance_Check(r)) { ...
+</pre>
+      </blockquote>
+      <p>
+Next: <a href="under-the-hood.html">A Peek Under the Hood</a>
+Previous: <a href="inheritance.html">Inheritance</a> 
+Up: <a href= "index.html">Top</a>
+      <p>
+         &copy; Copyright David Abrahams and Ullrich K&ouml;the 2000.
+        Permission to copy, use, modify, sell and distribute this document is
+        granted provided this copyright notice appears in all copies. This
+        document is provided ``as is'' without express or implied
+        warranty, and with no claim as to its suitability for any purpose.
+      <p>
+         Updated: Nov 26, 2000
+    </div>
+

doc/tutorial/doc/basic_interface.html

@@ -1,77 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Basic Interface</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="object_interface.html">
-<link rel="next" href="derived_object_types.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Basic Interface</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="object_interface.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="derived_object_types.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<p>
-Class <tt>object</tt> wraps <tt>PyObject*</tt>. All the intricacies of dealing with
-<tt>PyObject</tt>s such as managing reference counting are handled by the
-<tt>object</tt> class. C++ object interoperability is seamless. Boost.Python C++
-<tt>object</tt>s can in fact be explicitly constructed from any C++ object.</p>
-<p>
-To illustrate, this Python code snippet:</p>
-<code><pre>
-    <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=literal>'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=literal>'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>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></code>
-<p>
-Can be rewritten in C++ using Boost.Python facilities this way:</p>
-<code><pre>
-    <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>&quot;foo&quot;</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>&quot;bar&quot;</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>&quot;items&quot;</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></code>
-<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>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="object_interface.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="derived_object_types.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/building_an_extension_module.html

@@ -1,186 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Building an Extension Module </title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="class_data_members.html">
-<link rel="next" href="inheritance.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%"> <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><strong>Building 
-      an Extension Module</strong></font> </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><img src="theme/l_arr.gif" border="0"></td>
-    <td width="20"><img src="theme/r_arr.gif" border="0"></td>
-   </tr>
-</table>
-<h2>Building Boost.Python</h2>
-<p>Every Boost.Python extension module must be linked with the boost_python shared 
-  library. To build boost_python, use <a href="file:///C:/dev/boost/tools/build/index.html">Boost.Build</a> 
-  in the usual way from the <tt>libs/python/build</tt> subdirectory of your boost 
-  installation (if you have already built boost from the top level this may have 
-  no effect, since the work is already done).</p>
-<h2>Configuration</h2>
-<p>You may need to configure the following variables to point Boost.Build at your 
-  Python installation:</p>
-<table width="95%" border="0" align="center">
-  <tr class="table_title"> 
-    <td width="24%">Variable Name</td>
-    <td width="20%">Semantics</td>
-    <td width="21%">Default</td>
-    <td width="35%">Notes</td>
-  </tr>
-  <tr class="table_cells"> 
-    <td><tt>PYTHON_ROOT</tt></td>
-    <td> The root directory of your Python installation</td>
-    <td>Windows: <tt><br>
-      c:/tools/python <br>
-      Unix: /usr/local</tt></td>
-    <td>On Unix, this is the <tt>--with-prefix=</tt> directory used to configure 
-      Python</td>
-  </tr>
-  <tr class="table_cells"> 
-    <td><tt>PYTHON_VERSION</tt></td>
-    <td> The The 2-part python Major.Minor version number</td>
-    <td>Windows: 2.1 Unix: 1.5</td>
-    <td>Be sure not to include a third number, e.g. not &quot;2.2.1&quot;, even 
-      if that's the version you have.</td>
-  </tr>
-  <tr class="table_cells"> 
-    <td><tt>PYTHON_INCLUDES</tt></td>
-    <td> path to Python <span class="preprocessor">#include</span> directories</td>
-    <td>Autoconfigured from <tt><br>
-      PYTHON_ROOT</tt></td>
-    <td>&nbsp;</td>
-  </tr>
-  <tr class="table_cells"> 
-    <td><tt>PYTHON_LIB_PATH</tt></td>
-    <td>path to Python library object.</td>
-    <td>Autoconfigured from <tt><br>
-      PYTHON_ROOT</tt></td>
-    <td>&nbsp;</td>
-  </tr>
-  <tr class="table_cells"> 
-    <td><tt>PYTHON_STDLIB_PATH</tt></td>
-    <td>path to Python standard library modules</td>
-    <td>Autoconfigured from <tt><br>
-      PYTHON_ROOT</tt></td>
-    <td>&nbsp;</td>
-  </tr>
-  <tr class="table_cells"> 
-    <td height="129"><tt>CYGWIN_ROOT</tt></td>
-    <td> path to the user's Cygwin installation</td>
-    <td>Autoconfigured from <tt><br>
-      PYTHON_ROOT</tt></td>
-    <td><a href="http://www.cygwin.com">Cygwin</a> only. This and the following 
-      two settings are useful when building with multiple toolsets on Windows, 
-      since Cygwin requires a different build of Python.</td>
-  </tr>
-  <tr class="table_cells"> 
-    <td height="21"><tt>GCC_PYTHON_ROOT</tt></td>
-    <td>path to the user's Cygwin Python installation</td>
-    <td><tt>$(CYGWIN_ROOT)<br>
-      /usr/local</tt></td>
-    <td> <a href="http://www.cygwin.com">Cygwin</a> only</td>
-  </tr>
-  <tr class="table_cells"> 
-    <td><tt>GCC_DEBUG_PYTHON_ROOT</tt></td>
-    <td> path to the user's Cygwin <a href="#variants">pydebug</a> 
-      build</td>
-    <td><tt>$(CYGWIN_ROOT)<br>
-      /usr/local/pydebug</tt></td>
-    <td> <a href="http://www.cygwin.com">Cygwin</a> only</td>
-  </tr>
-</table>
-<h2>Results</h2>
-<p>The build process will create a <tt>libs/python/build/bin-stage</tt> subdirectory 
-  of the boost root (or of <tt>$(ALL_LOCATE_TARGET)</tt>, if you have set that 
-  variable), containing the built libraries. The libraries are actually built 
-  to unique directories for each toolset and variant elsewhere in the filesystem, 
-  and copied to the bin-stage directory as a convenience, so if you build with 
-  multiple toolsets at once, the product of later toolsets will overwrite that 
-  of earlier toolsets in bin-stage.</p>
-<h2>Testing</h2>
-<p>To build and test Boost.Python from within the <tt>libs/python/build directory</tt>, 
-  invoke</p>
-<pre>    bjam -sTOOLS=<a href="../../../tools/build/index.html">toolset</a> test</pre>
-<p>This will update all of the Boost.Python v1 test and example targets. The tests 
-  are relatively quiet by default. To get more-verbose output, you might try</p>
-<pre>    bjam -sTOOLS=<a href="../../../tools/build/index.html">toolset</a> -sPYTHON_TEST_ARGS=-v test</pre>
-<p>which will print each test's Python code with the expected output as it passes.</p>
-<h2>Building your Extension Module</h2>
-<p>Though there are other approaches, the easiest way to build an extension module 
-  using Boost.Python is with Boost.Build. Until Boost.Build v2 is released, cross-project 
-  build dependencies are not supported, so it works most smoothly if you add a 
-  new subproject to your boost installation. The <tt>libs/python/example</tt> 
-  subdirectory of your boost installation contains a minimal example (along with 
-  many extra sources). To copy the example subproject:</p>
-<ol>
-  <li> Create a new subdirectory in,<tt> libs/python</tt>, say <tt>libs/python/my_project</tt>.</li>
-  <li> Copy <a href="../example/Jamfile"><tt>libs/python/example/Jamfile</tt></a> 
-    to your new directory.</li>
-  <li> Edit the Jamfile as appropriate for your project. You'll want to change 
-    the <tt>subproject</tt> rule invocation at the top, and the names of some 
-    of the source files and/or targets.</li>
-</ol>
-<p>If you can't modify or copy your boost installation, the alternative is to 
-  create your own Boost.Build project. A similar example you can use as a starting 
-  point is available in <a href="../example/project.zip">this archive</a>. You'll 
-  need to edit the Jamfile and Jamrules files, depending on the relative location 
-  of your Boost installation and the new project. Note that automatic testing 
-  of extension modules is not available in this configuration.</p>
-<h2>Build Variants</h2>
-<p>Three variant configurations of all python-related targets are supported, and 
-  can be selected by setting the BUILD variable:</p>
-<p> * <tt>release</tt> (optimization, <tt>-DNDEBUG</tt>)<br>
-  * <tt>debug</tt> (no optimization <tt>-D_DEBUG</tt>)<br>
-  * <tt>debug-python</tt> (no optimization, <tt>-D_DEBUG -DBOOST_DEBUG_PYTHON</tt>)</p>
-<p>The first two variants of the boost_python library are built by default, and 
-  are compatible with the default Python distribution. The debug-python variant 
-  corresponds to a specially-built debugging version of Python. On Unix platforms, 
-  this python is built by adding <tt>--with-pydebug</tt> when configuring the 
-  Python build. On Windows, the debugging version of Python is generated by the 
-  &quot;Win32 Debug&quot; target of the PCBuild.dsw Visual C++ 6.0 project in 
-  the PCBuild subdirectory of your Python distribution. Extension modules built 
-  with Python debugging enabled are not link-compatible with a non-debug build 
-  of Python. Since few people actually have a debug build of Python (it doesn't 
-  come with the standard distribution), the normal debug variant builds modules 
-  which are compatible with ordinary Python.</p>
-<p>On many windows compilers, when extension modules are built with <tt>-D_DEBUG</tt>, 
-  Python defaults to force linking with a special debugging version of the Python 
-  DLL. Since this debug DLL isn't supplied with the default Python installation 
-  for Windows, Boost.Python uses <a href="../../../boost/python/detail/wrap_python.hpp"><tt>boost/python/detail/wrap_python.hpp</tt></a> 
-  to temporarily undefine <tt>_DEBUG</tt> when <tt>Python.h</tt> is <span class="preprocessor">#included</span> 
-  - unless <tt>BOOST_DEBUG_PYTHON</tt> is defined.</p>
-<p>If you want the extra runtime checks available with the debugging version of 
-  the library, <span class="preprocessor">#define</span> <tt>BOOST_DEBUG_PYTHON</tt> 
-  to re-enable python debuggin, and link with the debug-python variant of boost_python.</p>
-<p>If you do not <span class="preprocessor">#define</span> <tt>BOOST_DEBUG_PYTHON</tt>, 
-  be sure that any source files in your extension module <span class="preprocessor">#include</span> 
-  <tt>&lt;boost/python/detail/wrap_python.hpp&gt;</tt> instead of the usual <tt>Python.h</tt>, 
-  or you will have link incompatibilities.</p>
-<code></code> 
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><img src="theme/l_arr.gif" border="0"></td>
-    <td width="20"><img src="theme/r_arr.gif" border="0"></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/building_hello_world.html

@@ -1,191 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Building Hello World</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="quickstart.html">
-<link rel="next" href="exposing_classes.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Building Hello World</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="quickstart.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="exposing_classes.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<a name="from_start_to_finish"></a><h2>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: <b>bjam</b>.</p>
-<table width="80%" border="0" align="center">
-  <tr>
-    <td class="note_box">
-<img src="theme/lens.gif"></img> <b>Building without bjam</b><br><br>
-
-Besides bjam, there are of course other ways to get your module built.
-What's written here should not be taken as &quot;the one and only way&quot;.
-There are of course other build tools apart from <tt>bjam</tt>.
-    </td>
-  </tr>
-</table>
-<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">
-building.html</a>.
-After this brief <i>bjam</i> tutorial, we should have built two DLLs:</p>
-<ul><li>boost_python.dll</li><li>hello.pyd</li></ul><p>
-if you are on Windows, and</p>
-<ul><li>libboost_python.so</li><li>hello.so</li></ul><p>
-if you are on Unix.</p>
-<p>
-The tutorial example can be found in the directory:
-<tt>libs/python/example/tutorial</tt>. There, you can find:</p>
-<ul><li>hello.cpp</li><li>Jamfile</li></ul><p>
-The <tt>hello.cpp</tt> file is our C++ hello world example. The <tt>Jamfile</tt> is a
-minimalist <i>bjam</i> 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>bjam</tt> can be executed in
-the command line. Pre-built Boost.Jam executables are available for most
-platforms. For example, a pre-built Microsoft Windows bjam executable can
-be downloaded <a href="http://boost.sourceforge.net/jam-executables/bin.ntx86/bjam.zip">
-here</a>.
-The complete list of bjam pre-built
-executables can be found <a href="../../../../../tools/build/index.html#Jam">
-here</a>.</p>
-<a name="lets_jam_"></a><h2>Lets Jam!</h2><p>
-<img src="theme/jam.png"></img></p>
-<p>
-Here is our minimalist Jamfile:</p>
-<code><pre>
-    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
-        ;
-</pre></code><p>
-First, we need to specify our location in the boost project hierarchy.
-It so happens that the tutorial example is located in <tt>/libs/python/example/tutorial</tt>.
-Thus:</p>
-<code><pre>
-    subproject libs/python/example/tutorial ;
-</pre></code><p>
-Then we will include the definitions needed by Python modules:</p>
-<code><pre>
-    SEARCH on python.jam = $(BOOST_BUILD_PATH) ;
-    include python.jam ;
-</pre></code><p>
-Finally we declare our <tt>hello</tt> extension:</p>
-<code><pre>
-    extension hello                     # Declare a Python extension called hello
-    :   hello.cpp                       # source
-        &lt;dll&gt;../../build/boost_python   # dependencies
-        ;
-</pre></code><a name="running_bjam"></a><h2>Running bjam</h2><p>
-<i>bjam</i> is run using your operating system's command line interpreter.</p>
-<blockquote><p>Start it up.</p></blockquote><p>
-Make sure that the environment is set so that we can invoke the C++
-compiler. With MSVC, that would mean running the <tt>Vcvars32.bat</tt> batch
-file. For instance:</p>
-<code><pre>
-    <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></pre></code>
-<p>
-Some environment variables will have to be setup for proper building of our
-Python modules. Example:</p>
-<code><pre>
-    <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></pre></code>
-<p>
-The above assumes that the Python installation is in <tt>c:/dev/tools/python</tt>
-and that we are using Python version 2.2. You'll have to tweak this path
-appropriately. <img src="theme/note.gif"></img> Be sure not to include a third number, e.g. <b>not</b>  &quot;2.2.1&quot;,
-even if that's the version you have.</p>
-<p>
-Now we are ready... Be sure to <tt>cd</tt> to <tt>libs/python/example/tutorial</tt>
-where the tutorial <tt>&quot;hello.cpp&quot;</tt> and the <tt>&quot;Jamfile&quot;</tt> is situated.</p>
-<p>
-Finally:</p>
-<code><pre>
-    <span class=identifier>bjam </span><span class=special>-</span><span class=identifier>sTOOLS</span><span class=special>=</span><span class=identifier>msvc
-</span></pre></code>
-<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">
-Building Boost Libraries</a> for
-further details.</p>
-<p>
-It should be building now:</p>
-<code><pre>
-    cd C:\dev\boost\libs\python\example\tutorial
-    bjam -sTOOLS=msvc
-    ...patience...
-    ...found 1703 targets...
-    ...updating 40 targets...
-</pre></code><p>
-And so on... Finally:</p>
-<code><pre>
-    vc-C++ ..\..\..\..\libs\python\example\tutorial\bin\hello.pyd\msvc\debug\
-    runtime-link-dynamic\hello.obj
-    hello.cpp
-    vc-Link ..\..\..\..\libs\python\example\tutorial\bin\hello.pyd\msvc\debug\
-    runtime-link-dynamic\hello.pyd ..\..\..\..\libs\python\example\tutorial\bin\
-    hello.pyd\msvc\debug\runtime-link-dynamic\hello.lib
-       Creating library ..\..\..\..\libs\python\example\tutorial\bin\hello.pyd\
-       msvc\debug\runtime-link-dynamic\hello.lib and object ..\..\..\..\libs\python\
-       example\tutorial\bin\hello.pyd\msvc\debug\runtime-link-dynamic\hello.exp
-    ...updated 40 targets...
-</pre></code><p>
-If all is well, you should now have:</p>
-<ul><li>boost_python.dll</li><li>hello.pyd</li></ul><p>
-if you are on Windows, and</p>
-<ul><li>libboost_python.so</li><li>hello.so</li></ul><p>
-if you are on Unix.</p>
-<p>
-<tt>boost_python.dll</tt> can be found somewhere in <tt>libs\python\build\bin</tt>
-while <tt>hello.pyd</tt> can be found somewhere in
-<tt>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>
-<code><pre>
-    <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></pre></code>
-<blockquote><p><b>There you go... Have fun!</b></p></blockquote><table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="quickstart.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="exposing_classes.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/call_policies.html

@@ -1,169 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Call Policies</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="functions.html">
-<link rel="next" href="default_arguments.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Call Policies</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="functions.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="default_arguments.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<p>
-In C++, we often deal with arguments and return types such as pointers
-and references. Such primitive types are rather, ummmm, low level and
-they really don't tell us much. At the very least, we don't know the
-owner of the pointer or the referenced object. No wonder languages
-such as Java and Python never deal with such low level entities. In
-C++, it's usually considered a good practice to use smart pointers
-which exactly describe ownership semantics. Still, even good C++
-interfaces use raw references and pointers sometimes, so Boost.Python
-must deal with them. To do this, it may need your help. Consider the
-following C++ function:</p>
-<code><pre>
-    <span class=identifier>X</span><span class=special>&amp; </span><span class=identifier>f</span><span class=special>(</span><span class=identifier>Y</span><span class=special>&amp; </span><span class=identifier>y</span><span class=special>, </span><span class=identifier>Z</span><span class=special>* </span><span class=identifier>z</span><span class=special>);
-</span></pre></code>
-<p>
-How should the library wrap this function? A naive approach builds a
-Python X object around result reference. This strategy might or might
-not work out. Here's an example where it didn't</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>x </span><span class=special>= </span><span class=identifier>f</span><span class=special>(</span><span class=identifier>y</span><span class=special>, </span><span class=identifier>z</span><span class=special>) </span>#<span class=identifier>x </span><span class=identifier>refers </span><span class=identifier>to </span><span class=identifier>some </span><span class=identifier>C</span><span class=special>++ </span><span class=identifier>X
-    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>del </span><span class=identifier>y
-    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>some_method</span><span class=special>() </span>#<span class=identifier>CRASH</span><span class=special>!
-</span></pre></code>
-<p>
-What's the problem?</p>
-<p>
-Well, what if f() was implemented as shown below:</p>
-<code><pre>
-    <span class=identifier>X</span><span class=special>&amp; </span><span class=identifier>f</span><span class=special>(</span><span class=identifier>Y</span><span class=special>&amp; </span><span class=identifier>y</span><span class=special>, </span><span class=identifier>Z</span><span class=special>* </span><span class=identifier>z</span><span class=special>)
-    </span><span class=special>{
-        </span><span class=identifier>y</span><span class=special>.</span><span class=identifier>z </span><span class=special>= </span><span class=identifier>z</span><span class=special>;
-        </span><span class=keyword>return </span><span class=identifier>y</span><span class=special>.</span><span class=identifier>x</span><span class=special>;
-    </span><span class=special>}
-</span></pre></code>
-<p>
-The problem is that the lifetime of result X&amp; is tied to the lifetime
-of y, because the f() returns a reference to a member of the y
-object. This idiom is is not uncommon and perfectly acceptable in the
-context of C++. However, Python users should not be able to crash the
-system just by using our C++ interface. In this case deleting y will
-invalidate the reference to X. We have a dangling reference.</p>
-<p>
-Here's what's happening:</p>
-<ol><li><tt>f</tt> is called passing in a reference to <tt>y</tt> and a pointer to <tt>z</tt></li><li>A reference to <tt>y.x</tt> is returned</li><li><tt>y</tt> is deleted. <tt>x</tt> is a dangling reference</li><li><tt>x.some_method()</tt> is called</li><li><b>BOOM!</b></li></ol><p>
-We could copy result into a new object:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>f</span><span class=special>(</span><span class=identifier>y</span><span class=special>, </span><span class=identifier>z</span><span class=special>).</span><span class=identifier>set</span><span class=special>(</span><span class=number>42</span><span class=special>) </span>#<span class=identifier>Result </span><span class=identifier>disappears
-    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>y</span><span class=special>.</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>get</span><span class=special>()       </span>#<span class=identifier>No </span><span class=identifier>crash</span><span class=special>, </span><span class=identifier>but </span><span class=identifier>still </span><span class=identifier>bad
-    </span><span class=number>3.14
-</span></pre></code>
-<p>
-This is not really our intent of our C++ interface. We've broken our
-promise that the Python interface should reflect the C++ interface as
-closely as possible.</p>
-<p>
-Our problems do not end there. Suppose Y is implemented as follows:</p>
-<code><pre>
-    <span class=keyword>struct </span><span class=identifier>Y
-    </span><span class=special>{
-        </span><span class=identifier>X </span><span class=identifier>x</span><span class=special>; </span><span class=identifier>Z</span><span class=special>* </span><span class=identifier>z</span><span class=special>;
-        </span><span class=keyword>int </span><span class=identifier>z_value</span><span class=special>() </span><span class=special>{ </span><span class=keyword>return </span><span class=identifier>z</span><span class=special>-&gt;</span><span class=identifier>value</span><span class=special>(); </span><span class=special>}
-    </span><span class=special>};
-</span></pre></code>
-<p>
-Notice that the data member <tt>z</tt> is held by class Y using a raw
-pointer. Now we have a potential dangling pointer problem inside Y:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>x </span><span class=special>= </span><span class=identifier>f</span><span class=special>(</span><span class=identifier>y</span><span class=special>, </span><span class=identifier>z</span><span class=special>) </span>#<span class=identifier>y </span><span class=identifier>refers </span><span class=identifier>to </span><span class=identifier>z
-    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>del </span><span class=identifier>z       </span>#<span class=identifier>Kill </span><span class=identifier>the </span><span class=identifier>z </span><span class=identifier>object
-    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>y</span><span class=special>.</span><span class=identifier>z_value</span><span class=special>() </span>#<span class=identifier>CRASH</span><span class=special>!
-</span></pre></code>
-<p>
-For reference, here's the implementation of <tt>f</tt> again:</p>
-<code><pre>
-    <span class=identifier>X</span><span class=special>&amp; </span><span class=identifier>f</span><span class=special>(</span><span class=identifier>Y</span><span class=special>&amp; </span><span class=identifier>y</span><span class=special>, </span><span class=identifier>Z</span><span class=special>* </span><span class=identifier>z</span><span class=special>)
-    </span><span class=special>{
-        </span><span class=identifier>y</span><span class=special>.</span><span class=identifier>z </span><span class=special>= </span><span class=identifier>z</span><span class=special>;
-        </span><span class=keyword>return </span><span class=identifier>y</span><span class=special>.</span><span class=identifier>x</span><span class=special>;
-    </span><span class=special>}
-</span></pre></code>
-<p>
-Here's what's happening:</p>
-<ol><li><tt>f</tt> is called passing in a reference to <tt>y</tt> and a pointer to <tt>z</tt></li><li>A pointer to <tt>z</tt> is held by <tt>y</tt></li><li>A reference to <tt>y.x</tt> is returned</li><li><tt>z</tt> is deleted. <tt>y.z</tt> is a dangling pointer</li><li><tt>y.z_value()</tt> is called</li><li><tt>z-&gt;value()</tt> is called</li><li><b>BOOM!</b></li></ol><a name="call_policies"></a><h2>Call Policies</h2><p>
-Call Policies may be used in situations such as the example detailed above.
-In our example, <tt>return_internal_reference</tt> and <tt>with_custodian_and_ward</tt>
-are our friends:</p>
-<code><pre>
-    <span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>f</span><span class=special>,
-        </span><span class=identifier>return_internal_reference</span><span class=special>&lt;</span><span class=number>1</span><span class=special>,
-            </span><span class=identifier>with_custodian_and_ward</span><span class=special>&lt;</span><span class=number>1</span><span class=special>, </span><span class=number>2</span><span class=special>&gt; </span><span class=special>&gt;());
-</span></pre></code>
-<p>
-What are the <tt>1</tt> and <tt>2</tt> parameters, you ask?</p>
-<code><pre>
-    <span class=identifier>return_internal_reference</span><span class=special>&lt;</span><span class=number>1
-</span></pre></code>
-<p>
-Informs Boost.Python that the first argument, in our case <tt>Y&amp; y</tt>, is the
-owner of the returned reference: <tt>X&amp;</tt>. The &quot;<tt>1</tt>&quot; simply specifies the
-first argument. In short: &quot;return an internal reference <tt>X&amp;</tt> owned by the
-1st argument <tt>Y&amp; y</tt>&quot;.</p>
-<code><pre>
-    <span class=identifier>with_custodian_and_ward</span><span class=special>&lt;</span><span class=number>1</span><span class=special>, </span><span class=number>2</span><span class=special>&gt;
-</span></pre></code>
-<p>
-Informs Boost.Python that the lifetime of the argument indicated by ward
-(i.e. the 2nd argument: <tt>Z* z</tt>) is dependent on the lifetime of the
-argument indicated by custodian (i.e. the 1st argument: <tt>Y&amp; y</tt>).</p>
-<p>
-It is also important to note that we have defined two policies above. Two
-or more policies can be composed by chaining. Here's the general syntax:</p>
-<code><pre>
-    <span class=identifier>policy1</span><span class=special>&lt;</span><span class=identifier>args</span><span class=special>...,
-        </span><span class=identifier>policy2</span><span class=special>&lt;</span><span class=identifier>args</span><span class=special>...,
-            </span><span class=identifier>policy3</span><span class=special>&lt;</span><span class=identifier>args</span><span class=special>...&gt; </span><span class=special>&gt; </span><span class=special>&gt;
-</span></pre></code>
-<p>
-Here is the list of predefined call policies. A complete reference detailing
-these can be found <a href="../../v2/reference.html#models_of_call_policies">
-here</a>.</p>
-<ul><li><b>with_custodian_and_ward</b><br> Ties lifetimes of the arguments</li><li><b>with_custodian_and_ward_postcall</b><br> Ties lifetimes of the arguments and results</li><li><b>return_internal_reference</b><br> Ties lifetime of one argument to that of result</li><li><b>return_value_policy&lt;T&gt; with T one of:</b><br></li><li><b>reference_existing_object</b><br>naïve (dangerous) approach</li><li><b>copy_const_reference</b><br>Boost.Python v1 approach</li><li><b>copy_non_const_reference</b><br></li><li><b>manage_new_object</b><br> Adopt a pointer and hold the instance</li></ul><table width="80%" border="0" align="center">
-  <tr>
-    <td class="note_box">
-<img src="theme/smiley.gif"></img> <b>Remember the Zen, Luke:</b><br><br>
-&quot;Explicit is better than implicit&quot;<br>
-&quot;In the face of ambiguity, refuse the temptation to guess&quot;<br>    </td>
-  </tr>
-</table>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="functions.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="default_arguments.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/class_data_members.html

@@ -1,77 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Class Data Members</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="constructors.html">
-<link rel="next" href="class_properties.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Class Data Members</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="constructors.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="class_properties.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<p>
-Data members may also be exposed to Python so that they can be
-accessed as attributes of the corresponding Python class. Each data
-member that we wish to be exposed may be regarded as <b>read-only</b> or
-<b>read-write</b>.  Consider this class <tt>Var</tt>:</p>
-<code><pre>
-    <span class=keyword>struct </span><span class=identifier>Var
-    </span><span class=special>{
-        </span><span class=identifier>Var</span><span class=special>(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>name</span><span class=special>) </span><span class=special>: </span><span class=identifier>name</span><span class=special>(</span><span class=identifier>name</span><span class=special>), </span><span class=identifier>value</span><span class=special>() </span><span class=special>{}
-        </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=keyword>const </span><span class=identifier>name</span><span class=special>;
-        </span><span class=keyword>float </span><span class=identifier>value</span><span class=special>;
-    </span><span class=special>};
-</span></pre></code>
-<p>
-Our C++ <tt>Var</tt> class and its data members can be exposed to Python:</p>
-<code><pre>
-    <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Var</span><span class=special>&gt;(</span><span class=string>&quot;Var&quot;</span><span class=special>, </span><span class=identifier>init</span><span class=special>&lt;</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>&gt;())
-        </span><span class=special>.</span><span class=identifier>def_readonly</span><span class=special>(</span><span class=string>&quot;name&quot;</span><span class=special>, </span><span class=special>&amp;</span><span class=identifier>Var</span><span class=special>::</span><span class=identifier>name</span><span class=special>)
-        </span><span class=special>.</span><span class=identifier>def_readwrite</span><span class=special>(</span><span class=string>&quot;value&quot;</span><span class=special>, </span><span class=special>&amp;</span><span class=identifier>Var</span><span class=special>::</span><span class=identifier>value</span><span class=special>);
-</span></pre></code>
-<p>
-Then, in Python:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>x </span><span class=special>= </span><span class=identifier>Var</span><span class=special>(</span><span class=literal>'pi'</span><span class=special>)
-    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>value </span><span class=special>= </span><span class=number>3.14
-    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>print </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>name</span><span class=special>, </span><span class=literal>'is around'</span><span class=special>, </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>value
-    </span><span class=identifier>pi </span><span class=identifier>is </span><span class=identifier>around </span><span class=number>3.14
-</span></pre></code>
-<p>
-Note that <tt>name</tt> is exposed as <b>read-only</b> while <tt>value</tt> is exposed
-as <b>read-write</b>.</p>
-<code><pre>
-    &gt;&gt;&gt; x.name = 'e' # can't change name
-    Traceback (most recent call last):
-      File &quot;&lt;stdin&gt;&quot;, line 1, in ?
-    AttributeError: can't set attribute
-</pre></code><table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="constructors.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="class_properties.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/class_operators_special_functions.html

@@ -1,109 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Class Operators/Special Functions</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="class_virtual_functions.html">
-<link rel="next" href="functions.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Class Operators/Special Functions</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="class_virtual_functions.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="functions.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<a name="python_operators"></a><h2>Python Operators</h2><p>
-C is well known for the abundance of operators. C++ extends this to the
-extremes by allowing operator overloading. Boost.Python takes advantage of
-this and makes it easy to wrap C++ operator-powered classes.</p>
-<p>
-Consider a file position class <tt>FilePos</tt> and a set of operators that take
-on FilePos instances:</p>
-<code><pre>
-    <span class=keyword>class </span><span class=identifier>FilePos </span><span class=special>{ </span><span class=comment>/*...*/ </span><span class=special>};
-
-    </span><span class=identifier>FilePos     </span><span class=keyword>operator</span><span class=special>+(</span><span class=identifier>FilePos</span><span class=special>, </span><span class=keyword>int</span><span class=special>);
-    </span><span class=identifier>FilePos     </span><span class=keyword>operator</span><span class=special>+(</span><span class=keyword>int</span><span class=special>, </span><span class=identifier>FilePos</span><span class=special>);
-    </span><span class=keyword>int         </span><span class=keyword>operator</span><span class=special>-(</span><span class=identifier>FilePos</span><span class=special>, </span><span class=identifier>FilePos</span><span class=special>);
-    </span><span class=identifier>FilePos     </span><span class=keyword>operator</span><span class=special>-(</span><span class=identifier>FilePos</span><span class=special>, </span><span class=keyword>int</span><span class=special>);
-    </span><span class=identifier>FilePos</span><span class=special>&amp;    </span><span class=keyword>operator</span><span class=special>+=(</span><span class=identifier>FilePos</span><span class=special>&amp;, </span><span class=keyword>int</span><span class=special>);
-    </span><span class=identifier>FilePos</span><span class=special>&amp;    </span><span class=keyword>operator</span><span class=special>-=(</span><span class=identifier>FilePos</span><span class=special>&amp;, </span><span class=keyword>int</span><span class=special>);
-    </span><span class=keyword>bool        </span><span class=keyword>operator</span><span class=special>&lt;(</span><span class=identifier>FilePos</span><span class=special>, </span><span class=identifier>FilePos</span><span class=special>);
-</span></pre></code>
-<p>
-The class and the various operators can be mapped to Python rather easily
-and intuitively:</p>
-<code><pre>
-    <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>FilePos</span><span class=special>&gt;(</span><span class=string>&quot;FilePos&quot;</span><span class=special>)
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>self </span><span class=special>+ </span><span class=keyword>int</span><span class=special>())          </span><span class=comment>// __add__
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=keyword>int</span><span class=special>() </span><span class=special>+ </span><span class=identifier>self</span><span class=special>)          </span><span class=comment>// __radd__
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>self </span><span class=special>- </span><span class=identifier>self</span><span class=special>)           </span><span class=comment>// __sub__
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>self </span><span class=special>- </span><span class=keyword>int</span><span class=special>())          </span><span class=comment>// __rsub__
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>self </span><span class=special>+= </span><span class=keyword>int</span><span class=special>())         </span><span class=comment>// __iadd__
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>self </span><span class=special>-= </span><span class=identifier>other</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;())
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>self </span><span class=special>&lt; </span><span class=identifier>self</span><span class=special>);          </span><span class=comment>// __lt__
-</span></pre></code>
-<p>
-The code snippet above is very clear and needs almost no explanation at
-all. It is virtually the same as the operators' signatures. Just take
-note that <tt>self</tt> refers to FilePos object. Also, not every class <tt>T</tt> that
-you might need to interact with in an operator expression is (cheaply)
-default-constructible. You can use <tt>other&lt;T&gt;()</tt> in place of an actual
-<tt>T</tt> instance when writing &quot;self expressions&quot;.</p>
-<a name="special_methods"></a><h2>Special Methods</h2><p>
-Python has a few more <i>Special Methods</i>. Boost.Python supports all of the
-standard special method names supported by real Python class instances. A
-similar set of intuitive interfaces can also be used to wrap C++ functions
-that correspond to these Python <i>special functions</i>. Example:</p>
-<code><pre>
-    <span class=keyword>class </span><span class=identifier>Rational
-    </span><span class=special>{ </span><span class=keyword>operator </span><span class=keyword>double</span><span class=special>() </span><span class=keyword>const</span><span class=special>; </span><span class=special>};
-
-    </span><span class=identifier>Rational </span><span class=identifier>pow</span><span class=special>(</span><span class=identifier>Rational</span><span class=special>, </span><span class=identifier>Rational</span><span class=special>);
-    </span><span class=identifier>Rational </span><span class=identifier>abs</span><span class=special>(</span><span class=identifier>Rational</span><span class=special>);
-    </span><span class=identifier>ostream</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>&lt;&lt;(</span><span class=identifier>ostream</span><span class=special>&amp;,</span><span class=identifier>Rational</span><span class=special>);
-
-    </span><span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Rational</span><span class=special>&gt;()
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>float_</span><span class=special>(</span><span class=identifier>self</span><span class=special>))                  </span><span class=comment>// __float__
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>pow</span><span class=special>(</span><span class=identifier>self</span><span class=special>, </span><span class=identifier>other</span><span class=special>&lt;</span><span class=identifier>Rational</span><span class=special>&gt;))    </span><span class=comment>// __pow__
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>abs</span><span class=special>(</span><span class=identifier>self</span><span class=special>))                     </span><span class=comment>// __abs__
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>str</span><span class=special>(</span><span class=identifier>self</span><span class=special>))                     </span><span class=comment>// __str__
-        </span><span class=special>;
-</span></pre></code>
-<p>
-Need we say more?</p>
-<table width="80%" border="0" align="center">
-  <tr>
-    <td class="note_box">
-<img src="theme/lens.gif"></img> What is the business of <tt>operator&lt;&lt;</tt> <tt>.def(str(self))</tt>?
-Well, the method <tt>str</tt> requires the <tt>operator&lt;&lt;</tt> to do its work (i.e.
-<tt>operator&lt;&lt;</tt> is used by the method defined by def(str(self)).    </td>
-  </tr>
-</table>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="class_virtual_functions.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="functions.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/class_properties.html

@@ -1,81 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Class Properties</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="class_data_members.html">
-<link rel="next" href="inheritance.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Class Properties</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="class_data_members.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="inheritance.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<p>
-In C++, classes with public data members are usually frowned
-upon. Well designed classes that take advantage of encapsulation hide
-the class' data members. The only way to access the class' data is
-through access (getter/setter) functions. Access functions expose class
-properties. Here's an example:</p>
-<code><pre>
-    <span class=keyword>struct </span><span class=identifier>Num
-    </span><span class=special>{
-        </span><span class=identifier>Num</span><span class=special>();
-        </span><span class=keyword>float </span><span class=identifier>get</span><span class=special>() </span><span class=keyword>const</span><span class=special>;
-        </span><span class=keyword>void </span><span class=identifier>set</span><span class=special>(</span><span class=keyword>float </span><span class=identifier>value</span><span class=special>);
-        </span><span class=special>...
-    </span><span class=special>};
-</span></pre></code>
-<p>
-However, in Python attribute access is fine; it doesn't neccessarily break
-encapsulation to let users handle attributes directly, because the
-attributes can just be a different syntax for a method call. Wrapping our
-<tt>Num</tt> class using Boost.Python:</p>
-<code><pre>
-    <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Num</span><span class=special>&gt;(</span><span class=string>&quot;Num&quot;</span><span class=special>)
-        </span><span class=special>.</span><span class=identifier>add_property</span><span class=special>(</span><span class=string>&quot;rovalue&quot;</span><span class=special>, </span><span class=special>&amp;</span><span class=identifier>Var</span><span class=special>::</span><span class=identifier>get</span><span class=special>)
-        </span><span class=special>.</span><span class=identifier>add_property</span><span class=special>(</span><span class=string>&quot;value&quot;</span><span class=special>, </span><span class=special>&amp;</span><span class=identifier>Var</span><span class=special>::</span><span class=identifier>get</span><span class=special>, </span><span class=special>&amp;</span><span class=identifier>Var</span><span class=special>::</span><span class=identifier>set</span><span class=special>);
-</span></pre></code>
-<p>
-And at last, in Python:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>x </span><span class=special>= </span><span class=identifier>Num</span><span class=special>()
-    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>value </span><span class=special>= </span><span class=number>3.14
-    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>value</span><span class=special>, </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>rovalue
-    </span><span class=special>(</span><span class=number>3.14</span><span class=special>, </span><span class=number>3.14</span><span class=special>)
-    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>rovalue </span><span class=special>= </span><span class=number>2.17 </span>#<span class=identifier>error</span><span class=special>!
-</span></pre></code>
-<p>
-Take note that the class property <tt>rovalue</tt> is exposed as <b>read-only</b>
-since the <tt>rovalue</tt> setter member function is not passed in:</p>
-<code><pre>
-    <span class=special>.</span><span class=identifier>add_property</span><span class=special>(</span><span class=string>&quot;rovalue&quot;</span><span class=special>, </span><span class=special>&amp;</span><span class=identifier>Var</span><span class=special>::</span><span class=identifier>get</span><span class=special>)
-</span></pre></code>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="class_data_members.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="inheritance.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/class_virtual_functions.html

@@ -1,227 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Class Virtual Functions</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="inheritance.html">
-<link rel="next" href="class_operators_special_functions.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Class Virtual Functions</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="inheritance.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="class_operators_special_functions.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<p>
-In this section, we shall learn how to make functions behave
-polymorphically through virtual functions. Continuing our example, let us
-add a virtual function to our <tt>Base</tt> class:</p>
-<code><pre>
-    <span class=keyword>struct </span><span class=identifier>Base
-    </span><span class=special>{
-        </span><span class=keyword>virtual </span><span class=keyword>int </span><span class=identifier>f</span><span class=special>() </span><span class=special>= </span><span class=number>0</span><span class=special>;
-    </span><span class=special>};
-</span></pre></code>
-<p>
-Since <tt>f</tt> is a pure virtual function, <tt>Base</tt> is now an abstract
-class. Given an instance of our class, the free function <tt>call_f</tt>
-calls some implementation of this virtual function in a concrete
-derived class:</p>
-<code><pre>
-    <span class=keyword>int </span><span class=identifier>call_f</span><span class=special>(</span><span class=identifier>Base</span><span class=special>&amp; </span><span class=identifier>b</span><span class=special>) </span><span class=special>{ </span><span class=keyword>return </span><span class=identifier>b</span><span class=special>.</span><span class=identifier>f</span><span class=special>(); </span><span class=special>}
-</span></pre></code>
-<p>
-To allow this function to be implemented in a Python derived class, we
-need to create a class wrapper:</p>
-<code><pre>
-    <span class=keyword>struct </span><span class=identifier>BaseWrap </span><span class=special>: </span><span class=identifier>Base
-    </span><span class=special>{
-        </span><span class=identifier>BaseWrap</span><span class=special>(</span><span class=identifier>PyObject</span><span class=special>* </span><span class=identifier>self_</span><span class=special>)
-            </span><span class=special>: </span><span class=identifier>self</span><span class=special>(</span><span class=identifier>self_</span><span class=special>) </span><span class=special>{}
-        </span><span class=keyword>int </span><span class=identifier>f</span><span class=special>() </span><span class=special>{ </span><span class=keyword>return </span><span class=identifier>call_method</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;(</span><span class=identifier>self</span><span class=special>, </span><span class=string>&quot;f&quot;</span><span class=special>); </span><span class=special>}
-        </span><span class=identifier>PyObject</span><span class=special>* </span><span class=identifier>self</span><span class=special>;
-    </span><span class=special>};
-</span></pre></code>
-<table width="80%" border="0" align="center">
-  <tr>
-    <td class="note_box">
-<img src="theme/lens.gif"></img> <b>member function and methods</b><br><br> Python, like
-many object oriented languages uses the term <b>methods</b>.  Methods
-correspond roughly to C++'s <b>member functions</b>    </td>
-  </tr>
-</table>
-<p>
-Our class wrapper <tt>BaseWrap</tt> is derived from <tt>Base</tt>. Its overridden
-virtual member function <tt>f</tt> in effect calls the corresponding method
-of the Python object <tt>self</tt>, which is a pointer back to the Python
-<tt>Base</tt> object holding our <tt>BaseWrap</tt> instance.</p>
-<table width="80%" border="0" align="center">
-  <tr>
-    <td class="note_box">
-<img src="theme/note.gif"></img> <b>Why do we need BaseWrap?</b><br><br>
-
-<i>You may ask</i>, &quot;Why do we need the <tt>BaseWrap</tt> derived class? This could
-have been designed so that everything gets done right inside of
-Base.&quot;<br><br>
-
-One of the goals of Boost.Python is to be minimally intrusive on an
-existing C++ design. In principle, it should be possible to expose the
-interface for a 3rd party library without changing it. To unintrusively
-hook into the virtual functions so that a Python override may be called, we
-must use a derived class.<br><br>
-
-Note however that you don't need to do this to get methods overridden
-in Python to behave virtually when called <i>from</i> <b>Python</b>. The only
-time you need to do the <tt>BaseWrap</tt> dance is when you have a virtual
-function that's going to be overridden in Python and called
-polymorphically <i>from</i> <b>C++</b>.    </td>
-  </tr>
-</table>
-<p>
-Wrapping <tt>Base</tt> and the free function <tt>call_f</tt>:</p>
-<code><pre>
-    <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Base</span><span class=special>, </span><span class=identifier>BaseWrap</span><span class=special>, </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>noncopyable</span><span class=special>&gt;(</span><span class=string>&quot;Base&quot;</span><span class=special>, </span><span class=identifier>no_init</span><span class=special>)
-        </span><span class=special>;
-    </span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;call_f&quot;</span><span class=special>, </span><span class=identifier>call_f</span><span class=special>);
-</span></pre></code>
-<p>
-Notice that we parameterized the <tt>class_</tt> template with <tt>BaseWrap</tt> as the
-second parameter. What is <tt>noncopyable</tt>? Without it, the library will try
-to create code for converting Base return values of wrapped functions to
-Python. To do that, it needs Base's copy constructor... which isn't
-available, since Base is an abstract class.</p>
-<p>
-In Python, let us try to instantiate our <tt>Base</tt> class:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>base </span><span class=special>= </span><span class=identifier>Base</span><span class=special>()
-    </span><span class=identifier>AttributeError</span><span class=special>: </span><span class=special>...
-</span></pre></code>
-<p>
-Why is it an error? <tt>Base</tt> is an abstract class. As such it is advisable
-to define the Python wrapper with <tt>no_init</tt> as we have done above. Doing
-so will disallow abstract base classes such as <tt>Base</tt> to be instantiated.</p>
-<a name="deriving_a_python_class"></a><h2>Deriving a Python class</h2><p>
-Now, at last, we can even derive from our base class <tt>Base</tt> in Python:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=keyword>class </span><span class=identifier>Derived</span><span class=special>(</span><span class=identifier>Base</span><span class=special>):
-    </span><span class=special>...     </span><span class=identifier>def </span><span class=identifier>f</span><span class=special>(</span><span class=identifier>self</span><span class=special>):
-    </span><span class=special>...         </span><span class=keyword>return </span><span class=number>42
-    </span><span class=special>...
-</span></pre></code>
-<p>
-Cool eh? A Python class deriving from a C++ class!</p>
-<p>
-Let's now make an instance of our Python class <tt>Derived</tt>:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>derived </span><span class=special>= </span><span class=identifier>Derived</span><span class=special>()
-</span></pre></code>
-<p>
-Calling <tt>derived.f()</tt>:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>derived</span><span class=special>.</span><span class=identifier>f</span><span class=special>()
-    </span><span class=number>42
-</span></pre></code>
-<p>
-Will yield the expected result. Finally, calling calling the free function
-<tt>call_f</tt> with <tt>derived</tt> as argument:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>call_f</span><span class=special>(</span><span class=identifier>derived</span><span class=special>)
-    </span><span class=number>42
-</span></pre></code>
-<p>
-Will also yield the expected result.</p>
-<p>
-Here's what's happening:</p>
-<ol><li><tt>call_f(derived)</tt> is called in Python</li><li>This corresponds to <tt>def(&quot;call_f&quot;, call_f);</tt>. Boost.Python dispatches this call.</li><li><tt>int call_f(Base&amp; b) { return b.f(); }</tt> accepts the call.</li><li>The overridden virtual function <tt>f</tt> of <tt>BaseWrap</tt> is called.</li><li><tt>call_method&lt;int&gt;(self, &quot;f&quot;);</tt> dispatches the call back to Python.</li><li><tt>def f(self): return 42</tt> is finally called.</li></ol><p>
-Rewind back to our <tt>Base</tt> class, if its member function <tt>f</tt> was not
-declared as pure virtual:</p>
-<code><pre>
-    <span class=keyword>struct </span><span class=identifier>Base
-    </span><span class=special>{
-        </span><span class=keyword>virtual </span><span class=keyword>int </span><span class=identifier>f</span><span class=special>() </span><span class=special>{ </span><span class=keyword>return </span><span class=number>0</span><span class=special>; </span><span class=special>}
-    </span><span class=special>};
-</span></pre></code>
-<p>
-And instead is implemented to return <tt>0</tt>, as shown above.</p>
-<code><pre>
-    <span class=keyword>struct </span><span class=identifier>BaseWrap </span><span class=special>: </span><span class=identifier>Base
-    </span><span class=special>{
-        </span><span class=identifier>BaseWrap</span><span class=special>(</span><span class=identifier>PyObject</span><span class=special>* </span><span class=identifier>self_</span><span class=special>)
-            </span><span class=special>: </span><span class=identifier>self</span><span class=special>(</span><span class=identifier>self_</span><span class=special>) </span><span class=special>{}
-        </span><span class=keyword>int </span><span class=identifier>f</span><span class=special>() </span><span class=special>{ </span><span class=keyword>return </span><span class=identifier>call_method</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;(</span><span class=identifier>self</span><span class=special>, </span><span class=string>&quot;f&quot;</span><span class=special>); </span><span class=special>}
-        </span><span class=keyword>static </span><span class=keyword>int </span><span class=identifier>default_f</span><span class=special>(</span><span class=identifier>Base</span><span class=special>* </span><span class=identifier>b</span><span class=special>) </span><span class=special>{ </span><span class=keyword>return </span><span class=identifier>b</span><span class=special>-&gt;</span><span class=identifier>Base</span><span class=special>::</span><span class=identifier>f</span><span class=special>(); </span><span class=special>} </span><span class=comment>// &lt;&lt;=== added
-        </span><span class=identifier>PyObject</span><span class=special>* </span><span class=identifier>self</span><span class=special>;
-    </span><span class=special>};
-</span></pre></code>
-<p>
-then, our Boost.Python wrapper:</p>
-<code><pre>
-    <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Base</span><span class=special>, </span><span class=identifier>BaseWrap</span><span class=special>&gt;(</span><span class=string>&quot;Base&quot;</span><span class=special>)
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=special>&amp;</span><span class=identifier>BaseWrap</span><span class=special>::</span><span class=identifier>default_f</span><span class=special>)
-        </span><span class=special>;
-</span></pre></code>
-<p>
-Note that we are allowing <tt>Base</tt> objects to be instantiated this time,
-unlike before where we specifically defined the <tt>class_&lt;Base&gt;</tt> with
-<tt>no_init</tt>.</p>
-<p>
-In Python, the results would be as expected:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>base </span><span class=special>= </span><span class=identifier>Base</span><span class=special>()
-    </span><span class=special>&gt;&gt;&gt; </span><span class=keyword>class </span><span class=identifier>Derived</span><span class=special>(</span><span class=identifier>Base</span><span class=special>):
-    </span><span class=special>...     </span><span class=identifier>def </span><span class=identifier>f</span><span class=special>(</span><span class=identifier>self</span><span class=special>):
-    </span><span class=special>...         </span><span class=keyword>return </span><span class=number>42
-    </span><span class=special>...
-    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>derived </span><span class=special>= </span><span class=identifier>Derived</span><span class=special>()
-</span></pre></code>
-<p>
-Calling <tt>base.f()</tt>:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>base</span><span class=special>.</span><span class=identifier>f</span><span class=special>()
-    </span><span class=number>0
-</span></pre></code>
-<p>
-Calling <tt>derived.f()</tt>:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>derived</span><span class=special>.</span><span class=identifier>f</span><span class=special>()
-    </span><span class=number>42
-</span></pre></code>
-<p>
-Calling <tt>call_f</tt>, passing in a <tt>base</tt> object:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>call_f</span><span class=special>(</span><span class=identifier>base</span><span class=special>)
-    </span><span class=number>0
-</span></pre></code>
-<p>
-Calling <tt>call_f</tt>, passing in a <tt>derived</tt> object:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>call_f</span><span class=special>(</span><span class=identifier>derived</span><span class=special>)
-    </span><span class=number>42
-</span></pre></code>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="inheritance.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="class_operators_special_functions.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/constructors.html

@@ -1,102 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Constructors</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="exposing_classes.html">
-<link rel="next" href="class_data_members.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Constructors</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="exposing_classes.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="class_data_members.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<p>
-Our previous example didn't have any explicit constructors.
-Since <tt>World</tt> is declared as a plain struct, it has an implicit default
-constructor. Boost.Python exposes the default constructor by default,
-which is why we were able to write</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>planet </span><span class=special>= </span><span class=identifier>hello</span><span class=special>.</span><span class=identifier>World</span><span class=special>()
-</span></pre></code>
-<p>
-We may wish to wrap a class with a non-default constructor. Let us
-build on our previous example:</p>
-<code><pre>
-    <span class=keyword>struct </span><span class=identifier>World
-    </span><span class=special>{
-        </span><span class=identifier>World</span><span class=special>(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>msg</span><span class=special>): </span><span class=identifier>msg</span><span class=special>(</span><span class=identifier>msg</span><span class=special>) </span><span class=special>{} </span><span class=comment>// added constructor
-        </span><span class=keyword>void </span><span class=identifier>set</span><span class=special>(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>msg</span><span class=special>) </span><span class=special>{ </span><span class=keyword>this</span><span class=special>-&gt;</span><span class=identifier>msg </span><span class=special>= </span><span class=identifier>msg</span><span class=special>; </span><span class=special>}
-        </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>greet</span><span class=special>() </span><span class=special>{ </span><span class=keyword>return </span><span class=identifier>msg</span><span class=special>; </span><span class=special>}
-        </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>msg</span><span class=special>;
-    </span><span class=special>};
-</span></pre></code>
-<p>
-This time <tt>World</tt> has no default constructor; our previous
-wrapping code would fail to compile when the library tried to expose
-it. We have to tell <tt>class_&lt;World&gt;</tt> about the constructor we want to
-expose instead.</p>
-<code><pre>
-    <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>BOOST_PYTHON_MODULE</span><span class=special>(</span><span class=identifier>hello</span><span class=special>)
-    </span><span class=special>{
-        </span><span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>World</span><span class=special>&gt;(</span><span class=string>&quot;World&quot;</span><span class=special>, </span><span class=identifier>init</span><span class=special>&lt;</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>&gt;())
-            </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;greet&quot;</span><span class=special>, </span><span class=special>&amp;</span><span class=identifier>World</span><span class=special>::</span><span class=identifier>greet</span><span class=special>)
-            </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;set&quot;</span><span class=special>, </span><span class=special>&amp;</span><span class=identifier>World</span><span class=special>::</span><span class=identifier>set</span><span class=special>)
-        </span><span class=special>;
-    </span><span class=special>}
-</span></pre></code>
-<p>
-<tt>init&lt;std::string&gt;()</tt> exposes the constructor taking in a
-<tt>std::string</tt> (in Python, constructors are spelled
-&quot;<tt>&quot;__init__&quot;</tt>&quot;).</p>
-<p>
-We can expose additional constructors by passing more <tt>init&lt;...&gt;</tt>s to
-the <tt>def()</tt> member function. Say for example we have another World
-constructor taking in two doubles:</p>
-<code><pre>
-    <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>World</span><span class=special>&gt;(</span><span class=string>&quot;World&quot;</span><span class=special>, </span><span class=identifier>init</span><span class=special>&lt;</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>&gt;())
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>init</span><span class=special>&lt;</span><span class=keyword>double</span><span class=special>, </span><span class=keyword>double</span><span class=special>&gt;())
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;greet&quot;</span><span class=special>, </span><span class=special>&amp;</span><span class=identifier>World</span><span class=special>::</span><span class=identifier>greet</span><span class=special>)
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;set&quot;</span><span class=special>, </span><span class=special>&amp;</span><span class=identifier>World</span><span class=special>::</span><span class=identifier>set</span><span class=special>)
-    </span><span class=special>;
-</span></pre></code>
-<p>
-On the other hand, if we do not wish to expose any constructors at
-all, we may use <tt>no_init</tt> instead:</p>
-<code><pre>
-    <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Abstract</span><span class=special>&gt;(</span><span class=string>&quot;Abstract&quot;</span><span class=special>, </span><span class=identifier>no_init</span><span class=special>)
-</span></pre></code>
-<p>
-This actually adds an <tt>__init__</tt> method which always raises a
-Python RuntimeError exception.</p>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="exposing_classes.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="class_data_members.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/default_arguments.html

@@ -1,118 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Default Arguments</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="call_policies.html">
-<link rel="next" href="object_interface.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Default Arguments</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="call_policies.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="object_interface.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<p>
-Boost.Python wraps (member) function pointers. Unfortunately, C++ function
-pointers carry no default argument info. Take a function <tt>f</tt> with default
-arguments:</p>
-<code><pre>
-    <span class=keyword>int </span><span class=identifier>f</span><span class=special>(</span><span class=keyword>int</span><span class=special>, </span><span class=keyword>double </span><span class=special>= </span><span class=number>3.14</span><span class=special>, </span><span class=keyword>char </span><span class=keyword>const</span><span class=special>* </span><span class=special>= </span><span class=string>&quot;hello&quot;</span><span class=special>);
-</span></pre></code>
-<p>
-But the type of a pointer to the function <tt>f</tt> has no information
-about its default arguments:</p>
-<code><pre>
-    <span class=keyword>int</span><span class=special>(*</span><span class=identifier>g</span><span class=special>)(</span><span class=keyword>int</span><span class=special>,</span><span class=keyword>double</span><span class=special>,</span><span class=keyword>char </span><span class=keyword>const</span><span class=special>*) </span><span class=special>= </span><span class=identifier>f</span><span class=special>;    </span><span class=comment>// defaults lost!
-</span></pre></code>
-<p>
-When we pass this function pointer to the <tt>def</tt> function, there is no way
-to retrieve the default arguments:</p>
-<code><pre>
-    <span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>f</span><span class=special>);                            </span><span class=comment>// defaults lost!
-</span></pre></code>
-<p>
-Because of this, when wrapping C++ code in earlier versions of
-Boost.Python, we had to resort to writing thin wrappers:</p>
-<code><pre>
-    <span class=comment>// write &quot;thin wrappers&quot;
-    </span><span class=keyword>int </span><span class=identifier>f1</span><span class=special>(</span><span class=keyword>int </span><span class=identifier>x</span><span class=special>) </span><span class=special>{ </span><span class=identifier>f</span><span class=special>(</span><span class=identifier>x</span><span class=special>); </span><span class=special>}
-    </span><span class=keyword>int </span><span class=identifier>f2</span><span class=special>(</span><span class=keyword>int </span><span class=identifier>x</span><span class=special>, </span><span class=keyword>double </span><span class=identifier>y</span><span class=special>) </span><span class=special>{ </span><span class=identifier>f</span><span class=special>(</span><span class=identifier>x</span><span class=special>,</span><span class=identifier>y</span><span class=special>); </span><span class=special>}
-
-    </span><span class=comment>/*...*/
-
-        // in module init
-        </span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>f</span><span class=special>);  </span><span class=comment>// all arguments
-        </span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>f2</span><span class=special>); </span><span class=comment>// two arguments
-        </span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>f1</span><span class=special>); </span><span class=comment>// one argument
-</span></pre></code>
-<p>
-When you want to wrap functions (or member functions) that either:</p>
-<ul><li>have default arguments, or</li><li>are overloaded with a common sequence of initial arguments</li></ul><p>
-Boost.Python now has a way to make it easier.</p>
-<p>
-For instance, given a function:</p>
-<code><pre>
-    <span class=keyword>int </span><span class=identifier>foo</span><span class=special>(</span><span class=keyword>int </span><span class=identifier>a</span><span class=special>, </span><span class=keyword>char </span><span class=identifier>b </span><span class=special>= </span><span class=number>1</span><span class=special>, </span><span class=keyword>unsigned </span><span class=identifier>c </span><span class=special>= </span><span class=number>2</span><span class=special>, </span><span class=keyword>double </span><span class=identifier>d </span><span class=special>= </span><span class=number>3</span><span class=special>);
-</span></pre></code>
-<p>
-The macro invocation:</p>
-<code><pre>
-    <span class=identifier>BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class=special>(</span><span class=identifier>foo_overloads</span><span class=special>, </span><span class=identifier>foo</span><span class=special>, </span><span class=number>1</span><span class=special>, </span><span class=number>4</span><span class=special>)
-</span></pre></code>
-<p>
-Will automatically create the thin wrappers for us. This macro will create
-a class <tt>foo_overloads</tt> that can be passed on to <tt>def(...)</tt>. The third
-and fourth macro argument are the minimum arguments and maximum arguments,
-respectively. In our <tt>foo</tt> function the minimum number of arguments is 1
-and the maximum number of arguments is 4. The <tt>def(...)</tt> function will
-automatically add all the foo variants for us:</p>
-<code><pre>
-    <span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;foo&quot;</span><span class=special>, </span><span class=identifier>foo</span><span class=special>, </span><span class=identifier>foo_overloads</span><span class=special>());
-</span></pre></code>
-<p>
-A similar facility is provided for class constructors, again, with
-default arguments or a sequence of overloads. Remember init&lt;...&gt;? For example,
-given a class X with a constructor:</p>
-<code><pre>
-    <span class=keyword>struct </span><span class=identifier>X
-    </span><span class=special>{
-        </span><span class=identifier>X</span><span class=special>(</span><span class=keyword>int </span><span class=identifier>a</span><span class=special>, </span><span class=keyword>char </span><span class=identifier>b </span><span class=special>= </span><span class=literal>'D'</span><span class=special>, </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>c </span><span class=special>= </span><span class=string>&quot;constructor&quot;</span><span class=special>, </span><span class=keyword>double </span><span class=identifier>d </span><span class=special>= </span><span class=number>0.0</span><span class=special>);
-        </span><span class=comment>/*...*/
-    </span><span class=special>}
-</span></pre></code>
-<p>
-You can easily add this constructor to Boost.Python in one shot:</p>
-<code><pre>
-    <span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>init</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>, </span><span class=identifier>optional</span><span class=special>&lt;</span><span class=keyword>char</span><span class=special>, </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>, </span><span class=keyword>double</span><span class=special>&gt; </span><span class=special>&gt;())
-</span></pre></code>
-<p>
-Notice the use of <tt>init&lt;...&gt;</tt> and <tt>optional&lt;...&gt;</tt> to signify the default
-(optional arguments).</p>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="call_policies.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="object_interface.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/derived_object_types.html

@@ -1,117 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Derived Object types</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="basic_interface.html">
-<link rel="next" href="extracting_c___objects.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Derived Object types</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="basic_interface.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="extracting_c___objects.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<p>
-Boost.Python comes with a set of derived <tt>object</tt> types corresponding to
-that of Python's:</p>
-<ul><li>list</li><li>dict</li><li>tuple</li><li>str</li><li>long_</li><li>enum</li></ul><p>
-These derived <tt>object</tt> types act like real Python types. For instance:</p>
-<code><pre>
-    <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>&quot;1&quot;
-</span></pre></code>
-<p>
-Wherever appropriate, a particular derived <tt>object</tt> has corresponding
-Python type's methods. For instance, <tt>dict</tt> has a <tt>keys()</tt> method:</p>
-<code><pre>
-    <span class=identifier>d</span><span class=special>.</span><span class=identifier>keys</span><span class=special>()
-</span></pre></code>
-<p>
-<tt>make_tuple</tt> is provided for declaring <i>tuple literals</i>. Example:</p>
-<code><pre>
-    <span class=identifier>make_tuple</span><span class=special>(</span><span class=number>123</span><span class=special>, </span><span class=literal>'D'</span><span class=special>, </span><span class=string>&quot;Hello, World&quot;</span><span class=special>, </span><span class=number>0.0</span><span class=special>);
-</span></pre></code>
-<p>
-In C++, when Boost.Python <tt>object</tt>s are used as arguments to functions,
-subtype matching is required. For example, when a function <tt>f</tt>, as
-declared below, is wrapped, it will only accept instances of Python's
-<tt>str</tt> type and subtypes.</p>
-<code><pre>
-    <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>&quot;upper&quot;</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>&quot;%s is bigger than %s&quot; </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></code>
-<p>
-In finer detail:</p>
-<code><pre>
-    <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></code>
-<p>
-Illustrates that we provide versions of the str type's methods as C++
-member functions.</p>
-<code><pre>
-    <span class=identifier>object </span><span class=identifier>msg </span><span class=special>= </span><span class=string>&quot;%s is bigger than %s&quot; </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></code>
-<p>
-Demonstrates that you can write the C++ equivalent of <tt>&quot;format&quot; % x,y,z</tt>
-in Python, which is useful since there's no easy way to do that in std C++.</p>
-<p>
-<img src="theme/alert.gif"></img> <b>Beware</b> the common pitfall of forgetting that the constructors
-of most of Python's mutable types make copies, just as in Python.</p>
-<p>
-Python:</p>
-<code><pre>
-    <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=literal>'whatever'</span><span class=special>]            </span>#<span class=identifier>modifies </span><span class=identifier>the </span><span class=identifier>copy
-</span></pre></code>
-<p>
-C++:</p>
-<code><pre>
-    <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>&quot;__dict__&quot;</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=literal>'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></pre></code>
-<a name="class__lt_t_gt__as_objects"></a><h2>class_&lt;T&gt; as objects</h2><p>
-Due to the dynamic nature of Boost.Python objects, any <tt>class_&lt;T&gt;</tt> 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>
-<code><pre>
-    <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>&quot;Vec2&quot;</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>&quot;length&quot;</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>&quot;angle&quot;</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>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>&quot;length&quot;</span><span class=special>) </span><span class=special>== </span><span class=number>5.0</span><span class=special>);
-</span></pre></code>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="basic_interface.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="extracting_c___objects.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/enums.html

@@ -1,95 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Enums</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="extracting_c___objects.html">
-<link rel="next" href="iterators.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Enums</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="extracting_c___objects.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="iterators.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<p>
-Boost.Python has a nifty facility to capture and wrap C++ enums. While
-Python has no <tt>enum</tt> type, we'll often want to expose our C++ enums to
-Python as an <tt>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>
-<code><pre>
-    <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></code>
-<p>
-the construct:</p>
-<code><pre>
-    <span class=identifier>enum_</span><span class=special>&lt;</span><span class=identifier>choice</span><span class=special>&gt;(</span><span class=string>&quot;choice&quot;</span><span class=special>)
-        </span><span class=special>.</span><span class=identifier>value</span><span class=special>(</span><span class=string>&quot;red&quot;</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>&quot;blue&quot;</span><span class=special>, </span><span class=identifier>blue</span><span class=special>)
-        </span><span class=special>;
-</span></pre></code>
-<p>
-can be used to expose to Python. The new enum type is created in the
-current <tt>scope()</tt>, which is usually the current module. The snippet above
-creates a Python class derived from Python's <tt>int</tt> type which is
-associated with the C++ type passed as its first parameter.</p>
-<table width="80%" border="0" align="center">
-  <tr>
-    <td class="note_box">
-<img src="theme/lens.gif"></img> <b>what is a scope?</b><br><br> The scope is a class that has an
-associated global Python object which controls the Python namespace in
-which new extension classes and wrapped functions will be defined as
-attributes. Details can be found <a href="../../v2/scope.html">
-here</a>.    </td>
-  </tr>
-</table>
-<p>
-You can access those values in Python as</p>
-<code><pre>
-    <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></code>
-<p>
-where my_module is the module where the enum is declared. You can also
-create a new scope around a class:</p>
-<code><pre>
-    <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>&quot;X&quot;</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>// 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>&quot;nested&quot;</span><span class=special>)
-        </span><span class=special>.</span><span class=identifier>value</span><span class=special>(</span><span class=string>&quot;red&quot;</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>&quot;blue&quot;</span><span class=special>, </span><span class=identifier>blue</span><span class=special>)
-        </span><span class=special>;
-</span></pre></code>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="extracting_c___objects.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="iterators.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/exception_translation.html

@@ -1,60 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Exception Translation</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="iterators.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Exception Translation</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="iterators.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><img src="theme/r_arr_disabled.gif" border="0"></td>
-   </tr>
-</table>
-<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>
-<code><pre>
-    <span class=identifier>raise </span><span class=identifier>RuntimeError</span><span class=special>, </span><span class=literal>'unidentifiable C++ Exception'
-</span></pre></code>
-<p>
-Users may provide custom translation. Here's an example:</p>
-<code><pre>
-    <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=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>&quot;I'm sorry Dave...&quot;</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></code>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="iterators.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><img src="theme/r_arr_disabled.gif" border="0"></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/exposing_classes.html

@@ -1,79 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Exposing Classes</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="building_hello_world.html">
-<link rel="next" href="constructors.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Exposing Classes</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="building_hello_world.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="constructors.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<p>
-Now let's expose a C++ class to Python.</p>
-<p>
-Consider a C++ class/struct that we want to expose to Python:</p>
-<code><pre>
-    <span class=keyword>struct </span><span class=identifier>World
-    </span><span class=special>{
-        </span><span class=keyword>void </span><span class=identifier>set</span><span class=special>(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>msg</span><span class=special>) </span><span class=special>{ </span><span class=keyword>this</span><span class=special>-&gt;</span><span class=identifier>msg </span><span class=special>= </span><span class=identifier>msg</span><span class=special>; </span><span class=special>}
-        </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>greet</span><span class=special>() </span><span class=special>{ </span><span class=keyword>return </span><span class=identifier>msg</span><span class=special>; </span><span class=special>}
-        </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>msg</span><span class=special>;
-    </span><span class=special>};
-</span></pre></code>
-<p>
-We can expose this to Python by writing a corresponding Boost.Python
-C++ Wrapper:</p>
-<code><pre>
-    <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>BOOST_PYTHON_MODULE</span><span class=special>(</span><span class=identifier>hello</span><span class=special>)
-    </span><span class=special>{
-        </span><span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>World</span><span class=special>&gt;(</span><span class=string>&quot;World&quot;</span><span class=special>)
-            </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;greet&quot;</span><span class=special>, </span><span class=special>&amp;</span><span class=identifier>World</span><span class=special>::</span><span class=identifier>greet</span><span class=special>)
-            </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;set&quot;</span><span class=special>, </span><span class=special>&amp;</span><span class=identifier>World</span><span class=special>::</span><span class=identifier>set</span><span class=special>)
-        </span><span class=special>;
-    </span><span class=special>}
-</span></pre></code>
-<p>
-Here, we wrote a C++ class wrapper that exposes the member functions
-<tt>greet</tt> and <tt>set</tt>. Now, after building our module as a shared library, we
-may use our class <tt>World</tt> in Python. Here's a sample Python session:</p>
-<code><pre>
-    <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>planet </span><span class=special>= </span><span class=identifier>hello</span><span class=special>.</span><span class=identifier>World</span><span class=special>()
-    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>planet</span><span class=special>.</span><span class=identifier>set</span><span class=special>(</span><span class=literal>'howdy'</span><span class=special>)
-    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>planet</span><span class=special>.</span><span class=identifier>greet</span><span class=special>()
-    </span><span class=literal>'howdy'
-</span></pre></code>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="building_hello_world.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="constructors.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/extracting_c___objects.html

@@ -1,79 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Extracting C++ objects</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="derived_object_types.html">
-<link rel="next" href="enums.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Extracting C++ objects</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="derived_object_types.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="enums.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<p>
-At some point, we will need to get C++ values out of object instances. This
-can be achieved with the <tt>extract&lt;T&gt;</tt> function. Consider the following:</p>
-<code><pre>
-    <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>&quot;length&quot;</span><span class=special>); </span><span class=comment>// compile error
-</span></pre></code>
-<p>
-In the code above, we got a compiler error because Boost.Python
-<tt>object</tt> can't be implicitly converted to <tt>double</tt>s. Instead, what
-we wanted to do above can be achieved by writing:</p>
-<code><pre>
-    <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>&quot;length&quot;</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></code>
-<p>
-The first line attempts to extract the &quot;length&quot; attribute of the
-Boost.Python <tt>object</tt> <tt>o</tt>. The second line attempts to <i>extract</i> the
-<tt>Vec2</tt> object from held by the Boost.Python <tt>object</tt> <tt>o</tt>.</p>
-<p>
-Take note that we said &quot;attempt to&quot; above. What if the Boost.Python
-<tt>object</tt> <tt>o</tt> does not really hold a <tt>Vec2</tt> type? This is certainly
-a possibility considering the dynamic nature of Python <tt>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>
-<code><pre>
-    <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></code>
-<p>
-<img src="theme/bulb.gif"></img> The astute reader might have noticed that the <tt>extract&lt;T&gt;</tt>
-facility in fact solves the mutable copying problem:</p>
-<code><pre>
-    <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>&quot;__dict__&quot;</span><span class=special>));
-    </span><span class=identifier>d</span><span class=special>[</span><span class=literal>'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></pre></code>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="derived_object_types.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="enums.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/functions.html

@@ -1,73 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Functions</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="class_operators_special_functions.html">
-<link rel="next" href="call_policies.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Functions</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="class_operators_special_functions.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="call_policies.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<p>
-In this chapter, we'll look at Boost.Python powered functions in closer
-detail. We shall see some facilities to make exposing C++ functions to
-Python safe from potential pifalls such as dangling pointers and
-references. We shall also see facilities that will make it even easier for
-us to expose C++ functions that take advantage of C++ features such as
-overloading and default arguments.</p>
-<blockquote><p><i>Read on...</i></p></blockquote><p>
-But before you do, you might want to fire up Python 2.2 or later and type
-<tt>&gt;&gt;&gt; import this</tt>.</p>
-<code><pre>
-    &gt;&gt;&gt; import this
-    The Zen of Python, by Tim Peters
-    Beautiful is better than ugly.
-    Explicit is better than implicit.
-    Simple is better than complex.
-    Complex is better than complicated.
-    Flat is better than nested.
-    Sparse is better than dense.
-    Readability counts.
-    Special cases aren't special enough to break the rules.
-    Although practicality beats purity.
-    Errors should never pass silently.
-    Unless explicitly silenced.
-    In the face of ambiguity, refuse the temptation to guess.
-    There should be one-- and preferably only one --obvious way to do it
-    Although that way may not be obvious at first unless you're Dutch.
-    Now is better than never.
-    Although never is often better than *right* now.
-    If the implementation is hard to explain, it's a bad idea.
-    If the implementation is easy to explain, it may be a good idea.
-    Namespaces are one honking great idea -- let's do more of those!
-</pre></code><table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="class_operators_special_functions.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="call_policies.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/inheritance.html

@@ -1,98 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Inheritance</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="class_properties.html">
-<link rel="next" href="class_virtual_functions.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Inheritance</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="class_properties.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="class_virtual_functions.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<p>
-In the previous examples, we dealt with classes that are not polymorphic.
-This is not often the case. Much of the time, we will be wrapping
-polymorphic classes and class hierarchies related by inheritance. We will
-often have to write Boost.Python wrappers for classes that are derived from
-abstract base classes.</p>
-<p>
-Consider this trivial inheritance structure:</p>
-<code><pre>
-    <span class=keyword>struct </span><span class=identifier>Base </span><span class=special>{ </span><span class=keyword>virtual </span><span class=special>~</span><span class=identifier>Base</span><span class=special>(); </span><span class=special>};
-    </span><span class=keyword>struct </span><span class=identifier>Derived </span><span class=special>: </span><span class=identifier>Base </span><span class=special>{};
-</span></pre></code>
-<p>
-And a set of C++ functions operating on <tt>Base</tt> and <tt>Derived</tt> object
-instances:</p>
-<code><pre>
-    <span class=keyword>void </span><span class=identifier>b</span><span class=special>(</span><span class=identifier>Base</span><span class=special>*);
-    </span><span class=keyword>void </span><span class=identifier>d</span><span class=special>(</span><span class=identifier>Derived</span><span class=special>*);
-    </span><span class=identifier>Base</span><span class=special>* </span><span class=identifier>factory</span><span class=special>() </span><span class=special>{ </span><span class=keyword>return </span><span class=keyword>new </span><span class=identifier>Derived</span><span class=special>; </span><span class=special>}
-</span></pre></code>
-<p>
-We've seen how we can wrap the base class <tt>Base</tt>:</p>
-<code><pre>
-    <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Base</span><span class=special>&gt;(</span><span class=string>&quot;Base&quot;</span><span class=special>)
-        </span><span class=comment>/*...*/
-        </span><span class=special>;
-</span></pre></code>
-<p>
-Now we can inform Boost.Python of the inheritance relationship between
-<tt>Derived</tt> and its base class <tt>Base</tt>.  Thus:</p>
-<code><pre>
-    <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Derived</span><span class=special>, </span><span class=identifier>bases</span><span class=special>&lt;</span><span class=identifier>Base</span><span class=special>&gt; </span><span class=special>&gt;(</span><span class=string>&quot;Derived&quot;</span><span class=special>)
-        </span><span class=comment>/*...*/
-        </span><span class=special>;
-</span></pre></code>
-<p>
-Doing so, we get some things for free:</p>
-<ol><li>Derived automatically inherits all of Base's Python methods (wrapped C++ member functions)</li><li><b>If</b> Base is polymorphic, <tt>Derived</tt> objects which have been passed to Python via a pointer or reference to <tt>Base</tt> can be passed where a pointer or reference to <tt>Derived</tt> is expected.</li></ol><p>
-Now, we shall expose the C++ free functions <tt>b</tt> and <tt>d</tt> and <tt>factory</tt>:</p>
-<code><pre>
-    <span class=identifier>def</span><span class=special>(</span><span class=string>&quot;b&quot;</span><span class=special>, </span><span class=identifier>b</span><span class=special>);
-    </span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;d&quot;</span><span class=special>, </span><span class=identifier>d</span><span class=special>);
-    </span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;factory&quot;</span><span class=special>, </span><span class=identifier>factory</span><span class=special>);
-</span></pre></code>
-<p>
-Note that free function <tt>factory</tt> is being used to generate new
-instances of class <tt>Derived</tt>. In such cases, we use
-<tt>return_value_policy&lt;manage_new_object&gt;</tt> to instruct Python to adopt
-the pointer to <tt>Base</tt> and hold the instance in a new Python <tt>Base</tt>
-object until the the Python object is destroyed. We shall see more of
-Boost.Python <a href="call_policies.html">
-call policies</a> later.</p>
-<code><pre>
-    <span class=comment>// Tell Python to take ownership of factory's result
-    </span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;factory&quot;</span><span class=special>, </span><span class=identifier>factory</span><span class=special>,
-        </span><span class=identifier>return_value_policy</span><span class=special>&lt;</span><span class=identifier>manage_new_object</span><span class=special>&gt;());
-</span></pre></code>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="class_properties.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="class_virtual_functions.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/iterators.html

@@ -1,101 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Iterators</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="enums.html">
-<link rel="next" href="exception_translation.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Iterators</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="enums.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="exception_translation.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<p>
-In C++, and STL in particular, we see iterators everywhere. Python also has
-iterators, but these are two very different beasts.</p>
-<p>
-<b>C++ iterators:</b></p>
-<ul><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><p>
-<b>Python Iterators:</b></p>
-<ul><li>1 category (forward)</li><li>1 operation category (next())</li><li>Raises StopIteration exception at end</li></ul><p>
-The typical Python iteration protocol: <tt><b>for y in x...</b></tt> is as follows:</p>
-<code><pre>
-    <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></pre></code>
-<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 __iter__ function from C++ iterators that is compatible
-with the Python iteration protocol. For example:</p>
-<code><pre>
-    <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></code>
-<p>
-Or for use in class_&lt;&gt;:</p>
-<code><pre>
-    <span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;__iter__&quot;</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></code>
-<p>
-<b>range</b></p>
-<p>
-We can create a Python savvy iterator using the range function:</p>
-<ul><li>range(start, finish)</li><li>range&lt;Policies,Target&gt;(start, finish)</li></ul><p>
-Here, start/finish may be one of:</p>
-<ul><li>member data pointers</li><li>member function pointers</li><li>adaptable function object (use Target parameter)</li></ul><p>
-<b>iterator</b></p>
-<ul><li>iterator&lt;T, Policies&gt;()</li></ul><p>
-Given a container <tt>T</tt>, iterator is a shortcut that simply calls <tt>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>
-<code><pre>
-    <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></pre></code>
-<p>
-Now, our C++ Wrapper:</p>
-<code><pre>
-    <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>F</span><span class=special>&gt;(</span><span class=string>&quot;Field&quot;</span><span class=special>)
-        </span><span class=special>.</span><span class=identifier>property</span><span class=special>(</span><span class=string>&quot;pions&quot;</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>&quot;bogons&quot;</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></code>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="enums.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="exception_translation.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/object_interface.html

@@ -1,54 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Object Interface</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="default_arguments.html">
-<link rel="next" href="basic_interface.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Object Interface</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="default_arguments.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="basic_interface.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<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>object</tt>. We shall see in
-this chapter how to deal with Python objects.</p>
-<p>
-As mentioned, one of the goals of Boost.Python is to provide a
-bidirectional mapping between C++ and Python while maintaining the Python
-feel. Boost.Python C++ <tt>object</tt>s are as close as possible to Python. This
-should minimize the learning curve significantly.</p>
-<p>
-<img src="theme/python.png"></img></p>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="default_arguments.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="basic_interface.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/quickstart.html

@@ -1,79 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>QuickStart</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="next" href="building_hello_world.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>QuickStart</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><img src="theme/l_arr_disabled.gif" border="0"></td>
-    <td width="20"><a href="building_hello_world.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<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="hello_world"></a><h2>Hello World</h2><p>
-Following C/C++ tradition, let's start with the &quot;hello, world&quot;. A C++
-Function:</p>
-<code><pre>
-    <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>&quot;hello, world&quot;</span><span class=special>;
-    </span><span class=special>}
-</span></pre></code>
-<p>
-can be exposed to Python by writing a Boost.Python wrapper:</p>
-<code><pre>
-    <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>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>&quot;greet&quot;</span><span class=special>, </span><span class=identifier>greet</span><span class=special>);
-    </span><span class=special>}
-</span></pre></code>
-<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>
-<code><pre>
-    <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></pre></code>
-<blockquote><p><i><b>Next stop... Building your Hello World module from start to finish...</b></i></p></blockquote><table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><img src="theme/l_arr_disabled.gif" border="0"></td>
-    <td width="20"><a href="building_hello_world.html"><img src="theme/r_arr.gif" border="0"></a></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/theme/style.css

@@ -1,170 +0,0 @@
-body
-{
-    background-image: url(bkd.gif);
-    background-color: #FFFFFF;
-    margin: 1em 2em 1em 2em;
-}
-
-h1 { font-family: Verdana, Arial, Helvetica, sans-serif; font-weight: bold; text-align: left;  }
-h2 { font: 140% sans-serif; font-weight: bold; text-align: left;  }
-h3 { font: 120% sans-serif; font-weight: bold; text-align: left;  }
-h4 { font: bold 100% sans-serif; font-weight: bold; text-align: left;  }
-h5 { font: italic 100% sans-serif; font-weight: bold; text-align: left;  }
-h6 { font: small-caps 100% sans-serif; font-weight: bold; text-align: left;  }
-
-pre
-{
-    border-top: gray 1pt solid;
-    border-right: gray 1pt solid;
-    border-left: gray 1pt solid;
-    border-bottom: gray 1pt solid;
-
-    padding-top: 2pt;
-    padding-right: 2pt;
-    padding-left: 2pt;
-    padding-bottom: 2pt;
-
-    display: block;
-    font-family: "courier new", courier, mono;
-    background-color: #eeeeee; font-size: small
-}
-
-code
-{
-    font-family: "Courier New", Courier, mono;
-    font-size: small
-}
-
-tt
-{
-    display: inline;
-    font-family: "Courier New", Courier, mono;
-    color: #000099;
-    font-size: small
-}
-
-p
-{
-    text-align: justify;
-    font-family: Georgia, "Times New Roman", Times, serif
-}
-
-ul
-{
-    list-style-image: url(bullet.gif);
-    font-family: Georgia, "Times New Roman", Times, serif
-}
-
-ol
-{
-    font-family: Georgia, "Times New Roman", Times, serif
-}
-
-a
-{
-    font-weight: bold;
-    color: #003366;
-    text-decoration: none;
-}
-
-a:hover { color: #8080FF; }
-
-.literal        {  color: #666666; font-style: italic}
-.keyword        {  color: #000099}
-.identifier     {}
-.comment        {  font-style: italic; color: #990000}
-.special        {  color: #800040}
-.preprocessor   {  color: #FF0000}
-.string         {  font-style: italic; color: #666666}
-.copyright      {  color: #666666; font-size: small}
-.white_bkd      {  background-color: #FFFFFF}
-.dk_grey_bkd    {  background-color: #999999}
-.quotes         {  color: #666666; font-style: italic; font-weight: bold}
-
-.note_box
-{
-    display: block;
-
-    border-top: gray 1pt solid;
-    border-right: gray 1pt solid;
-    border-left: gray 1pt solid;
-    border-bottom: gray 1pt solid;
-
-    padding-right: 12pt;
-    padding-left: 12pt;
-    padding-bottom: 12pt;
-    padding-top: 12pt;
-
-    font-family: Arial, Helvetica, sans-serif;
-    background-color: #E2E9EF;
-    font-size: small; text-align: justify
-}
-
-.table_title
-{
-    background-color: #648CCA;
-
-    font-family: Verdana, Arial, Helvetica, sans-serif; color: #FFFFFF;
-    font-weight: bold
-; padding-top: 4px; padding-right: 4px; padding-bottom: 4px; padding-left: 4px
-}
-
-.table_cells
-{
-    background-color: #E2E9EF;
-
-    font-family: Geneva, Arial, Helvetica, san-serif;
-    font-size: small
-; padding-top: 4px; padding-right: 4px; padding-bottom: 4px; padding-left: 4px
-}
-
-.toc
-{
-    DISPLAY: block;
-    background-color: #E2E9EF
-    font-family: Arial, Helvetica, sans-serif;
-
-    border-top: gray 1pt solid;
-    border-left: gray 1pt solid;
-    border-bottom: gray 1pt solid;
-    border-right: gray 1pt solid;
-
-    padding-top: 24pt;
-    padding-right: 24pt;
-    padding-left: 24pt;
-    padding-bottom: 24pt;
-}
-
-.toc_title
-{
-    background-color: #648CCA;
-    padding-top: 4px;
-    padding-right: 4px;
-    padding-bottom: 4px;
-    padding-left: 4px;
-    font-family: Geneva, Arial, Helvetica, san-serif;
-    color: #FFFFFF;
-    font-weight: bold
-}
-
-.toc_cells
-{
-    background-color: #E2E9EF;
-    padding-top: 4px;
-    padding-right: 4px;
-    padding-bottom: 4px;
-    padding-left: 4px;
-    font-family: Geneva, Arial, Helvetica, san-serif;
-    font-size: small
-}
-
-div.logo
-{
-	float: right;
-}
-
-.toc_cells_L0 { background-color: #E2E9EF; padding-top: 4px; padding-right: 4px; padding-bottom: 4px; padding-left: 4px; font-family: Geneva, Arial, Helvetica, san-serif; font-size: small }
-.toc_cells_L1 { background-color: #E2E9EF; padding-top: 4px; padding-right: 4px; padding-bottom: 4px; padding-left: 44px; font-family: Geneva, Arial, Helvetica, san-serif; font-size: small }
-.toc_cells_L2 { background-color: #E2E9EF; padding-top: 4px; padding-right: 4px; padding-bottom: 4px; padding-left: 88px; font-family: Geneva, Arial, Helvetica, san-serif; font-size: small }
-.toc_cells_L3 { background-color: #E2E9EF; padding-top: 4px; padding-right: 4px; padding-bottom: 4px; padding-left: 122px; font-family: Geneva, Arial, Helvetica, san-serif; font-size: small }
-.toc_cells_L4 { background-color: #E2E9EF; padding-top: 4px; padding-right: 4px; padding-bottom: 4px; padding-left: 166px; font-family: Geneva, Arial, Helvetica, san-serif; font-size: small }

doc/tutorial/index.html

@@ -1,126 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Boost Python Tutorial</title>
-<link rel="stylesheet" href="doc/theme/style.css" type="text/css">
-<link rel="next" href="quickstart.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="doc/theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%">
-      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Boost Python Tutorial</b></font>
-    </td>
-  </tr>
-</table>
-<br>
-<table width="80%" border="0" align="center">
-  <tr>
-    <td class="toc_title">Table of contents</td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L0">
-        <a href="doc/quickstart.html">QuickStart</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L0">
-        <a href="doc/building_hello_world.html">Building Hello World</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L0">
-        <a href="doc/exposing_classes.html">Exposing Classes</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L1">
-        <a href="doc/constructors.html">Constructors</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L1">
-        <a href="doc/class_data_members.html">Class Data Members</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L1">
-        <a href="doc/class_properties.html">Class Properties</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L1">
-        <a href="doc/inheritance.html">Inheritance</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L1">
-        <a href="doc/class_virtual_functions.html">Class Virtual Functions</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L1">
-        <a href="doc/class_operators_special_functions.html">Class Operators/Special Functions</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L0">
-        <a href="doc/functions.html">Functions</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L1">
-        <a href="doc/call_policies.html">Call Policies</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L1">
-        <a href="doc/default_arguments.html">Default Arguments</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L0">
-        <a href="doc/object_interface.html">Object Interface</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L1">
-        <a href="doc/basic_interface.html">Basic Interface</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L1">
-        <a href="doc/derived_object_types.html">Derived Object types</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L1">
-        <a href="doc/extracting_c___objects.html">Extracting C++ objects</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L1">
-        <a href="doc/enums.html">Enums</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L0">
-        <a href="doc/iterators.html">Iterators</a>
-    </td>
-  </tr>
-  <tr>
-    <td class="toc_cells_L0">
-        <a href="doc/exception_translation.html">Exception Translation</a>
-    </td>
-  </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/under-the-hood.html

@@ -0,0 +1,61 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
+    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+    <title>
+      A Peek Under the Hood
+    </title>
+    <h1>
+      <img src="../../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center"
+      width="277" height="86">
+    </h1>
+    <h1>
+      A Peek Under the Hood
+    </h1>
+    <p>
+      Declaring a <code>class_builder&lt;T&gt;</code> causes the instantiation
+      of an <code>extension_class&lt;T&gt;</code> to which it forwards all
+      member function calls and which is doing most of the real work.
+      <code>extension_class&lt;T&gt;</code> is a subclass of <code>
+      PyTypeObject</code>, the <code> struct</code> which Python's 'C' API uses
+      to describe a type. <a href="example1.html#world_class">An instance of the
+      <code>extension_class&lt;&gt;</code></a> becomes the Python type object
+      corresponding to <code>hello::world</code>. When we <a href=
+      "example1.html#add_world_class">add it to the module</a> it goes into the
+      module's dictionary to be looked up under the name "world".
+    <p>
+      Boost.Python uses C++'s template argument deduction mechanism to determine the
+      types of arguments to functions (except constructors, for which we must
+      <a href="example1.html#Constructor_example">provide an argument list</a>
+      because they can't be named in C++). Then, it calls the appropriate
+      overloaded functions <code>PyObject*
+      to_python(</code><em>S</em><code>)</code> and <em>
+      S'</em><code>from_python(PyObject*,
+      type&lt;</code><em>S</em><code>&gt;)</code> which convert between any C++
+      type <em>S</em> and a <code>PyObject*</code>, the type which represents a
+      reference to any Python object in its 'C' API. The <a href= 
+      "example1.html#world_class"><code>extension_class&lt;T&gt;</code></a>
+      template defines a whole raft of these conversions (for <code>T, T*,
+      T&amp;, std::auto_ptr&lt;T&gt;</code>, etc.), using the same inline
+      friend function technique employed by <a href="../../utility/operators.htm">the boost operators
+      library</a>.
+    <p>
+      Because the <code>to_python</code> and <code>from_python</code> functions
+      for a user-defined class are defined by <code>
+      extension_class&lt;T&gt;</code>, it is important that an instantiation of
+      <code> extension_class&lt;T&gt;</code> is visible to any code which wraps
+      a C++ function with a <code>T, T*, const T&amp;</code>, etc. parameter or
+      return value. In particular, you may want to create all of the classes at
+      the top of your module's init function, then <code>def</code> the member
+      functions later to avoid problems with inter-class dependencies.
+    <p>
+      Next: <a href="building.html">Building a Module with Boost.Python</a>
+      Previous: <a href="special.html">Special Method and Operator Support</a>
+      Up: <a href="index.html">Top</a>
+    <p>
+      &copy; Copyright David Abrahams 2000. Permission to copy, use, modify,
+      sell and distribute this document is granted provided this copyright
+      notice appears in all copies. This document is provided "as is" without
+      express or implied warranty, and with no claim as to its suitability for
+      any purpose.
+    <p>
+      Updated: Nov 26, 2000
+

doc/v2/CallPolicies.html

@@ -1,152 +1,124 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
 <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">
-
-    <title>Boost.Python - CallPolicies Concept</title>
-  </head>
-
-  <body link="#0000ff" vlink="#800080">
-    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<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 - CallPolicies Concept</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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">CallPolicies Concept</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<dl class="page-index"> 
+  <dt><a href="#introduction">Introduction</a></dt>
+  <dt><a href="#composition">CallPolicies Composition</a></dt>
+  <dt><a href="#concept-requirements">Concept Requirements</a></dt>
+  <dl class="page-index"> 
+    <dt><a href="#CallPolicies-concept">CallPolicies Concept</a></dt>
+  </dl>
+</dl>
 
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+<h2><a name="introduction"></a>Introduction</h2>
 
-          <h2 align="center">CallPolicies Concept</h2>
-        </td>
-      </tr>
-    </table>
-    <hr>
+<p>Models of the CallPolicies concept are used to specialize the
+behavior of Python callable objects generated by Boost.Python to
+wrapped C++ objects like function and member function
+pointers, providing three behaviors:
+<ol>
+<li> <code>precall</code> - Python argument tuple management before
+the wrapped object is invoked
+<li> <code>result_converter</code> - C++ return value handling
+<li> <code>postcall</code> - Python argument tuple and result
+management after the wrapped object is invoked
+</ol>
 
-    <dl class="page-index">
-      <dt><a href="#introduction">Introduction</a></dt>
+<h2><a name="composition"></a>CallPolicies Composition</h2>
 
-      <dt><a href="#composition">CallPolicies Composition</a></dt>
+In order to allow the use of multiple models of CallPolicies in the
+same callable object, Boost.Python's CallPolicies class templates
+provide a chaining interface which allows them to be recursively
+composed. This interface takes the form of an optional template
+parameter, <code>Base</code> which defaults to <a
+href="default_call_policies.html#default_call_policies-spec">
+<code>default_call_policies</code></a>.  By convention, the
+<code>precall</code> function of the
+<code>Base</code> is invoked <i>after</i> the <code>precall</code>
+function supplied by the outer template, and the <code>postcall</code>
+function of the <code>Base</code> is invoked <i>before</i> the
+<code>postcall</code> function of the outer template. If a
+<code>result_converter</code> is supplied by the outer template, it
+<i>replaces</i> any <code>result_converter</code> supplied by the
+<code>Base</code>. For an example, see <a
+href="return_internal_reference.html#return_internal_reference-spec">
+<code>return_internal_reference</code></a>.
 
-      <dt><a href="#concept-requirements">Concept Requirements</a></dt>
+<h2><a name="concept-requirements"></a>Concept Requirements</h2>
+<h3><a name="CallPolicies-concept"></a>CallPolicies Concept</h3>
 
-      <dd>
-        <dl class="page-index">
-          <dt><a href="#CallPolicies-concept">CallPolicies Concept</a></dt>
-        </dl>
-      </dd>
-    </dl>
+<p>In the table below, <code><b>x</b></code> denotes an object whose
+type <code><b>P</b></code> is a model of CallPolicies,
+<code><b>a</b></code> denotes a <code>PyObject*</code> pointing to
+a Python argument tuple object, and <code><b>r</b></code> denotes a
+<code>PyObject*</code> referring to a &quot;preliminary&quot; result
+object.
 
-    <h2><a name="introduction"></a>Introduction</h2>
+<table summary="CallPolicies expressions" border="1" cellpadding="5">
 
-    <p>Models of the CallPolicies concept are used to specialize the behavior
-    of Python callable objects generated by Boost.Python to wrapped C++
-    objects like function and member function pointers, providing three
-    behaviors:</p>
+  <tr> 
+    <td><b>Expression</b></td>
+    <td><b>Type</b></td>
+    <td><b>Result/Semantics</b></td>
+  </tr>
 
-    <ol>
-      <li><code>precall</code> - Python argument tuple management before the
-      wrapped object is invoked</li>
+  <tr> 
+    <td valign="top"><code>x.precall(a)</code></td>
+    <td>convertible  to <code>bool</code>
+    <td>returns <code>false</code> and <code><a
+    href="http://www.python.org/doc/2.2/api/exceptionHandling.html#l2h-71">PyErr_Occurred</a>()&nbsp;!=&nbsp;0</code>
+    upon failure, <code>true</code> otherwise.
 
-      <li><code>result_converter</code> - C++ return value handling</li>
+  <tr> 
+    <td valign="top"><code>P::result_converter</code></td>
+    <td>A model of <a href="ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a>.
+    <td>An MPL unarymetafunction object used produce the
+    &quot;preliminary&quot result object.
 
-      <li><code>postcall</code> - Python argument tuple and result management
-      after the wrapped object is invoked</li>
-    </ol>
+  <tr> 
+    <td valign="top"><code>x.postcall(a, r)</code></td>
+    <td>convertible  to <code>PyObject*</code>
+    <td>0 <code>0</code> and <code><a
+    href="http://www.python.org/doc/2.2/api/exceptionHandling.html#l2h-71">PyErr_Occurred</a>()&nbsp;!=&nbsp;0</code>
+    upon failure. Must &quot;conserve references&quot; even in the
+    event of an exception. In other words, if <code>r</code> is not
+    returned, its reference count must be decremented; if another
+    existing object is returned, its reference count must be
+    incremented.
+</table>
 
-    <h2><a name="composition"></a>CallPolicies Composition</h2>
-    In order to allow the use of multiple models of CallPolicies in the same
-    callable object, Boost.Python's CallPolicies class templates provide a
-    chaining interface which allows them to be recursively composed. This
-    interface takes the form of an optional template parameter,
-    <code>Base</code> which defaults to <a href=
-    "default_call_policies.html#default_call_policies-spec"><code>default_call_policies</code></a>.
-    By convention, the <code>precall</code> function of the <code>Base</code>
-    is invoked <i>after</i> the <code>precall</code> function supplied by the
-    outer template, and the <code>postcall</code> function of the
-    <code>Base</code> is invoked <i>before</i> the <code>postcall</code>
-    function of the outer template. If a <code>result_converter</code> is
-    supplied by the outer template, it <i>replaces</i> any
-    <code>result_converter</code> supplied by the <code>Base</code>. For an
-    example, see <a href=
-    "return_internal_reference.html#return_internal_reference-spec"><code>return_internal_reference</code></a>.
-    
+Models of CallPolicies are required to be <a
+href="../../../utility/CopyConstructible.html">CopyConstructible</a>.
 
-    <h2><a name="concept-requirements"></a>Concept Requirements</h2>
+<hr>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  19 May, 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>
 
-    <h3><a name="CallPolicies-concept"></a>CallPolicies Concept</h3>
-
-    <p>In the table below, <code><b>x</b></code> denotes an object whose type
-    <code><b>P</b></code> is a model of CallPolicies, <code><b>a</b></code>
-    denotes a <code>PyObject*</code> pointing to a Python argument tuple
-    object, and <code><b>r</b></code> denotes a <code>PyObject*</code>
-    referring to a "preliminary" result object.</p>
-
-    <table summary="CallPolicies expressions" border="1" cellpadding="5">
-      <tr>
-        <td><b>Expression</b></td>
-
-        <td><b>Type</b></td>
-
-        <td><b>Result/Semantics</b></td>
-      </tr>
-
-      <tr>
-        <td valign="top"><code>x.precall(a)</code></td>
-
-        <td>convertible to <code>bool</code></td>
-
-        <td>returns <code>false</code> and <code><a href=
-        "http://www.python.org/doc/2.2/api/exceptionHandling.html#l2h-71">PyErr_Occurred</a>()&nbsp;!=&nbsp;0</code>
-        upon failure, <code>true</code> otherwise.</td>
-      </tr>
-
-      <tr>
-        <td valign="top"><code>P::result_converter</code></td>
-
-        <td>A model of <a href=
-        "ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a>.</td>
-
-        <td>An MPL unary <a href=
-        "../../../mpl/doc/paper/html/usage.html#metafunctions.classes">Metafunction
-        Class</a> used produce the "preliminary" result object.</td>
-      </tr>
-
-      <tr>
-        <td valign="top"><code>x.postcall(a, r)</code></td>
-
-        <td>convertible to <code>PyObject*</code></td>
-
-        <td>0 <code>0</code> and <code><a href=
-        "http://www.python.org/doc/2.2/api/exceptionHandling.html#l2h-71">PyErr_Occurred</a>()&nbsp;!=&nbsp;0</code>
-        upon failure. Must "conserve references" even in the event of an
-        exception. In other words, if <code>r</code> is not returned, its
-        reference count must be decremented; if another existing object is
-        returned, its reference count must be incremented.</td>
-      </tr>
-    </table>
-    Models of CallPolicies are required to be <a href=
-    "../../../utility/CopyConstructible.html">CopyConstructible</a>. 
-    <hr>
-
-    <p>Revised 
-    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     19 May, 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>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>
-  </body>
+<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.
+</body>
 </html>
-

doc/v2/ObjectWrapper.html

@@ -1,155 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<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">
-
-    <title>Boost.Python - ObjectWrapper Concept</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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
-
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
-
-          <h2 align="center">ObjectWrapper and TypeWrapper Concepts</h2>
-        </td>
-      </tr>
-    </table>
-    <hr>
-
-    <dl class="page-index">
-      <dt><a href="#introduction">Introduction</a></dt>
-
-      <dt><a href="#concept-requirements">Concept Requirements</a></dt>
-
-      <dd>
-        <dl class="page-index">
-          <dt><a href="#ObjectWrapper-concept">ObjectWrapper Concept</a></dt>
-
-          <dt><a href="#TypeWrapper-concept">TypeWrapper Concept</a></dt>
-        </dl>
-      </dd>
-
-      <dt><a href="#caveat">Caveat</a></dt>
-    </dl>
-
-    <h2><a name="introduction"></a>Introduction</h2>
-
-    <p>This page defines two concepts used to describe classes which manage a
-    Python objects, and which are intended to support usage with a
-    Python-like syntax.</p>
-
-    <h2><a name="concept-requirements"></a>Concept Requirements</h2>
-
-    <h3><a name="ObjectWrapper-concept"></a>ObjectWrapper Concept</h3>
-    Models of the ObjectWrapper concept have <a href=
-    "object.html#object-spec">object</a> as a publicly-accessible base class,
-    and are used to supply special construction behavior and/or additional
-    convenient functionality through (often templated) member functions.
-    Except when the return type <code>R</code> is itself an <a href=
-    "#TypeWrapper-concept">TypeWrapper</a>, a member function invocation of
-    the form 
-<pre>
-x.<i>some_function</i>(<i>a<small>1</small>, a<small>2</small>,...a<small>n</small></i>)
-</pre>
-    always has semantics equivalent to: 
-<pre>
-<a href=
-"extract.html#extract-spec">extract</a>&lt;R&gt;(x.attr("<i>some_function</i>")(<a
- href=
-"object.html#object-spec-ctors">object</a>(<i>a<small>1</small></i>), <a
-href=
-"object.html#object-spec-ctors">object</a>(<i>a<small>2</small></i>),...<a
-href="object.html#object-spec-ctors">object</a>(<i>a<small>n</small></i>)))()
-</pre>
-    When the <code>R</code> is an <a href=
-    "#TypeWrapper-concept">TypeWrapper</a>, the result type may be
-    constructed by taking direct posession of: 
-<pre>
-x.attr("<i>some_function</i>")(<a href=
-"object.html#object-spec-ctors">object</a>(<i>a<small>1</small></i>), <a
- href=
-"object.html#object-spec-ctors">object</a>(<i>a<small>2</small></i>),...<a
- href=
-"object.html#object-spec-ctors">object</a>(<i>a<small>n</small></i>)).ptr()
-</pre>
-    [see <a href="#caveat">caveat</a> below] 
-
-    <h3><a name="TypeWrapper-concept"></a>TypeWrapper Concept</h3>
-    TypeWrapper is a refinement of ObjectWrapper which is associated with a
-    particular Python type <code>X</code>. For a given TypeWrapper
-    <code>T</code>, a valid constructor expression 
-<pre>
-T(<i>a<small>1</small>, a<small>2</small>,...a<small>n</small></i>)
-</pre>
-    builds a new <code>T</code> object managing the result of invoking
-    <code>X</code> with arguments corresponding to 
-<pre>
-<a href=
-"object.html#object-spec-ctors">object</a>(<i>a<small>1</small></i>), <a
- href=
-"object.html#object-spec-ctors">object</a>(<i>a<small>2</small></i>),...<a
- href=
-"object.html#object-spec-ctors">object</a>(<i>a<small>n</small></i>)
-</pre>
-
-When used as arguments to wrapped C++ functions, or as the template
-parameter to <code><a
-href="extract.html#extract-spec">extract</a>&lt;&gt;</code>, only
-instances of the associated Python type will be considered a match.
-
-    <h3><a name="caveat">Caveat</a></h3>
-    The upshot of the special member function invocation rules when the
-    return type is a TypeWrapper is that it is possible for the returned
-    object to manage a Python object of an inappropriate type. This is not
-    usually a serious problem; the worst-case result is that errors will be
-    detected at runtime a little later than they might otherwise be. For an
-    example of how this can occur, note that the <code><a href=
-    "dict.html#dict-spec">dict</a></code> member function <code>items</code>
-    returns an object of type <code><a href=
-    "list.html#list-spec">list</a></code>. Now suppose the user defines this
-    <code>dict</code> subclass in Python: 
-<pre>
-&gt;&gt;&gt; class mydict(dict):
-...     def items(self):
-...         return tuple(dict.items(self)) # return a tuple
-</pre>
-    Since an instance of <code>mydict</code> is also an instance of
-    <code>dict</code>, when used as an argument to a wrapped C++ function,
-    <code><a href="dict.html#dict-spec">boost::python::dict</a></code> can
-    accept objects of Python type <code>mydict</code>. Invoking
-    <code>items()</code> on this object can result in an instance of <code><a
-    href="list.html#list-spec">boost::python::list</a></code> which actually
-    holds a Python tuple. Subsequent attempts to use list methods (e.g.
-    <code>append</code>, or any other mutating operation) on this object will
-    raise the same exception that would occur if you tried to do it from
-    Python. 
-    <hr>
-
-    <p>Revised 
-    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     30 Sept, 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>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>
-  </body>
-</html>
-

doc/v2/acknowledgments.html

@@ -1,103 +1,32 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
 <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">
-
-    <title>Boost.Python - Acknowledgments</title>
-  </head>
-
-  <body link="#0000ff" vlink="#800080">
-    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<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 - Acknowledgments</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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
-
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
-
-          <h2 align="center">Acknowledgments</h2>
-        </td>
-      </tr>
-    </table>
-    <hr>
-
-    <p><a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> is
-    the architect, designer, and implementor of <b>Boost.Python</b>.</p>
-
-    <p>Joel de Guzman implemented the <a href="overloads.html">default
-    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.
-    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
-    real-world insight into user requirements. Ralf has written some <a href=
-    "faq.html#question2">extensions</a> for converting C++ containers that I
-    hope will be incorporated into the library soon. He also implemented the
-    cross-module support in the first version of Boost.Python. More
-    importantly, Ralf makes sure nobody forgets the near-perfect synergy of
-    C++ and Python for solving the problems of large-scale software
-    construction.</p>
-
-    <p><a href="../../../../people/aleksey_gurtovoy.htm">Aleksey Gurtovoy</a>
-    wrote an incredible C++ <a href="http://www.mywikinet.com/mpl">Template
-    Metaprogramming Library</a> which allows Boost.Python to perform much of
-    its compile-time magic. In addition, Aleksey very generously contributed
-    his time and deep knowledge of the quirks of various buggy compilers to
-    help us get around problems at crucial moments.</p>
-
-    <p><a href="../../../../people/paul_mensonides.htm">Paul Mensonides</a>,
-    building on the work <a href="../../../../people/vesa_karvonen.htm">Vesa
-    Karvonen</a>, wrote a similarly amazing <a href=
-    "../../../preprocessor/doc/index.html">Preprocessor Metaprogramming
-    Library</a>, and generously contributed the time and expertise to get it
-    working in the Boost.Python library, rewriting much of Boost.Python to
-    use the new preproccessor metaprogramming constructs and helping us to
-    work around buggy and slow C++ preprocessors.</p>
-
-    <p><a href="mailto:achim@procoders.net">Achim Domma</a> contributed some
-    of the <a href="reference.html#object_wrappers">Object Wrappers</a> and
-    HTML templates for this documentation. Dave Hawkes contributed
-    inspiration for the use of the <code><a href=
-    "scope.html#scope-spec">scope</a></code> class to simplify module
-    definition syntax. Pearu Pearson wrote some of the test cases that are in
-    the current test suite.</p>
-
-    <p>Martin Casado solved some sticky problems which allow us to build the
-    Boost.Python shared library for AIX's crazy dynamic linking model.</p>
-
-    <p>The development of this version of Boost.Python was funded in part by
-    the <a href="http://www.llnl.gov/">Lawrence Livermore National
-    Laboratories</a> and by the <a href="http://cci.lbl.gov/">Computational
-    Crystallography Initiative</a> at Lawrence Berkeley National
-    Laboratories.</p>
-
-    <p><a href="http://kogs-www.informatik.uni-hamburg.de/~koethe/">Ullrich
-    Koethe</a> provided the implementation of inheritance and special
-    method/operator support in the first version of Boost.Python.</p>
-
-    <p>The first version of Boost.Python would not have been possible without
-    the support of Dragon Systems, which supported its development and
-    release as a Boost library.</p>
-    <hr>
-
-    <p>Revised 
-    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     08 October, 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>
+  <tr> 
+    <td valign="top" width="300"> 
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Acknowledgments</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+{{text}}
+<hr>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 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/args.html

@@ -1,103 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<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">
-
-    <title>Boost.Python - &lt;boost/python/args.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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
-
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
-
-          <h2 align="center">Header &lt;boost/python/args.hpp&gt;</h2>
-        </td>
-      </tr>
-    </table>
-    <hr>
-
-    <h2>Contents</h2>
-
-    <dl class="page-index">
-      <dt><a href="#introduction">Introduction</a></dt>
-
-      <dt><a href="#keyword-expression"><i>keyword-expressions</i></a></dt>
-
-      <dt><a href="#functions">Functions</a></dt>
-
-      <dd>
-        <dl class="page-index">
-          <dt><code><a href=
-          "#args-spec">args</a>(</code>...<code>)</code></dt>
-        </dl>
-      </dd>
-
-      <dt><a href="#examples">Example(s)</a></dt>
-    </dl>
-    <hr>
-
-    <h2><a name="introduction"></a>Introduction</h2>
-
-    <p>Supplies a family of overloaded functions for specifying argument
-    keywords for wrapped C++ functions.</p>
-
-    <h2><a name="keyword-expression"></a><i>keyword-expressions</i></h2>
-
-    <p>A <b>keyword-expression</b> results in an object which holds a
-    sequence of <a href="definitions.html#ntbs">ntbs</a>es, and whose type
-    encodes the number of keywords specified.</p>
-
-    <h2><a name="functions"></a>Functions</h2>
-
-    <h3><a name="args-spec"></a><code>args(</code>...<code>)</code></h3>
-<pre>
-<i>unspecified1</i> args(char const*);
-<i>unspecified2</i> args(char const*, char const*);
-   .
-   .
-   .
-<i>unspecifiedN</i> args(char const*, char const*, ... char const*);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> Every argument must be a <a href=
-      "definitions.html#ntbs">ntbs</a>.</dt>
-
-      <dt><b>Returns:</b> an object representing a <a href=
-      "#keyword-expression"><i>keyword-expression</i></a> encapsulating the
-      arguments passed.</dt>
-    </dl>
-
-    <h2><a name="examples"></a>Example</h2>
-<pre>
-#include &lt;boost/python/def.hpp&gt;
-using namespace boost::python;
-
-int f(int x, int y, int z);
-
-BOOST_PYTHON_MODULE(xxx)
-{
-   def("f", f, args("x", "y", "z"));
-}
-</pre>
-
-    <p>Revised 05 November, 2001</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_method.html

@@ -1,89 +1,74 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
 <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">
-
-    <title>Boost.Python - &lt;call_method.hpp&gt;</title>
-  </head>
-
-  <body link="#0000ff" vlink="#800080">
-    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<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;call_method.hpp&gt;</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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
+  <tr> 
+    <td valign="top" width="300"> 
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Header &lt;call_method.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>
+  <dl class="page-index">
+    <dt><a href="#call_method-spec">call_method</a></dt>
+  </dl>
 
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+  <dt><a href="#examples">Example(s)</a></dt>
 
-          <h2 align="center">Header &lt;call_method.hpp&gt;</h2>
-        </td>
-      </tr>
-    </table>
-    <hr>
+</dl>
+<hr>
+<h2><a name="introduction"></a>Introduction</h2>
+<p>
+  <code>&lt;boost/python/call_method.hpp&gt;</code> defines the <a
+  href="#call_method-spec"><code>call_method</code></a> family of overloaded function
+  templates, used to invoke callable attributes of Python objects from C++.
 
-    <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="#call_method-spec">call_method</a></dt>
-        </dl>
-      </dd>
-
-      <dt><a href="#examples">Example(s)</a></dt>
-    </dl>
-    <hr>
-
-    <h2><a name="introduction"></a>Introduction</h2>
-
-    <p><code>&lt;boost/python/call_method.hpp&gt;</code> defines the <a href=
-    "#call_method-spec"><code>call_method</code></a> family of overloaded
-    function templates, used to invoke callable attributes of Python objects
-    from C++.</p>
-
-    <h2><a name="functions"></a>Functions</h2>
+<h2><a name="functions"></a>Functions</h2>
 <pre>
-<a name=
-"call_method-spec">template &lt;class R, class A1, class A2, ... class A<i>n</i>&gt;</a>
+<a name="call_method-spec">template &lt;class R, class A1, class A2, ... class A<i>n</i>&gt;</a>
 R call_method(PyObject* self, char const* method, A1 const&amp;, A2 const&amp;, ... A<i>n</i> const&amp;)
 </pre>
+<dl class="function-semantics"> 
+  <dt><b>Requires:</b> <code>R</code> is a pointer type, reference
+  type, or a complete type with an accessible copy constructor</dt>
 
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> <code>R</code> is a pointer type, reference type,
-      or a complete type with an accessible copy constructor</dt>
+  <dt><b>Effects:</b> Invokes <code>self.<i>method</i>(a1,&nbsp;a2,&nbsp;...a<i>n</i>)</code> in
+  Python, where <code>a1</code>...<code>a<i>n</i></code> are the arguments to
+  <code>call_method()</code>, converted to Python objects. For a
+  complete semantic description, see <a href="callbacks.html">this
+  page</a>.
 
-      <dt><b>Effects:</b> Invokes
-      <code>self.<i>method</i>(a1,&nbsp;a2,&nbsp;...a<i>n</i>)</code> in
-      Python, where <code>a1</code>...<code>a<i>n</i></code> are the
-      arguments to <code>call_method()</code>, converted to Python objects.
-      For a complete semantic description, see <a href="callbacks.html">this
-      page</a>.</dt>
+  <dt><b>Returns:</b> The result of the Python call, converted to the
+  C++ type <code>R</code>.</dt>
 
-      <dt><b>Returns:</b> The result of the Python call, converted to the C++
-      type <code>R</code>.</dt>
+</dt>
+  <dt><b>Rationale:</b> <code>call_method</code> is critical to
+  implementing C++ virtual functions which are overridable in Python,
+  as shown by the example below.
+</dt>
+</dl>
 
-      <dt><b>Rationale:</b> <code>call_method</code> is critical to
-      implementing C++ virtual functions which are overridable in Python, as
-      shown by the example below.</dt>
-    </dl>
+<h2><a name="examples"></a>Example(s)</h2>
 
-    <h2><a name="examples"></a>Example(s)</h2>
-    The following C++ illustrates the use of <code>call_method</code> in
-    wrapping a class with a virtual function that can be overridden in
-    Python: 
+The following C++ illustrates the use of <code>call_method</code> in
+wrapping a class with a virtual function that can be overridden in
+Python:
 
-    <h3>C++ Module Definition</h3>
+<h3>C++ Module Definition</h3>
 <pre>
 #include &lt;boost/python/module.hpp&gt;
 #include &lt;boost/python/class.hpp&gt;
@@ -94,13 +79,13 @@ R call_method(PyObject* self, char const* method, A1 const&amp;, A2 const&amp;,
 class Base
 {
  public:
-   virtual char const* class_name() const { return "Base"; }
+   virtual char const* class_name() const { return &quot;Base&quot;; }
    virtual ~Base();
 };
 
 bool is_base(Base* b)
 {
-   return !std::strcmp(b-&gt;class_name(), "Base");
+   return !std::strcmp(b-&gt;class_name(), &quot;Base&quot;);
 }
 
 // Wrapper code begins here
@@ -112,25 +97,26 @@ class Base_callback : public Base
  public:
    Base_callback(PyObject* self) : m_self(self) {}
 
-   char const* class_name() const { return <b>call_method</b>(m_self, "class_name"); }
+   char const* class_name() const { return <b>call_method</b>(m_self, &quot;class_name&quot;); }
    char const* Base_name() const { return Base::class_name(); }
  private:
-   PyObject* const m_self;
+   PyObject* m_self;
 };
 
 using namespace boost::python;
-BOOST_PYTHON_MODULE(my_module)
+BOOST_PYTHON_MODULE_INIT(my_module)
 {
-    def("is_base", is_base);
-
-    class_&lt;Base,Base_callback, noncopyable&gt;("Base")
-        .def("class_name", &amp;Base_callback::Base_name)
-        ;
-
+   module("my_module")
+      .def(&quot;is_base&quot;, is_base)
+      .add(
+         class_&lt;Base,Base_callback, noncopyable&gt;(&quot;Base&quot;)
+             .def(&quot;class_name&quot;, &#24;Base_callback::Base_name);
+         )
+       ;
 }
 </pre>
 
-    <h3>Python Code</h3>
+<h3>Python Code</h3>
 <pre>
 &gt;&gt;&gt; from my_module import *
 &gt;&gt;&gt; class Derived(Base):
@@ -144,15 +130,12 @@ BOOST_PYTHON_MODULE(my_module)
 &gt;&gt;&gt; is_base(Derived())
 0
 </pre>
-
-    <p>Revised 
-    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     28 Sept, 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>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  10 May, 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/callbacks.html

@@ -1,85 +1,62 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
 <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">
-
-    <title>Boost.Python - Calling Python Functions and Methods</title>
-  </head>
-
-  <body link="#0000ff" vlink="#800080">
-    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<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 - Calling Python Functions and Methods</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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
+  <tr> 
+    <td valign="top" width="300"> 
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Calling Python Functions and Methods</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<h2>Contents</h2>
+<dl class="page-index"> 
+  <dt><a href="#introduction">Introduction</a></dt>
+  <dt><a href="#argument_handling">Argument Handling</a></dt>
+  <dt><a href="#result_handling">Result Handling</a></dt>
+  <dt><a href="#result_handling">Rationale</a></dt>
+</dl>
+<hr>
 
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+<h2><a name="introduction">Introduction</a></h2>
+<p>
+Boost.Python provides two families of function templates,
+<code><a href="call.html#call-spec">call</a></code> and <code><a
+href="call_method.html#call_method-spec">call_method</a></code>, for
+invoking Python functions and methods respectively. The interface for
+calling a Python function object (or any Python callable object) looks
+like:
 
-          <h2 align="center">Calling Python Functions and Methods</h2>
-        </td>
-      </tr>
-    </table>
-    <hr>
-
-    <h2>Contents</h2>
-
-    <dl class="page-index">
-      <dt><a href="#introduction">Introduction</a></dt>
-
-      <dt><a href="#argument_handling">Argument Handling</a></dt>
-
-      <dt><a href="#result_handling">Result Handling</a></dt>
-
-      <dt><a href="#result_handling">Rationale</a></dt>
-    </dl>
-    <hr>
-
-    <h2><a name="introduction">Introduction</a></h2>
-    The simplest way to call a Python function from C++, given an <code><a
-    href="object.html#object-spec">object</a></code> instance <code>f</code>
-    holding the function, is simply to invoke its function call operator. 
-<pre>
-f("tea", 4, 2) // In Python: f('tea', 4, 2)
-</pre>
-    And of course, a method of an <code><a href=
-    "object.html#object-spec">object</a></code> instance <code>x</code> can
-    be invoked by using the function-call operator of the corresponding
-    attribute: 
-<pre>
-x.attr("tea")(4, 2); // In Python: x.tea(4, 2)
-</pre>
-
-    <p>If you don't have an <code>object</code> instance, Boost.Python
-    provides two families of function templates, <code><a href=
-    "call.html#call-spec">call</a></code> and <code><a href=
-    "call_method.html#call_method-spec">call_method</a></code>, for invoking
-    Python functions and methods respectively on <code>PyObject*</code>s. The
-    interface for calling a Python function object (or any Python callable
-    object) looks like:</p>
 <pre>
 call&lt;ResultType&gt;(callable_object, a1, a2... a<i>N</i>);
 </pre>
-    Calling a method of a Python object is similarly easy: 
+
+Calling a method of a Python object is similarly easy:
+
 <pre>
-call_method&lt;ResultType&gt;(self_object, "<i>method-name</i>", a1, a2... a<i>N</i>);
+call_method&lt;ResultType&gt;(self_object, &quot;<i>method-name</i>&quot;, a1, a2... a<i>N</i>);
 </pre>
-    This comparitively low-level interface is the one you'll use when
-    implementing C++ virtual functions that can be overridden in Python. 
 
-    <h2><a name="argument_handling">Argument Handling</a></h2>
 
-    <p>Arguments are converted to Python according to their type. By default,
-    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>
+<h2><a name="argument_handling">Argument Handling</a></h2>
+<p>
+
+Arguments are converted to Python according to their type. By default,
+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>:
+
 <pre>
 class X : boost::noncopyable
 {
@@ -92,160 +69,178 @@ void apply(PyObject* callable, X&amp; x)
    boost::python::call&lt;void&gt;(callable, boost::ref(x));
 }
 </pre>
-    In the table below, <code><b>x</b></code> denotes the actual argument
-    object and <code><b>cv</b></code> denotes an optional
-    <i>cv-qualification</i>: "<code>const</code>", "<code>volatile</code>",
-    or "<code>const volatile</code>". 
+
+In the table below, <code><b>x</b></code> denotes the actual argument
+object and <code><b>cv</b></code> denotes an optional
+<i>cv-qualification</i>: &quot;<code>const</code>&quot;,
+&quot;<code>volatile</code>&quot;, or &quot;<code>const
+volatile</code>&quot;.
 
     <table border="1" summary="class_ template parameters">
       <tr>
-        <th>Argument Type</th>
+        <th>Argument Type
 
-        <th>Behavior</th>
-      </tr>
+        <th>Behavior
 
       <tr>
         <td><code>T cv&amp;</code><br>
-         <code>T cv</code></td>
+        <code>T cv</code>
 
-        <td>The Python argument is created by the same means used for the
-        return value of a wrapped C++ function returning <code>T</code>. When
-        <code>T</code> is a class type, that normally means <code>*x</code>
-        is copy-constructed into the new Python object.</td>
-      </tr>
+        <td>The Python argument is created by the same means used 
+        for the return value of a wrapped C++ function returning
+        <code>T</code>. When
+        <code>T</code> is a class type, that normally means
+        <code>*x</code> is copy-constructed into the new Python
+        object. 
 
       <tr>
-        <td><code>T*</code></td>
+        <td><code>T*</code> 
 
-        <td>If <code>x&nbsp;==&nbsp;0</code>, the Python argument will be
-        <code><a href=
-        "http://www.python.org/doc/current/lib/bltin-null-object.html">None</a></code>.
-        Otherwise, the Python argument is created by the same means used for
-        the return value of a wrapped C++ function returning <code>T</code>.
-        When <code>T</code> is a class type, that normally means
-        <code>*x</code> is copy-constructed into the new Python object.</td>
-      </tr>
+        <td>If <code>x&nbsp;==&nbsp;0</code>, the Python argument will
+        be <code><a
+        href="http://www.python.org/doc/current/lib/bltin-null-object.html">None</a></code>. Otherwise,
+        the Python argument is created by the same means used for the
+        return value of a wrapped C++ function returning
+        <code>T</code>. When
+        <code>T</code> is a class type, that normally means
+        <code>*x</code> is copy-constructed into the new Python
+        object. 
 
       <tr>
-        <td><code><a href=
-        "../../../bind/ref.html#reference_wrapper">boost::reference_wrapper</a>&lt;T&gt;</code></td>
+        <td><code><a
+        href="../../../bind/ref.html#reference_wrapper">boost::reference_wrapper</a>&lt;T&gt; </code>
 
-        <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
-        holds a reference to the resulting object beyond the lifetime of
-        <code>*x.get()</code> <b>may result in a crash!</b></td>
-      </tr>
+        <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 holds a reference to the resulting object beyond
+        the lifetime of <code>*x.get()</code> <b>may result in a
+        crash!</b> 
 
       <tr>
-        <td><code><a href=
-        "ptr.html#pointer_wrapper-spec">pointer_wrapper</a>&lt;T&gt;</code></td>
+        <td><code><a
+        href="ptr.html#pointer_wrapper-spec">pointer_wrapper</a>&lt;T&gt;</code>
+
+        <td>If <code>x.get()&nbsp;==&nbsp;0</code>, the Python
+        argument will be <code><a
+        href="http://www.python.org/doc/current/lib/bltin-null-object.html">None</a></code>.
+        Otherwise, the Python argument contains a pointer to, rather
+        than a copy of, <code>*x.get()</code>. Note: failure to ensure
+        that no Python code holds a reference to the resulting object
+        beyond the lifetime of <code>*x.get()</code> <b>may result in
+        a crash!</b>  
 
-        <td>If <code>x.get()&nbsp;==&nbsp;0</code>, the Python argument will
-        be <code><a href=
-        "http://www.python.org/doc/current/lib/bltin-null-object.html">None</a></code>.
-        Otherwise, the Python argument contains a pointer to, rather than a
-        copy of, <code>*x.get()</code>. Note: failure to ensure that no
-        Python code holds a reference to the resulting object beyond the
-        lifetime of <code>*x.get()</code> <b>may result in a crash!</b></td>
-      </tr>
     </table>
 
-    <h2><a name="result_handling">Result Handling</a></h2>
-    In general, <code>call&lt;ResultType&gt;()</code> and
-    <code>call_method&lt;ResultType&gt;()</code> return
-    <code>ResultType</code> by exploiting all lvalue and rvalue
-    <code>from_python</code> converters registered for ResultType and
-    returning a copy of the result. However, when <code>ResultType</code> is
-    a pointer or reference type, Boost.Python searches only for lvalue
-    converters. To prevent dangling pointers and references, an exception
-    will be thrown if the Python result object has only a single reference
-    count. 
+<h2><a name="result_handling">Result Handling</a></h2>
 
-    <h2><a name="rationale">Rationale</a></h2>
-    In general, to get Python arguments corresponding to
-    <code>a1</code>...<code>a<i>N</i></code>, a new Python object must be
-    created for each one; should the C++ object be copied into that Python
-    object, or should the Python object simply hold a reference/pointer to
-    the C++ object? In general, the latter approach is unsafe, since the
-    called function may store a reference to the Python object somewhere. If
-    the Python object is used after the C++ object is destroyed, we'll crash
-    Python. 
+In general, <code>call&lt;ResultType&gt;()</code> and
+<code>call_method&lt;ResultType&gt;()</code> return
+<code>ResultType</code> by exploiting all lvalue and rvalue
+<code>from_python</code> converters registered for ResultType and
+returning a copy of the result. However, when
+<code>ResultType</code> is a pointer or reference type, Boost.Python
+searches only for lvalue converters. To prevent dangling pointers and
+references, an exception will be thrown if the Python result object
+has only a single reference count.
 
-    <p>In keeping with the philosophy that users on the Python side shouldn't
-    have to worry about crashing the interpreter, the default behavior is to
-    copy the C++ object, and to allow a non-copying behavior only if the user
-    writes <code><a href="../../../bind/ref.html">boost::ref</a>(a1)</code>
-    instead of a1 directly. At least this way, the user doesn't get dangerous
-    behavior "by accident". It's also worth noting that the non-copying
-    ("by-reference") behavior is in general only available for class types,
-    and will fail at runtime with a Python exception if used otherwise[<a
-    href="#1">1</a>].</p>
+<h2><a name="rationale">Rationale</a></h2>
 
-    <p>However, pointer types present a problem: one approach is to refuse to
-    compile if any aN has pointer type: after all, a user can always pass
-    <code>*aN</code> to pass "by-value" or <code>ref(*aN)</code> to indicate
-    a pass-by-reference behavior. However, this creates a problem for the
-    expected null pointer to <code>None</code> conversion: it's illegal to
-    dereference a null pointer value.</p>
+In general, to get Python arguments corresponding to
+<code>a1</code>...<code>a<i>N</i></code>, a new Python object must be
+created for each one; should the C++ object be copied into that Python
+object, or should the Python object simply hold a reference/pointer to
+the C++ object? In general, the latter approach is unsafe, since the
+called function may store a reference to the Python object
+somewhere. If the Python object is used after the C++ object is
+destroyed, we'll crash Python.
 
-    <p>The compromise I've settled on is this:</p>
+<p>In keeping with the philosophy that users on the Python side
+shouldn't have to worry about crashing the interpreter, the default
+behavior is to copy the C++ object, and to allow a non-copying
+behavior only if the user writes <code><a
+href="../../../bind/ref.html">boost::ref</a>(a1)</code> instead of a1
+directly. At least this way, the user doesn't get dangerous behavior
+&quot;by accident&quot;. It's also worth noting that the non-copying
+(&quot;by-reference&quot;) behavior is in general only available for
+class types, and will fail at runtime with a Python exception if used
+otherwise[<a href="#1">1</a>].
 
-    <ol>
-      <li>The default behavior is pass-by-value. If you pass a non-null
-      pointer, the pointee is copied into a new Python object; otherwise the
-      corresponding Python argument will be None.</li>
+<p>
+However, pointer types present a problem: one approach is to refuse
+to compile if any aN has pointer type: after all, a user can always pass
+<code>*aN</code> to pass &quot;by-value&quot; or <code>ref(*aN)</code>
+to indicate a pass-by-reference behavior. However, this creates a
+problem for the expected null pointer to
+<code>None</code> conversion: it's illegal to dereference a null
+pointer value.
 
-      <li>if you want by-reference behavior, use <code>ptr(aN)</code> if
-      <code>aN</code> is a pointer and <code>ref(aN)</code> otherwise. If a
-      null pointer is passed to <code>ptr(aN)</code>, the corresponding
-      Python argument will be <code>None</code>.</li>
-    </ol>
+<p>
 
-    <p>As for results, we have a similar problem: if <code>ResultType</code>
-    is allowed to be a pointer or reference type, the lifetime of the object
-    it refers to is probably being managed by a Python object. When that
-    Python object is destroyed, our pointer dangles. The problem is
-    particularly bad when the <code>ResultType</code> is char const* - the
-    corresponding Python String object is typically uniquely-referenced,
-    meaning that the pointer dangles as soon as <code>call&lt;char
-    const*&gt;(...)</code> returns.</p>
+The compromise I've settled on is this: 
 
-    <p>The old Boost.Python v1 deals with this issue by refusing to compile
-    any uses of <code>call&lt;char const*&gt;()</code>, but this goes both
-    too far and not far enough. It goes too far because there are cases where
-    the owning Python string object survives beyond the call (just for
-    instance, when it's the name of a Python class), and it goes not far
-    enough because we might just as well have the same problem with a
-    returned pointer or reference of any other type.</p>
+<ol>
+<li>The default behavior is pass-by-value. If you pass a non-null
+   pointer, the pointee is copied into a new Python object; otherwise
+   the corresponding Python argument will be None.
 
-    <p>In Boost.Python v2 this is dealt with by:</p>
+<li>if you want by-reference behavior, use <code>ptr(aN)</code> if
+   <code>aN</code> is a pointer and <code>ref(aN)</code> otherwise. If
+   a null pointer is passed to <code>ptr(aN)</code>, the corresponding
+   Python argument will be <code>None</code>.
+   </ol>
 
-    <ol>
-      <li>lifting the compile-time restriction on const char* callback
-      returns</li>
+<p>
+As for results, we have a similar problem: if <code>ResultType</code>
+is allowed to be a pointer or reference type, the lifetime of the
+object it refers to is probably being managed by a Python object. When
+that Python object is destroyed, our pointer dangles. The problem is
+particularly bad when the <code>ResultType</code> is char const* - the
+corresponding Python String object is typically uniquely-referenced,
+meaning that the pointer dangles as soon as <code>call&lt;char
+const*&gt;(...)</code> returns.
 
-      <li>detecting the case when the reference count on the result Python
-      object is 1 and throwing an exception inside of
-      <code>call&lt;U&gt;(...)</code> when <code>U</code> is a pointer or
-      reference type.</li>
-    </ol>
-    This should be acceptably safe because users have to explicitly specify a
-    pointer/reference for <code>U</code> in <code>call&lt;U&gt;</code>, and
-    they will be protected against dangles at runtime, at least long enough
-    to get out of the <code>call&lt;U&gt;(...)</code> invocation. 
-    <hr>
-    <a name="1">[1]</a> It would be possible to make it fail at compile-time
-    for non-class types such as int and char, but I'm not sure it's a good
-    idea to impose this restriction yet. 
+<p>
+The old Boost.Python v1 deals with this issue by refusing to compile
+any uses of <code>call&lt;char const*&gt;()</code>, but this goes both
+too far and not far enough. It goes too far because there are cases
+where the owning Python string object survives beyond the call (just
+for instance, when it's the name of a Python class), and it goes not
+far enough because we might just as well have the same problem with a
+returned pointer or reference of any other type.
 
-    <p>Revised 
-    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     17 April, 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-    </p>
+<p>
 
-    <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
-  </body>
+In Boost.Python v2 this is dealt with by:
+
+<ol>
+   <li> lifting the compile-time restriction on const
+    char* callback returns
+
+   
+   <li> detecting the case when the reference count on the result
+    Python object is 1 and throwing an exception inside of
+    <code>call&lt;U&gt;(...)</code> when <code>U</code> is a pointer
+    or reference type.
+</ol>
+
+This should be acceptably safe because users have to explicitly
+specify a pointer/reference for <code>U</code> in
+<code>call&lt;U&gt;</code>, and they will be protected against dangles
+at runtime, at least long enough to get out of the
+<code>call&lt;U&gt;(...)</code> invocation.
+
+<hr>
+
+<a name="1">[1]</a> It would be possible to make it fail at compile-time for non-class
+types such as int and char, but I'm not sure it's a good idea to impose
+this restriction yet.
+
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  17 April, 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/configuration.html

@@ -1,141 +1,91 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
 <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">
-
-    <title>Boost.Python - Configuration</title>
-  </head>
-
-  <body link="#0000ff" vlink="#800080">
-    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<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 - Configuration</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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
-
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
-
-          <h2 align="center">Configuration</h2>
-        </td>
-      </tr>
-    </table>
-    <hr>
-
-    <dl class="page-index">
-      <dt><a href="#introduction">Introduction</a></dt>
-
-      <dt><a href="#app-defined">Application Defined Macros</a></dt>
-
-      <dt><a href="#lib-defined-impl">Library Defined Implementation
-      Macros</a></dt>
-    </dl>
-
-    <h2><a name="introduction"></a>Introduction</h2>
-
-    <p><b>Boost.Python</b> uses several configuration macros in <a href=
-    "http://www.boost.org/libs/config/config.htm">&lt;boost/config.hpp&gt;</a>,
-    as well as configuration macros meant to be supplied by the application.
-    These macros are documented here.</p>
-
-    <h2><a name="app-defined"></a>Application Defined Macros</h2>
-
-    <p>These are the macros that may be defined by an application using
-    <b>Boost.Python</b>. Note that if you extend a strict interpretation of the C++
-    standard to cover dynamic libraries, using different values of these
-    macros when compiling different libraries (including extension modules
-    and the <b>Boost.Python</b> library itself) is a violation of the <a href=
-    "definitions.html#ODR">ODR</a>. However, we know of no C++
-    implementations on which this particular violation is detectable or
-    causes any problems.</p>
-
-    <table summary="application defined macros" width="100%" cellpadding=
-    "10">
-      <tr>
-        <th align="left"><b>Macro</b></td>
-
-        <th><b>Default</b></td>
-
-        <th align="left"><b>Meaning</b></td>
-      </tr>
-
-      <tr>
-        <td valign="top"><code>BOOST_PYTHON_MAX_ARITY</code></td>
-
-        <td valign="top" align="center">15</td>
-
-        <td valign="top">The maximum <a href="definitions.html#arity">arity</a> of any
-        function, member function, or constructor to be wrapped, invocation
-        of a <b>Boost.Python</b> function wich is specified as taking arguments
-        <code>x1,&nbsp;x2,</code>...<code>X</code><i>n</i>. This includes, in
-        particular, callback mechanisms such as <code><a href=
-        "object.html#object-spec">object</a>::operator()(</code>...<code>)</code>
-        or <code><a href=
-        "call_method.html#call_method-spec">call_method</a>&lt;R&gt;(</code>...<code>
-        )</code>.</td>
-      </tr>
-
-      <tr>
-        <td valign="top"><code>BOOST_PYTHON_MAX_BASES</code></td>
-
-        <td valign="top" align="center">10</td>
-
-        <td valign="top">The maximum number of template arguments to the <code><a href=
-        "class.html#bases-spec">bases</a>&lt;</code>...<code>&gt;</code>
-        class template, which is used to specify the bases of a wrapped C++
-        class..</td>
-      </tr>
-    </table>
-
-    <h2><a name="lib-defined-impl"></a>Library Defined Implementation
-    Macros</h2>
-
-    <p>These macros are defined by <b>Boost.Python</b> and are
-    implementation details of interest only to implementors and those porting
-    to new platforms.</p>
-
-    <table summary="library defined implementation macros" width="100%"
-    cellpadding="10">
-      <tr>
-        <th align="left"><b>Macro</b></td>
-
-        <th><b>Default</b></td>
-
-        <th align="left"><b>Meaning</b></td>
-      </tr>
-
-      <tr>
-        <td valign="top"><code>BOOST_PYTHON_TYPE_ID_NAME</code></td>
-
-        <td valign="top" align="center"><i>not&nbsp;defined</i></td>
-
-        <td valign="top">If defined, this indicates that the type_info comparison across
-        shared library boundaries does not work on this platform. In other
-        words, if shared-lib-1 passes <code>typeid(T)</code> to a function in
-        shared-lib-2 which compares it to <code>typeid(T)</code>, that
-        comparison may return <code>false</code>. If this macro is #defined,
-        Boost.Python uses and compares <code>typeid(T).name()</code> instead
-        of using and comparing the <code>std::type_info</code> objects
-        directly.</td>
-      </tr>
-    </table>
-    <hr>
-
-    <p>Revised 
-    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     04 October, 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>
+  <tr> 
+    <td valign="top" width="300"> 
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Configuration</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<dl class="page-index">
+  <dt><a href="#introduction">Introduction</a></dt>
+  <dt><a href="#app-defined">Application Defined Macros</a></dt>
+  <dt><a href="#lib-defined-public">Public Library Defined Macros</a></dt>
+  <dt><a href="#lib-defined-impl">Library Defined Implementation Macros</a></dt>
+</dl>
+<h2><a name="introduction"></a>Introduction</h2>
+<p>Boost.Python uses several configuration macros in <a href="http://www.boost.org/libs/config/config.htm">&lt;boost/config.hpp&gt;</a>, 
+  as well as configuration macros meant to be supplied by the application. These 
+  macros are documented here.</p>
+<h2><a name="app-defined"></a>Application Defined Macros</h2>
+<p>These are the macros that may be defined by an application using Boost.Python.</p>
+<table summary="application defined macros" cellspacing="10" width="100%">
+  <tr>
+    <td><b>Macro</b></td>
+    <td><b>Meaning</b></td>
+  </tr>
+  <tr>
+    <td>{{macro}}</td>
+	<td>{{meaning}}</td>
+  </tr>
+  <tr>
+    <td>{{macro}}</td>
+	<td>{{meaning}}</td>
+  </tr>
+</table>
+<h2><a name="lib-defined-public"></a>Public Library Defined Macros</h2>
+<p>These macros are defined by Boost.Python but are expected to be used by application 
+  code.</p>
+<table summary="public library defined macros" cellspacing="10" width="100%">
+  <tr>
+    <td><b>Macro</b></td>
+    <td><b>Meaning</b></td>
+  </tr>
+  <tr>
+    <td>{{macro}}</td>
+	<td>{{meaning}}</td>
+  </tr>
+  <tr>
+    <td>{{macro}}</td>
+	<td>{{meaning}}</td>
+  </tr>
+</table>
+<h2><a name="lib-defined-impl"></a>Library Defined Implementation Macros</h2>
+<p>These macros are defined by Boost.Python and are implementation details of interest 
+  only to implementers.</p>
+<table summary="library defined implementation macros" cellspacing="10" width="100%">
+  <tr>
+    <td><b>Macro</b></td>
+    <td><b>Meaning</b></td>
+  </tr>
+  <tr>
+    <td>{{macro}}</td>
+	<td>{{meaning}}</td>
+  </tr>
+  <tr>
+    <td>{{macro}}</td>
+	<td>{{meaning}}</td>
+  </tr>
+</table>
+<hr>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 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/copy_const_reference.html

@@ -1,58 +1,46 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-  <head>
-    <meta name="generator" content=
-    "HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
+    <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/copy_const_reference.hpp&gt;</title>
-  </head>
+    <title>Boost.Python - &lt;boost/python/copy_const_reference.hpp&gt;</title>
 
-  <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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
         <td valign="top">
           <h1 align="center">Boost.Python</h1>
 
           <h2 align="center">Header
           &lt;boost/python/copy_const_reference.hpp&gt;</h2>
-        </td>
-      </tr>
     </table>
     <hr>
 
     <h2>Contents</h2>
 
     <dl class="page-index">
-      <dt><a href="#classes">Classes</a></dt>
+      <dt><a href="#classes">Classes</a>
 
       <dd>
         <dl class="page-index">
           <dt><a href="#copy_const_reference-spec">Class
-          <code>copy_const_reference</code></a></dt>
+          <code>copy_const_reference</code></a>
 
           <dd>
             <dl class="page-index">
               <dt><a href="#copy_const_reference-spec-synopsis">Class
-              <code>copy_const_reference</code> synopsis</a></dt>
+              <code>copy_const_reference</code> synopsis</a>
 
               <dt><a href="#copy_const_reference-spec-metafunctions">Class
-              <code>copy_const_reference</code> metafunctions</a></dt>
+              <code>copy_const_reference</code> metafunctions</a>
             </dl>
-          </dd>
         </dl>
-      </dd>
 
-      <dt><a href="#examples">Example</a></dt>
+      <dt><a href="#examples">Example</a>
     </dl>
     <hr>
 
@@ -62,10 +50,9 @@
     <code>copy_const_reference</code></h3>
 
     <p><code>copy_const_reference</code> is a model of <a href=
-    "ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a>
-    which can be used to wrap C++ functions returning a reference-to-const
-    type such that the referenced value is copied into a new Python
-    object.</p>
+    "ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a> which can be
+    used to wrap C++ functions returning a reference-to-const type such that
+    the referenced value is copied into a new Python object.
 
     <h4><a name="copy_const_reference-spec-synopsis"></a>Class
     <code>copy_const_reference</code> synopsis</h4>
@@ -86,17 +73,17 @@ template &lt;class T&gt; struct apply
 </pre>
 
     <dl class="metafunction-semantics">
-      <dt><b>Requires:</b> <code>T</code> is <code>U const&amp;</code> for
-      some <code>U</code>.</dt>
+      <dt><b>Requires:</b> <code>T</code> is <code>U const&amp;</code> for some
+      <code>U</code>.
 
       <dt><b>Returns:</b> <code>typedef <a href=
       "to_python_value.html#to_python_value-spec">to_python_value</a>&lt;T&gt;
-      type;</code></dt>
+      type;</code>
     </dl>
 
     <h2><a name="examples"></a>Example</h2>
 
-    <h3>C++ Module Definition</h3>
+<h3>C++ Module Definition</h3>
 <pre>
 #include &lt;boost/python/module.hpp&gt;
 #include &lt;boost/python/class.hpp&gt;
@@ -115,18 +102,22 @@ struct Foo {
 
 // Wrapper code
 using namespace boost::python;
-BOOST_PYTHON_MODULE(my_module)
+BOOST_PYTHON_MODULE_INIT(my_module)
 {
-    class_&lt;Bar&gt;("Bar");
-
-     class_&lt;Foo&gt;("Foo", init&lt;int&gt;())
-        .def("get_bar", &amp;Foo::get_bar
-            , return_value_policy&lt;copy_const_reference&gt;())
+   module m("my_module")
+      .add(
+         class_&lt;Bar&gt;()
+         )
+      .add(
+         class_&lt;Foo&gt;()
+            .def_init(args&lt;int&gt;())
+            .def("get_bar", &amp;Foo::get_bar
+                , return_value_policy&lt;copy_const_reference&gt;())
+         )
        ;
 }
 </pre>
-
-    <h3>Python Code</h3>
+<h3>Python Code</h3>
 <pre>
 &gt;&gt;&gt; from my_module import *
 &gt;&gt;&gt; f = Foo(3)         # create a Foo object
@@ -135,13 +126,10 @@ BOOST_PYTHON_MODULE(my_module)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 September, 2002 
+     15 February, 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>
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
 

doc/v2/copy_non_const_reference.html

@@ -1,59 +1,47 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-  <head>
-    <meta name="generator" content=
-    "HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
+    <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/copy_non_const_reference.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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
         <td valign="top">
           <h1 align="center">Boost.Python</h1>
 
           <h2 align="center">Header
           &lt;boost/python/copy_non_const_reference.hpp&gt;</h2>
-        </td>
-      </tr>
     </table>
     <hr>
 
     <h2>Contents</h2>
 
     <dl class="page-index">
-      <dt><a href="#classes">Classes</a></dt>
+      <dt><a href="#classes">Classes</a>
 
       <dd>
         <dl class="page-index">
           <dt><a href="#copy_non_const_reference-spec">Class
-          <code>copy_non_const_reference</code></a></dt>
+          <code>copy_non_const_reference</code></a>
 
           <dd>
             <dl class="page-index">
               <dt><a href="#copy_non_const_reference-spec-synopsis">Class
-              <code>copy_non_const_reference</code> synopsis</a></dt>
+              <code>copy_non_const_reference</code> synopsis</a>
 
-              <dt><a href=
-              "#copy_non_const_reference-spec-metafunctions">Class
-              <code>copy_non_const_reference</code> metafunctions</a></dt>
+              <dt><a href="#copy_non_const_reference-spec-metafunctions">Class
+              <code>copy_non_const_reference</code> metafunctions</a>
             </dl>
-          </dd>
         </dl>
-      </dd>
 
-      <dt><a href="#examples">Example</a></dt>
+      <dt><a href="#examples">Example</a>
     </dl>
     <hr>
 
@@ -63,10 +51,9 @@
     <code>copy_non_const_reference</code></h3>
 
     <p><code>copy_non_const_reference</code> is a model of <a href=
-    "ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a>
-    which can be used to wrap C++ functions returning a
-    reference-to-non-const type such that the referenced value is copied into
-    a new Python object.</p>
+    "ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a> which can be
+    used to wrap C++ functions returning a reference-to-non-const type such
+    that the referenced value is copied into a new Python object.
 
     <h4><a name="copy_non_const_reference-spec-synopsis"></a>Class
     <code>copy_non_const_reference</code> synopsis</h4>
@@ -88,16 +75,16 @@ template &lt;class T&gt; struct apply
 
     <dl class="metafunction-semantics">
       <dt><b>Requires:</b> <code>T</code> is <code>U&amp;</code> for some
-      non-const <code>U</code>.</dt>
+      non-const <code>U</code>.
 
       <dt><b>Returns:</b> <code>typedef <a href=
       "to_python_value.html#to_python_value-spec">to_python_value</a>&lt;T&gt;
-      type;</code></dt>
+      type;</code>
     </dl>
 
     <h2><a name="examples"></a>Example</h2>
 
-    <p>C++ code:</p>
+    <p>C++ code:
 <pre>
 #include &lt;boost/python/module.hpp&gt;
 #include &lt;boost/python/class.hpp&gt;
@@ -116,14 +103,18 @@ struct Foo {
 
 // Wrapper code
 using namespace boost::python;
-BOOST_PYTHON_MODULE(my_module)
+BOOST_PYTHON_MODULE_INIT(my_module)
 {
-    class_&lt;Bar&gt;("Bar");
-
-     class_&lt;Foo&gt;("Foo", init&lt;int&gt;())
-        .def("get_bar", &amp;Foo::get_bar
-            , return_value_policy&lt;copy_non_const_reference&gt;())
-       ;
+   module("my_module")
+      .add(
+         class_&lt;Bar&gt;()
+         )
+      .add(
+         class_&lt;Foo&gt;()
+            .def_init(args&lt;int&gt;())
+            .def("get_bar", &amp;Foo::get_bar
+                , return_value_policy&lt;copy_non_const_reference&gt;())
+         );
 }
 </pre>
     Python Code: 
@@ -135,13 +126,10 @@ BOOST_PYTHON_MODULE(my_module)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 September, 2001 
+     05 November, 2001 
     <!--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>
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
 

doc/v2/data_members.html

@@ -1,118 +1,109 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-  <head>
-    <meta name="generator" content=
-    "HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
+    <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/data_members.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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
         <td valign="top">
           <h1 align="center">Boost.Python</h1>
 
-          <h2 align="center">Header
-          &lt;boost/python/data_members.hpp&gt;</h2>
-        </td>
-      </tr>
+          <h2 align="center">Header &lt;boost/python/data_members.hpp&gt;</h2>
     </table>
     <hr>
 
     <h2>Contents</h2>
 
     <dl class="page-index">
-      <dt><a href="#introduction">Introduction</a></dt>
+      <dt><a href="#introduction">Introduction</a>
 
-      <dt><a href="#functions">Functions</a></dt>
+      <dt><a href="#functions">Functions</a>
 
       <dd>
         <dl class="page-index">
-          <dt><a href="#make_getter-spec">make_getter</a></dt>
+          <dt><a href="#make_getter-spec">make_getter</a>
 
-          <dt><a href="#make_setter-spec">make_setter</a></dt>
+          <dt><a href="#make_setter-spec">make_setter</a>
         </dl>
-      </dd>
 
-      <dt><a href="#examples">Example</a></dt>
+      <dt><a href="#examples">Example</a>
     </dl>
     <hr>
 
     <h2><a name="introduction"></a>Introduction</h2>
 
     <p><code><a href="#make_getter-spec">make_getter</a>()</code> and
-    <code><a href="#make_setter-spec">make_setter</a>()</code> are the
-    functions used internally by <code>class_&lt;&gt;::<a href=
+    <code><a href="#make_setter-spec">make_setter</a>()</code> are
+    the functions used internally by <code>class_&lt;&gt;::<a href=
     "class.html#class_-spec-modifiers">def_readonly</a></code> and
     <code>class_&lt;&gt;::<a href=
-    "class.html#class_-spec-modifiers">def_readwrite</a></code> to produce
-    Python callable objects which wrap C++ data members.</p>
+    "class.html#class_-spec-modifiers">def_readwrite</a></code> to
+    produce Python callable objects which wrap C++ data members.
 
     <h2><a name="functions"></a>Functions</h2>
+
 <pre>
 <a name="make_getter-spec">template &lt;class C, class D&gt;</a>
-<a href="object.html#object-spec">object</a> make_getter(D C::*pm);
+objects::function* make_getter(D C::*pm);
 
 template &lt;class C, class D, class Policies&gt;
-<a href=
-"object.html#object-spec">object</a> make_getter(D C::*pm, Policies const&amp; policies);
+objects::function* make_getter(D C::*pm, Policies const&amp; policies);
 </pre>
 
     <dl class="function-semantics">
-      <dt><b>Requires:</b> <code>Policies</code> is a model of <a href=
-      "CallPolicies.html">CallPolicies</a>.</dt>
+      <dt><b>Requires:</b> <code>Policies</code> is a model of <a
+      href="CallPolicies.html">CallPolicies</a>.
 
-      <dt><b>Effects:</b> Creates a Python callable object which accepts a
-      single argument that can be converted <code>from_python</code> to
-      <code>C*</code>, and returns the corresponding member <code>D</code>
-      member of the <code>C</code> object, converted <code>to_python</code>.
-      If <code>policies</code> is supplied, it will be applied to the
-      function as described <a href="CallPolicies.html">here</a>.</dt>
+      <dt><b>Effects:</b> Creates a Python callable object which
+      accepts a single argument that can be converted
+      <code>from_python</code> to <code>C*</code>, and returns the
+      corresponding member <code>D</code> member of the <code>C</code>
+      object, converted <code>to_python</code>. If
+      <code>policies</code> is supplied, it will be applied to the
+      function as described <a href=
+      "CallPolicies.html">here</a>.
 
-      <dt><b>Returns:</b> An instance of <a href=
-      "object.html#object-spec">object</a> which holds the new Python
-      callable object.</dt>
+      <dt><b>Returns:</b> A pointer convertible to <code>PyObject*</code> which
+      refers to the new Python callable object.
     </dl>
 <pre>
 <a name="make_setter-spec">template &lt;class C, class D&gt;</a>
-<a href="object.html#object-spec">object</a> make_setter(D C::*pm);
+objects::function* make_setter(D C::*pm);
 
 template &lt;class C, class D, class Policies&gt;
-<a href=
-"object.html#object-spec">object</a> make_setter(D C::*pm, Policies const&amp; policies);
+objects::function* make_setter(D C::*pm, Policies const&amp; policies);
 </pre>
 
     <dl class="function*-semantics">
-      <dt><b>Requires:</b> <code>Policies</code> is a model of <a href=
-      "CallPolicies.html">CallPolicies</a>.</dt>
+      <dt><b>Requires:</b> <code>Policies</code> is a model of <a
+      href="CallPolicies.html">CallPolicies</a>.
 
-      <dt><b>Effects:</b> Creates a Python callable object which, when called
-      from Python, expects two arguments which can be converted
+      <dt><b>Effects:</b> Creates a Python callable object which, when
+      called from Python, expects two arguments which can be converted
       <code>from_python</code> to <code>C*</code> and
       <code>D&nbsp;const&amp;</code>, respectively, and sets the
-      corresponding <code>D</code> member of the <code>C</code> object. If
-      <code>policies</code> is supplied, it will be applied to the function
-      as described <a href="CallPolicies.html">here</a>.</dt>
+      corresponding <code>D</code> member of the <code>C</code>
+      object. If <code>policies</code> is supplied, it will be applied
+      to the function as described <a
+      href="CallPolicies.html">here</a>.
 
-      <dt><b>Returns:</b> An instance of <a href=
-      "object.html#object-spec">object</a> which holds the new Python
-      callable object.</dt>
+      <dt><b>Returns:</b> A pointer convertible to
+      <code>PyObject*</code> which refers to the new Python callable
+      object.
     </dl>
 
     <h2><a name="examples"></a>Example</h2>
 
-    <p>The code below uses make_getter and make_setter to expose a data
-    member as functions:</p>
+    <p>The code below uses make_getter and make_setter to expose a
+    data member as functions:
+
 <pre>
 #include &lt;boost/python/data_members.hpp&gt;
 #include &lt;boost/python/module.hpp&gt;
@@ -128,10 +119,14 @@ using namespace boost::python;
 
 BOOST_PYTHON_MODULE_INIT(data_members_example)
 {
-    class_&lt;X&gt;("X", init&lt;int&gt;())
-       .def("get", make_getter(&amp;X::y))
-       .def("set", make_setter(&amp;X::y))
-       ;
+    module("data_members_example")
+        .add(
+            class_&lt;X&gt;(&quot;X&quot;)
+               .def_init(args&lt;int&gt;())
+               .def(&quot;get&quot;, make_getter(&amp;X::y))
+               .def(&quot;set&quot;, make_setter(&amp;X::y))
+        )
+        ;
 }
 </pre>
     It can be used this way in Python: 
@@ -147,13 +142,9 @@ BOOST_PYTHON_MODULE_INIT(data_members_example)
 
     <p>
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 September 2002 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-    </p>
+    8 May 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></p>
-  </body>
-</html>
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
 

doc/v2/def.html

@@ -1,196 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<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">
-
-    <title>Boost.Python - &lt;boost/python/def.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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
-
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
-
-          <h2 align="center">Header &lt;boost/python/def.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="#def-spec">def</a></dt>
-        </dl>
-      </dd>
-
-      <dt><a href="#examples">Example</a></dt>
-    </dl>
-    <hr>
-
-    <h2><a name="introduction"></a>Introduction</h2>
-
-    <p><code><a href="#def-spec">def</a>()</code> is the function which can
-    be used to expose C++ functions and callable objects as Python functions
-    in the current <code><a href="scope.html">scope</a></code>.</p>
-
-    <h2><a name="functions"></a>Functions</h2>
-    <a name="def-spec"></a>def 
-<pre>
-template &lt;class F&gt;
-void def(char const* name, F f);
-
-template &lt;class Fn, class A1&gt;
-void def(char const* name, Fn fn, A1 const&amp;);
-
-template &lt;class Fn, class A1, class A2&gt;
-void def(char const* name, Fn fn, A1 const&amp;, A2 const&amp;);
-
-template &lt;class Fn, class A1, class A2, class A3&gt;
-void def(char const* name, Fn fn, A1 const&amp;, A2 const&amp;, A3 const&amp;);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> <code>name</code> is an <a href=
-      "definitions.html#ntbs">ntbs</a> which conforms to Python's <a href=
-      "http://www.python.org/doc/current/ref/identifiers.html">identifier
-      naming rules</a>.</dt>
-
-      <dd>
-        <ul>
-          <li>
-            If <code>a1</code> is the result of an <a href=
-            "overloads.html#overload-dispatch-expression"><em>overload-dispatch-expression</em></a>,
-            only the second form is allowed and fn must be a pointer to
-            function or pointer to member function whose <a href=
-            "definitions.html#arity">arity</a> is the same as A1's <a href=
-            "overloads.html#overload-dispatch-expression"><em>maximum
-            arity</em></a>. 
-
-            <dl>
-              <dt><b>Effects:</b> For each prefix <em>P</em> of
-              <code>Fn</code>'s sequence of argument types, beginning with
-              the one whose length is <code>A1</code>'s <a href=
-              "overloads.html#overload-dispatch-expression"><em>minimum
-              arity</em></a>, adds a
-              <code><em>name</em>(</code>...<code>)</code> function overload
-              to the <a href="scope.html">current scope</a>. Each overload
-              generated invokes <code>a1</code>'s call-expression with
-              <em>P</em>, using a copy of <code>a1</code>'s <a href=
-              "CallPolicies.html">call policies</a>. If the longest valid
-              prefix of <code>A1</code> contains <em>N</em> types and
-              <code>a1</code> holds <em>M</em> keywords, an initial sequence
-              of the keywords are used for all but the first
-              <em>N</em>&nbsp;-&nbsp;<em>M</em> arguments of each
-              overload.<br>
-              </dt>
-            </dl>
-          </li>
-
-          <li>
-            Otherwise, a single function overload built around fn (which must
-            not be null) is added to the <a href="scope.html">current
-            scope</a>: 
-
-            <ul>
-              <li>If fn is a function or member function pointer,
-              <code>a1</code>-<code>a3</code> (if supplied) may be selected
-              in any order from the table below.</li>
-
-              <li>Otherwise, <code>Fn</code> must be [derived from] <code><a
-              href="object.html#object-spec">object</a></code>, and
-              <code>a1-a2</code> (if supplied) may be selcted in any order
-              from the first two rows of the table below. To be useful,
-              <code>fn</code> should be <a href=
-              "http://www.python.org/doc/current/lib/built-in-funcs.html#l2h-6">
-              callable</a>.</li>
-            </ul>
-
-            <table border="1" summary="def() optional arguments">
-              <tr>
-                <th>Memnonic Name</th>
-
-                <th>Requirements/Type properties</th>
-
-                <th>Effects</th>
-              </tr>
-
-              <tr>
-                <td>docstring</td>
-
-                <td>Any <a href="definitions.html#ntbs">ntbs</a>.</td>
-
-                <td>Value will be bound to the <code>__doc__</code> attribute
-                of the resulting method overload.</td>
-              </tr>
-
-              <tr>
-                <td>policies</td>
-
-                <td>A model of <a href=
-                "CallPolicies.html">CallPolicies</a></td>
-
-                <td>A copy will be used as the call policies of the resulting
-                method overload.</td>
-              </tr>
-
-              <tr>
-                <td>keywords</td>
-
-                <td>The result of a <a href=
-                "args.html#keyword-expression"><em>keyword-expression</em></a>
-                specifying no more arguments than the <a href=
-                "definitions.html#arity">arity</a> of <code>fn</code>.</td>
-
-                <td>A copy will be used as the call policies of the resulting
-                method overload.</td>
-              </tr>
-            </table>
-          </li>
-        </ul>
-      </dd>
-    </dl>
-
-    <h2><a name="examples"></a>Example</h2>
-<pre>
-#include &lt;boost/python/def.hpp&gt;
-#include &lt;boost/python/module.hpp&gt;
-#include &lt;boost/python/args.hpp&gt;
-
-char const* foo(int x, int y) { return "foo"; }
-
-BOOST_PYTHON_MODULE(def_test)
-{
-    def("foo", foo, args("x", "y"), "foo's docstring");
-}
-</pre>
-
-    <p>
-    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     03 October, 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/definitions.html

@@ -1,100 +1,35 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
 <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">
-
-    <title>Boost.Python - Definitions</title>
-  </head>
-
-  <body link="#0000ff" vlink="#800080">
-    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<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 - Definitions</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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
-
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
-
-          <h2 align="center">Definitions</h2>
-        </td>
-      </tr>
-    </table>
-    <hr>
-
-    <dl class="definitions">
-      <dt><b><a name="arity">arity</a>:</b> The number of arguments accepted
-      by a function or member function. Unless otherwise specified, the
-      hidden "<code>this</code>" argument to member functions is not counted
-      when specifying arity</dt>
-
-      <dd><br>
-      </dd>
-
-      <dt><b><a name="ntbs">ntbs</a>:</b> Null-Terminated Byte String, or
-      `C'-string. C++ string literals are <strong>ntbs</strong>es. An
-      <strong>ntbs</strong> must never be null.</dt>
-
-      <dd><br>
-      </dd>
-
-      <dt><b><a name="raise">raise</a>:</b> Exceptions in Python are
-      "raised", not "thrown", as they are in C++. When this documentation
-      says that some Python exception is "raised" in the context of C++ code,
-      it means that the corresponding Python exception is set via the <a
-      href=
-      "http://www.python.org/doc/current/api/exceptionHandling.html">Python/'C'
-      API</a>, and <code><a href=
-      "errors.html#throw_error_already_set-spec">throw_error_already_set</a>()</code>
-      is called.</dt>
-
-      <dd><br>
-      </dd>
-
-      <dt><b><a name="POD">POD</a>:</b> A technical term from the C++
-      standard. Short for "Plain Ol'Data": A POD-struct is an aggregate class
-      that has no non-static data members of type pointer to member,
-      non-POD-struct, non-POD-union (or array of such types) or reference,
-      and has no user-defined copy assign- ment operator and no user-defined
-      destructor. Similarly, a POD-union is an aggregate union that has no
-      non-static data members of type pointer to member, non-POD-struct,
-      non-POD-union (or array of such types) or reference, and has no
-      user-defined copy assignment operator and no user-defined destructor. A
-      POD class is a class that is either a POD-struct or a POD-union. An
-      aggregate is an array or a class (clause 9) with no user-declared
-      constructors (12.1), no private or protected non-static data members
-      (clause 11), no base classes (clause 10), and no virtual functions
-      (10.3).</dt>
-
-      <dd><br>
-      </dd>
-
-      <dt><b><a name="ODR">ODR</a>:</b> The &quot;One Definition
-      Rule&quot;, which says that any entity in a C++ program must have the same definition in all translation units (object files) which make up a program.
-      </dt>
-
-      <dd><br>
-      </dd>
-
-
-    </dl>
-    <hr>
-
-    <p>Revised 
-    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     03 October, 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>
+  <tr> 
+    <td valign="top" width="300"> 
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Definitions</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<dl class="definitions">
+  <dt><b>{{term}}:</b> {{definition}}</dt>
+  <dt><b>{{term}}:</b> {{definition}}</dt>
+</dl>
+<hr>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 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/dict.html

@@ -1,150 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<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">
-
-    <title>Boost.Python - &lt;boost/python/dict.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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
-
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
-
-          <h2 align="center">Header &lt;boost/python/dict.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="#dict-spec">Class <code>dict</code></a></dt>
-
-          <dd>
-            <dl class="page-index">
-              <dt><a href="#dict-spec-synopsis">Class <code>dict</code>
-              synopsis</a></dt>
-            </dl>
-          </dd>
-        </dl>
-      </dd>
-
-      <dt><a href="#examples">Example(s)</a></dt>
-    </dl>
-    <hr>
-
-    <h2><a name="introduction"></a>Introduction</h2>
-
-    <p>Exposes a <a href=
-    "ObjectWrapper.html#TypeWrapper-concept">TypeWrapper</a> for the Python
-    <a href=
-    "http://www.python.org/dev/doc/devel/lib/typesmapping.html">dict</a>
-    type.</p>
-
-    <h2><a name="classes"></a>Classes</h2>
-
-    <h3><a name="dict-spec"></a>Class <code>dict</code></h3>
-
-    <p>Exposes the <a href=
-    "http://www.python.org/dev/doc/devel/lib/typesmapping.html">mapping
-    protocol</a> of Python's built-in <code>dict</code> type. The semantics
-    of the constructors and member functions defined below can be fully
-    understood by reading the <a href=
-    "ObjectWrapper.html#TypeWrapper-concept">TypeWrapper</a> concept
-    definition. Since <code>dict</code> is publicly derived from <code><a
-    href="object.html#object-spec">object</a></code>, the public object
-    interface applies to <code>dict</code> instances as well.</p>
-
-    <h4><a name="dict-spec-synopsis"></a>Class <code>dict</code>
-    synopsis</h4>
-<pre>
-namespace boost { namespace python
-{
-   class dict : public object
-   {
-      dict();
-
-      template&lt; class T &gt;
-      dict(T const &amp; data);
-
-      // modifiers
-      void clear();
-      dict copy();
-
-      template &lt;class T1, class T2&gt;
-      tuple popitem();
-
-      template &lt;class T&gt;
-      object setdefault(T const &amp;k);
-
-      template &lt;class T1, class T2&gt;
-      object setdefault(T1 const &amp; k, T2 const &amp; d);
-
-      void update(object_cref E);
- 
-      template&lt; class T &gt;
-      void update(T const &amp; E);
-
-      // observers
-      list values() const;
-    
-      object get(object_cref k) const;
-
-      template&lt;class T&gt;
-      object get(T const &amp; k) const;
-
-      object get(object_cref k, object_cref d) const;
-      object get(T1 const &amp; k, T2 const &amp; d) const;
-
-      bool has_key(object_cref k) const;
-
-      template&lt; class T &gt;
-      bool has_key(T const &amp; k) const;
-
-      list items() const;
-      object iteritems() const;
-      object iterkeys() const;
-      object itervalues() const;
-      list keys() const;
-  };
-}}
-</pre>
-
-    <h2><a name="examples"></a>Example</h2>
-<pre>
-using namespace boost::python;
-dict swap_object_dict(object target, dict d)
-{
-    dict result = extract&lt;dict&gt;(target.attr("__dict__"));
-    target.attr("__dict__") = d;
-    return result;
-}
-</pre>
-
-    <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>
-  </body>
-</html>
-

doc/v2/enum.html

@@ -1,203 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<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">
-
-    <title>Boost.Python - &lt;boost/python/enum.hpp&gt;</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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
-
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
-
-          <h2 align="center">Header &lt;boost/python/enum.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="#enum_-spec">Class template
-          <code>enum_</code></a></dt>
-
-          <dd>
-            <dl class="page-index">
-              <dt><a href="#enum_-spec-synopsis">Class template <code>enum_</code>
-              synopsis</a></dt>
-
-              <dt><a href="#enum_-spec-ctors">Class template <code>enum_</code>
-              constructors</a></dt>
-
-              <dt><a href="#enum_-spec-modifiers">Class template <code>enum_</code>
-              modifier functions</a></dt>
-            </dl>
-          </dd>
-
-        </dl>
-      </dd>
-
-      <dt><a href="#examples">Example(s)</a></dt>
-    </dl>
-    <hr>
-
-    <h2><a name="introduction"></a>Introduction</h2>
-
-    <p><code>&lt;boost/python/enum.hpp&gt;</code> defines the
-    interface through which users expose their C++ enumeration types
-    to Python. It declares the
-    <code>enum_</code> class template, which is parameterized on the
-    enumeration type being exposed. </p>
-
-
-    <h2><a name="classes"></a>Classes</h2>
-
-    <h3><a name="enum_-spec"></a>Class template
-    <code>enum_&lt;T&gt;</code></h3>
-
-    <p>Creates a Python class derived from Python's <code>int</code>
-    type which is associated with the C++ type passed as its first
-    parameter. 
-
-    <h4><a name="enum_-spec-synopsis"></a>Class template <code>enum_</code>
-    synopsis</h4>
-<pre>
-namespace boost { namespace python
-{
-  template &lt;class T&gt;
-  class enum_ : public <a href="object.html#object-spec">object</a>
-  {
-    enum_(char const* name);
-    inline enum_&lt;T&gt;&amp; value(char const* name, T);
-  };
-}}
-</pre>
-
-    <h4><a name="enum_-spec-ctors"></a>Class template <code>enum_</code>
-    constructors</h4>
-<pre>
-enum_(char const* name);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> <code>name</code> is an <a href=
-      "definitions.html#ntbs">ntbs</a> which conforms to Python's <a href=
-      "http://www.python.org/doc/current/ref/identifiers.html">identifier
-      naming rules</a>. 
-
-      <dt><b>Effects:</b> Constructs an <code>enum_</code> object
-      holding a Python extension type derived from <code>int</code>
-      which is named <code>name</code>. The
-      <code>name</code>d attribute of the <a href=
-      "scope.html#introduction">current scope</a> is bound to the new
-      extension type.</dt>
-    </dl>
-
-    <h4><a name="enum_-spec-modifiers"></a>Class template
-    <code>enum_</code> modifier functions</h4>
-<pre>
-inline enum_&lt;T&gt;&amp; value(char const* name, T x);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> <code>name</code> is an <a href=
-      "definitions.html#ntbs">ntbs</a> which conforms to Python's <a
-      href=
-      "http://www.python.org/doc/current/ref/identifiers.html">identifier
-      naming rules</a>.
-
-      <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>.
-
-      <dt><b>Returns:</b> <code>*this</code></dt>
-
-    </dl>
-
-    <h2><a name="examples"></a>Example(s)</h2>
-
-    <p>C++ module definition
-<pre>
-#include &lt;boost/python/enum.hpp&gt;
-#include &lt;boost/python/def.hpp&gt;
-#include &lt;boost/python/module.hpp&gt;
-
-using namespace boost::python;
-
-enum color { red = 1, green = 2, blue = 4 };
-
-color identity_(color x) { return x; }
-
-BOOST_PYTHON_MODULE(enums)
-{
-    enum_&lt;color&gt;(&quot;color&quot;)
-        .value(&quot;red&quot;, red)
-        .value(&quot;green&quot;, green)
-        .value(&quot;blue&quot;, blue)
-        ;
-    
-    def(&quot;identity&quot;, identity_);
-}
-</pre>
-    <p>Interactive Python:
-<pre>
-&gt;&gt;&gt; from enums import *
-
-&gt;&gt;&gt; identity(color.red)
-enums.color.red
-
-&gt;&gt;&gt; identity(color.green)
-enums.color.green
-
-&gt;&gt;&gt; identity(color.blue)
-enums.color.blue
-
-&gt;&gt;&gt; identity(color(1))
-enums.color.red
-
-&gt;&gt;&gt; identity(color(2))
-enums.color.green
-
-&gt;&gt;&gt; identity(color(3))
-enums.color(3)
-
-&gt;&gt;&gt; identity(color(4))
-enums.color.blue
-
-&gt;&gt;&gt; identity(1)
-Traceback (most recent call last):
-  File &quot;&lt;stdin&gt;&quot;, line 1, in ?
-TypeError: bad argument type for built-in operation
-</pre>
-    <hr>
-
-    Revised 
-    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     03 October, 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></p>
-  </body>
-</html>
-

doc/v2/errors.html

@@ -1,68 +1,53 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-  <head>
-    <meta name="generator" content=
-    "HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
+    <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/errors.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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
         <td valign="top">
           <h1 align="center">Boost.Python</h1>
 
           <h2 align="center">Header &lt;boost/python/errors.hpp&gt;</h2>
-        </td>
-      </tr>
     </table>
     <hr>
 
     <h2>Contents</h2>
 
     <dl class="page-index">
-      <dt><a href="#introduction">Introduction</a></dt>
+      <dt><a href="#introduction">Introduction</a>
 
-      <dt><a href="#classes">Classes</a></dt>
+      <dt><a href="#classes">Classes</a>
 
       <dd>
         <dl class="page-index">
-          <dt><a href="#error_already_set-spec">Class
-          <code>error_already_set</code></a></dt>
+          <dt><a href="#error_already_set-spec">Class <code>error_already_set</code></a>
 
           <dd>
             <dl class="page-index">
               <dt><a href="#error_already_set-spec-synopsis">Class
-              <code>error_already_set</code> synopsis</a></dt>
+              <code>error_already_set</code> synopsis</a>
             </dl>
-          </dd>
         </dl>
-      </dd>
 
-      <dt><a href="#functions">Functions</a></dt>
+      <dt><a href="#functions">Functions</a>
 
       <dd>
         <dl class="page-index">
-          <dt><a href="#handle_exception-spec">handle_exception</a></dt>
+          <dt><a href="#handle_exception-spec">handle_exception</a>
 
-          <dt><a href="#expect_non_null-spec">expect_non_null</a></dt>
-
-          <dt><a href=
-          "#throw_error_already_set-spec">throw_error_already_set</a></dt>
+          <dt><a href="#expect_non_null-spec">expect_non_null</a>
+          <dt><a href="#throw_error_already_set-spec">throw_error_already_set</a>
         </dl>
-      </dd>
 
-      <dt><a href="#examples">Examples</a></dt>
+      <dt><a href="#examples">Examples</a>
     </dl>
     <hr>
 
@@ -71,24 +56,20 @@
     <p><code>&lt;boost/python/errors.hpp&gt;</code> provides types and
     functions for managing and translating between Python and C++ exceptions.
     This is relatively low-level functionality that is mostly used internally
-    by Boost.Python. Users should seldom need it.</p>
+    by Boost.Python. Users should seldom need it.
 
     <h2><a name="classes"></a>Classes</h2>
 
     <h3><a name="error_already_set-spec"></a>Class
     <code>error_already_set</code></h3>
 
-    <p><code>error_already_set</code> is an exception type which can be
-    thrown to indicate that a Python error has occurred. If thrown, the
-    precondition is that <a href=
+    <p><code>error_already_set</code> is an exception type which can be thrown
+    to indicate that a Python error has occurred. If thrown, the precondition
+    is that <a href=
     "http://www.python.org/doc/2.2/api/exceptionHandling.html#l2h-71">PyErr_Occurred()</a>
-    returns a value convertible to <code>true</code>. Portable code shouldn't
-    throw this exception type directly, but should instead use <code><a href=
-    "#throw_error_already_set-spec">throw_error_already_set</a>()</code>,
-    below.</p>
+    returns a value convertible to <code>true</code>.
 
-    <h4><a name="error_already_set-spec-synopsis"></a>Class error_already_set
-    synopsis</h4>
+    <h4><a name="error_already_set-spec-synopsis"></a>Class error_already_set synopsis</h4>
 <pre>
 namespace boost { namespace python
 {
@@ -105,100 +86,84 @@ void handle_exception() throw();
 </pre>
 
     <dl class="handle_exception-semantics">
-      <dt><b>Requires:</b> The first form requires that the expression
-      <code><a href=
+      <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>
       is valid. The second form requires that a C++ exception is currently
-      being handled (see section 15.1 in the C++ standard).</dt>
+      being handled (see section 15.1 in the C++ standard).
 
       <dt><b>Effects:</b> The first form calls <code>f()</code> inside a
-      <code>try</code> block which first attempts to use all registered <a
-      href="exception_translator.html">exception translators</a>. If none of
-      those translates the exception, the <code>catch</code> clauses then set
-      an appropriate Python exception for the C++ exception caught, returning
-      <code>true</code> if an exception was thrown, <code>false</code>
-      otherwise. The second form passes a function which rethrows the
-      exception currently being handled to the first form.</dt>
+      <code>try</code> block whose <code>catch</code> clauses set an
+      appropriate Python exception for the C++ exception caught, returning
+      <code>true</code> if an exception was caught, <code>false</code>
+      otherwise. The second form passes a function which rethrows the exception
+      currently being handled to the first form.
 
-      <dt><b>Postconditions:</b> No exception is being handled</dt>
+      <dt><b>Postconditions:</b> No exception is being handled
 
-      <dt><b>Throws:</b> nothing</dt>
+      <dt><b>Throws:</b> nothing
 
       <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
-      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
-      facilities: <code><a href=
-      "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=
-      "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
-      within an enclosing <code>try</code> block.</dt>
+      ensure that no C++ exceptions escape, since the calling language usually
+      doesn't have the equipment neccessary 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 facilities: <a href=
+      "make_function.html#make_function-spec">make_function()</a>, <a href=
+      "make_function.html#make_constructor-spec">make_constructor()</a>, <a
+      href="module.html#def-spec">module::def</a> and <a href=
+      "class.html#def-spec">class_::def</a>). 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 within
+      an enclosing <code>try</code> block.
     </dl>
 <pre>
-<a name=
-"expect_non_null-spec">template &lt;class T&gt; T* expect_non_null(T* x);</a>
+<a name="expect_non_null-spec">template &lt;class T&gt; T* expect_non_null(T* x);</a>
 </pre>
 
     <dl class="expect_non_null-semantics">
-      <dt><b>Returns:</b> <code>x</code></dt>
+      <dt><b>Returns:</b> <code>x</code>
 
       <dt><b>Throws:</b> <code><a href=
-      "#error_already_set-spec">error_already_set</a>()</code> iff <code>x ==
-      0</code>.</dt>
+      "#error_already_set-spec">error_already_set()</a></code> iff <code>x ==
+      0</code>.
 
-      <dt><b>Rationale:</b> Simplifies error-handling when calling functions
-      in the <a href="http://www.python.org/doc/2.2/api/api.html">Python/C
-      API</a> which return 0 on error.</dt>
+      <dt><b>Rationale:</b> Simplifies error-handling when calling many
+      functions in the <a href=
+      "http://www.python.org/doc/2.2/api/api.html">Python/C API</a>, which
+      return 0 on error.
     </dl>
+
 <pre>
 <a name="throw_error_already_set-spec">void throw_error_already_set();</a>
 </pre>
 
     <dl class="throw_error_already_set-semantics">
-      <dt><b>Effects:</b> <code>throw&nbsp;<a href=
-      "#error_already_set-spec">error_already_set</a>();</code></dt>
-    </dl>
 
-    <dl>
-      <dt><b>Rationale:</b> Many platforms and compilers are not able to
-      consistently catch exceptions thrown across shared library boundaries.
-      Using this function from the Boost.Python library ensures that the
-      appropriate <code>catch</code> block in <code><a href=
-      "#handle_exception-spec">handle_exception</a>()</code> can catch the
-      exception.</dt>
+      <dt><b>Effects:</b> <code>throw&nbsp;<a href=
+      "#error_already_set-spec">error_already_set</a>();</code> 
     </dl>
 
     <h2><a name="examples"></a>Examples</h2>
 <pre>
 #include &lt;string&gt;
 #include &lt;boost/python/errors.hpp&gt;
-#include &lt;boost/python/object.hpp&gt;
-#include &lt;boost/python/handle.hpp&gt;
+#include &lt;boost/python/reference.hpp&gt;
 
 // Returns a std::string which has the same value as obj's "__name__"
 // attribute.
-std::string get_name(boost::python::object obj)
+std::string get_name(boost::python::ref obj)
 {
    // throws if there's no __name__ attribute
    PyObject* p = boost::python::expect_non_null(
-      PyObject_GetAttrString(obj.ptr(), "__name__"));
-
-   char const* s = PyString_AsString(p);
-   if (s != 0) 
-        Py_DECREF(p);
+      PyObject_GetAttrString(obj.get(), "__name__"));
 
    // throws if it's not a Python string
    std::string result(
       boost::python::expect_non_null(
          PyString_AsString(p)));
 
-   Py_DECREF(p); // Done with p
+   Py_XDECREF(p); // Done with p
    
    return result;
 }
@@ -207,19 +172,12 @@ std::string get_name(boost::python::object obj)
 // Demonstrate form 1 of handle_exception
 //
 
-// Place into result a Python Int object whose value is 1 if a and b have
+// Place a Python Int object whose value is 1 if a and b have
 // identical "__name__" attributes, 0 otherwise.
-void same_name_impl(PyObject*&amp; result, boost::python::object a, boost::python::object b)
+void same_name_impl(PyObject*&amp; result, PyObject* a, PyObject* b)
 {
    result = PyInt_FromLong(
-      get_name(a) == get_name(a2));
-}
-
-object borrowed_object(PyObject* p)
-{
-   return boost::python::object(
-        boost::python::handle&lt;&gt;(
-             boost::python::borrowed(a1)));
+      get_name(boost::python::ref(a1)) == get_name(boost::python::ref(a2)));
 }
 
 // This is an example Python 'C' API interface function
@@ -236,7 +194,7 @@ same_name(PyObject* args, PyObject* keywords)
    // Use boost::bind to make an object compatible with
    // boost::Function0&lt;void&gt;
    if (boost::python::handle_exception(
-         boost::bind&lt;void&gt;(same_name_impl, boost::ref(result), borrowed_object(a1), borrowed_object(a2))))
+         boost::bind&lt;void&gt;(same_name_impl, boost::ref(result), a1, a2)))
    {
       // an exception was thrown; the Python error was set by
       // handle_exception()
@@ -259,10 +217,9 @@ same_name2(PyObject* args, PyObject* keywords)
 
    if (!PyArg_ParseTuple(args, const_cast&lt;char*&gt;("OO"), &amp;a1, &amp;a2))
       return 0;
-
    try {
       return PyInt_FromLong(
-         get_name(borrowed_object(a1)) == get_name(borrowed_object(a2)));
+         get_name(boost::python::ref(a1)) == get_name(boost::python::ref(a2)));
    }
    catch(...)
    {
@@ -275,13 +232,10 @@ same_name2(PyObject* args, PyObject* keywords)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 September, 2002 
+     17 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>
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
 

doc/v2/exception_translator.html

@@ -1,148 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<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">
-
-    <title>Boost.Python -
-    &lt;boost/python/exception_translator.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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
-
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
-
-          <h2 align="center">Header
-          &lt;boost/python/exception_translator.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=
-          "#register_exception_translator-spec">register_exception_translator</a></dt>
-        </dl>
-      </dd>
-
-      <dt><a href="#examples">Example(s)</a></dt>
-    </dl>
-    <hr>
-
-    <h2><a name="introduction"></a>Introduction</h2>
-
-    <p>As described <a href="errors.html#handle_exception-spec">here</a>, it
-    is important to make sure that exceptions thrown by C++ code do not pass
-    into the Python interpreter core. By default, Boost.Python translates all
-    C++ exceptions thrown by wrapped functions and module init functions into
-    Python, but the default translators are extremely limited: most C++
-    exceptions will appear in Python as a <a href=
-    "http://www.python.org/doc/current/lib/module-exceptions.html">RuntimeError</a>
-    exception whose representation is
-    <code>'Unidentifiable&nbsp;C++&nbsp;Exception'</code>. To produce better
-    error messages, users can register additional exception translators as
-    described below.</p>
-
-    <h2><a name="functions"></a>Functions</h2>
-
-<h3><code><a name="register_exception_translator-spec">register_exception_translator</a></code></h3>
-
-<pre>
-<a name="register_exception_translator-spec">template&lt;class ExceptionType, class Translate&gt;</a>
-void register_exception_translator(Translate const&amp; translate);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b></dt>
-
-      <dd>
-        <code>Translate</code> is <a href=
-        "../../../utility/CopyConstructible.html">Copyconstructible</a>, and
-        the following code must be well-formed: 
-<pre>
-void f(ExceptionType x) { translate(x); }
-</pre>
-        The expression <code>translate(x)</code> must either throw a C++
-        exception, or a subsequent call to <code><a href=
-        "http://www.python.org/doc/current/api/exceptionHandling.html">PyErr_Occurred</a>()</code>
-        must return 1.
-      </dd>
-
-      <p>
-
-      <dt><b>Effects:</b> Adds a copy of <code>translate</code> to the sequence of
-      exception translators tried when Boost.Python catches an exception that
-      is about to pass into Python's core interpreter. The new translator
-      will get "first shot" at translating all exceptions matching the catch
-      clause shown above. Any subsequently-registered translators will be
-      allowed to translate the exception earlier. A translator which cannot
-      translate a given C++ exception can re-throw it, and it will be handled
-      by a translator which was registered earlier (or by the default
-      translator).</dt>
-    </dl>
-
-    <h2><a name="examples"></a>Example</h2>
-<pre>
-#include &lt;boost/python/module.hpp&gt;
-#include &lt;boost/python/def.hpp&gt;
-#include &lt;boost/python/exception_translator.hpp&gt;
-#include &lt;exception&gt;
-
-struct my_exception : std::exception
-{
-  char const* what() throw() { return "One of my exceptions"; }
-};
-
-void translate(my_exception const&amp; e)
-{
-    // Use the Python 'C' API to set up an exception object
-    PyErr_SetString(PyExc_RuntimeError, e.what());
-}
-
-void something_which_throws()
-{
-    ...
-    throw my_exception();
-    ...
-}
-
-BOOST_PYTHON_MODULE(exception_translator_ext)
-{
-  using namespace boost::python;
-  register_exception_translator&lt;my_exception&gt;(&amp;translate);
-  
-  def("something_which_throws", something_which_throws);
-}
-</pre>
-    <br>
-     <br>
-     
-    <hr>
-
-    <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>
-  </body>
-</html>
-

doc/v2/extract.html

@@ -1,230 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<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">
-
-    <title>Boost.Python - &lt;boost/python/extract.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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
-
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
-
-          <h2 align="center">Header &lt;boost/python/extract.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="#extract-spec">Class <code>extract</code></a></dt>
-
-          <dd>
-            <dl class="page-index">
-              <dt><a href="#extract-spec-synopsis">Class <code>extract</code>
-              synopsis</a></dt>
-
-              <dt><a href="#extract-spec-ctors">Class <code>extract</code>
-              constructors and destructor</a></dt>
-
-              <dt><a href="#extract-spec-observers">Class
-              <code>extract</code> observer functions</a></dt>
-            </dl>
-          </dd>
-        </dl>
-      </dd>
-
-
-      <dt><a href="#examples">Example</a></dt>
-    </dl>
-    <hr>
-
-    <h2><a name="introduction"></a>Introduction</h2>
-
-    <p>Exposes a mechanism for extracting C++ object values from
-    generalized Python objects. Note that
-    <code>extract&lt;</code>...<code>&gt;</code> can also be used to
-    &quot;downcast&quot; an <a
-    href="object.html#object-spec">object</a> to some specific <a
-    href="ObjectWrapper.html#ObjectWrapper-concept">ObjectWrapper</a>. Because
-    invoking a mutable python type with an argument of the same type
-    (e.g. <code>list([1,2])</code> typically makes a <em>copy</em> of
-    the argument object, this may be the only way to access the <a
-    href="ObjectWrapper.html#ObjectWrapper-concept">ObjectWrapper</a>'s
-    interface on the original object.
-
-    <h2><a name="classes"></a>Classes</h2>
-
-    <h3><a name="extract-spec"></a>Class template <code>extract</code></h3>
-
-    <p><code>extract&lt;T&gt;</code> can be used to extract a value of
-    an arbitrary C++ type from an instance of <code><a
-    href="object.html#object-spec">object</a></code>. Two usages are supported:
-<ol>
-<li><b><code>extract&lt;T&gt;(o)</code></b> is a temporary object
-which is implicitly convertible to <code>T</code> (explicit conversion
-is also available through the object's function-call
-operator). However, if no conversion is available which can convert
-<code>o</code> to an object of type <code>T</code>, a Python
-<code>TypeError</code> exception will be <a
-href="definitions.html#raise">raised</a>.
-
-<li><b><code>extract&lt;T&gt; x(o);</code></b> constructs an extractor
-whose <code>check()</code> member function can be used to ask whether
-a conversion is available without causing an exception to be thrown.
-</ol>
-
-    <h4><a name="extract-spec-synopsis"></a>Class template <code>extract</code>
-    synopsis</h4>
-<pre>
-namespace boost { namespace python
-{
-  template &lt;class T&gt;
-  struct extract
-  {
-      typedef <i>unspecified</i> result_type;
-
-      extract(PyObject*);
-      extract(object const&amp;);
-
-      result_type operator()() const;
-      operator result_type() const;
-
-      bool check() const;
-  };
-}}
-</pre>
-
-    <h4><a name="extract-spec-ctors"></a>Class <code>extract</code>
-    constructors and destructor</h4>
-<pre>
-extract(PyObject* p);
-extract(object const&amp;);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> The first form requires that <code>p</code> is non-null.</dt>
-
-      <dt><b>Effects:</b>Stores a pointer to the Python object managed
-      by its constructor argument. In particular, the reference
-      count of the object is not incremented. The onus is on the user
-      to be sure it is not destroyed before the extractor's conversion
-      function is called.</dt>
-    </dl>
-
-    <h4><a name="extract-spec-observers"></a>Class <code>extract</code>
-    observer functions</h4>
-<pre>
-result_type operator()() const;
-operator result_type() const;
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Effects:</b> Converts the stored pointer to
-      <code>result_type</code>, which is either <code>T</code> or
-      <code>T const&amp;</code>.
-      </dt>
-
-      <dt><b>Returns:</b> An object of <code>result_type</code>
-      corresponding to the one referenced by the stored pointer.</dt>
-
-      <dt><b>Throws:</b> <code><a
-      href="errors.html#error_already_set-spec">error_already_set</a></code>
-      and sets a <code>TypeError</code> if no such conversion is
-      available. May also emit other unspecified exceptions thrown by
-      the converter which is actually used.</dt>
-    </dl>
-
-<pre>
-bool check() const;
-</pre>
-
-    <dl class="function-semantics">
-
-      <dt><b>Postconditions:</b> None. In particular, note that a
-      return value of <code>true</code> does not preclude an exception
-      being thrown from <code>operator result_type()</code> or
-      <code>operator()()</code>.</dt>
-
-      <dt><b>Returns:</b> <code>false</code> <i>only</i> if no conversion from the
-      stored pointer to <code>T</code> is available.</dt>
-
-    </dl>
-
-
-    <h2><a name="examples"></a>Examples</h2>
-
-<pre>
-#include &lt;cstdio&gt;
-using namespace boost::python;
-int Print(str s)
-{ 
-   // extract a C string from the Python string object
-   char const* c_str = extract&lt;char const*&gt;(s);
-
-   // Print it using printf
-   std::printf(&quot;%s\n&quot;, c_str);
-
-   // Get the Python string's length and convert it to an int
-   return extract&lt;int&gt;(s.attr(&quot;__len__&quot;)())
-}
-</pre>
-
-The following example shows how extract can be used along with
-<code><a
-href="class.html#class_-spec">class_</a>&lt;</code>...<code>&gt;</code>
-to create and access an instance of a wrapped C++ class.
-
-<pre>
-struct X
-{
-   X(int x) : v(x) {}
-   int value() { return v; }
- private:
-   int v;
-};
-
-BOOST_PYTHON_MODULE(extract_ext)
-{
-    object x_class(
-       class_&lt;X&gt;(&quot;X&quot;, init&lt;int&gt;())
-          .def(&quot;value&quot;, &amp;X::value))
-          ;
-        
-    // Instantiate an X object through the Python interface. 
-    // Its lifetime is now managed by x_obj.
-    object x_obj = x_class(3);
-
-    // Get a reference to the C++ object out of the Python object
-    X const&amp; x = extract&lt;X&amp;&gt;(x_obj);
-    assert(x.value() == 3);
-}
-</pre>
-    <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>
-  </body>
-</html>
-

doc/v2/faq.html

@@ -1,166 +1,39 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
 <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">
-
-    <title>Boost.Python - FAQ</title>
-  </head>
-
-  <body link="#0000ff" vlink="#800080">
-    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<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 - FAQ</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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
-
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
-
-          <h2 align="center">Frequently Asked Questions (FAQs)</h2>
-        </td>
-      </tr>
-    </table>
-    <hr>
-
-    <dl class="page-index">
-      <dt><a href="#question1">Is return_internal reference
-      efficient?</a></dt>
-
-      <dt><a href="#question2">How can I wrap containers which take C++
-      containers as arguments?</a></dt>
-    </dl>
-
-    <h2><a name="question1"></a>Is return_internal reference efficient?</h2>
-
-    <blockquote>
-      <b>Q:</b> <i>I have an object composed of 12 doubles. A const&amp; to
-      this object is returned by a member function of another class. From the
-      viewpoint of using the returned object in Python I do not care if I get
-      a copy or a reference to the returned object. In Boost.Python Version 2
-      I have the choice of using copy_const_reference or
-      return_internal_reference. Are there considerations that would lead me
-      to prefer one over the other, such as size of generated code or memory
-      overhead?</i> 
-
-      <p><b>A:</b> copy_const_reference will make an instance with storage
-      for one of your objects, size = base_size + 12 * sizeof(double).
-      return_internal_reference will make an instance with storage for a
-      pointer to one of your objects, size = base_size + sizeof(void*).
-      However, it will also create a weak reference object which goes in the
-      source object's weakreflist and a special callback object to manage the
-      lifetime of the internally-referenced object. My guess?
-      copy_const_reference is your friend here, resulting in less overall
-      memory use and less fragmentation, also probably fewer total
-      cycles.</p>
-    </blockquote>
-
-    <h2><a name="question2"></a>How can I wrap functions which take C++
-    containers as arguments?</h2>
-
-    <p>Ralf W. Grosse-Kunstleve provides these notes:</p>
-
-    <ol>
-      <li>
-        Using the regular <code>class_&lt;&gt;</code> wrapper: 
-<pre>
-class_&lt;std::vector&lt;double&gt; &gt;("std_vector_double")
-  .def(...)
-  ...
-  ;
-</pre>
-        This can be moved to a template so that several types (double, int,
-        long, etc.) can be wrapped with the same code. This technique is used
-        in the file 
-
-        <blockquote>
-          scitbx/include/scitbx/array_family/boost_python/flex_wrapper.h
-        </blockquote>
-        in the "scitbx" package. The file could easily be modified for
-        wrapping std::vector&lt;&gt; instantiations. 
-
-        <p>This type of C++/Python binding is most suitable for containers
-        that may contain a large number of elements (&gt;10000).</p>
-      </li>
-
-      <li>
-        Using custom rvalue converters. Boost.Python "rvalue converters"
-        match function signatures such as: 
-<pre>
-void foo(std::vector&lt;double&gt; const&amp; array); // pass by const-reference
-void foo(std::vector&lt;double&gt; array); // pass by value
-</pre>
-        Some custom rvalue converters are implemented in the file 
-
-        <blockquote>
-          scitbx/include/scitbx/boost_python/container_conversions.h
-        </blockquote>
-        This code can be used to convert from C++ container types such as
-        std::vector&lt;&gt; or std::list&lt;&gt; to Python tuples and vice
-        versa. A few simple examples can be found in the file 
-
-        <blockquote>
-          scitbx/array_family/boost_python/regression_test_module.cpp
-        </blockquote>
-        Automatic C++ container &lt;-&gt; Python tuple conversions are most
-        suitable for containers of moderate size. These converters generate
-        significantly less object code compared to alternative 1 above.
-      </li>
-    </ol>
-    A disadvantage of using alternative 2 is that operators such as
-    arithmetic +,-,*,/,% are not available. It would be useful to have custom
-    rvalue converters that convert to a "math_array" type instead of tuples.
-    This is currently not implemented but is possible within the framework of
-    Boost.Python V2 as it will be released in the next couple of weeks. [ed.:
-    this was posted on 2002/03/10] 
-
-    <p>It would also be useful to also have "custom lvalue converters" such
-    as std::vector&lt;&gt; &lt;-&gt; Python list. These converters would
-    support the modification of the Python list from C++. For example:</p>
-
-    <p>C++:</p>
-<pre>
-void foo(std::vector&lt;double&gt;&amp; array)
-{
-  for(std::size_t i=0;i&lt;array.size();i++) {
-    array[i] *= 2;
-  }
-}
-</pre>
-    Python: 
-<pre>
-&gt;&gt;&gt; l = [1, 2, 3]
-&gt;&gt;&gt; foo(l)
-&gt;&gt;&gt; print l
-[2, 4, 6]
-</pre>
-    Custom lvalue converters require changes to the Boost.Python core library
-    and are currently not available. 
-
-    <p>P.S.:</p>
-
-    <p>The "scitbx" files referenced above are available via anonymous
-    CVS:</p>
-<pre>
-cvs -d:pserver:anonymous@cvs.cctbx.sourceforge.net:/cvsroot/cctbx login
-cvs -d:pserver:anonymous@cvs.cctbx.sourceforge.net:/cvsroot/cctbx co scitbx
-</pre>
-    <hr>
-
-    <p>Revised 
-    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     05 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>
+  <tr> 
+    <td valign="top" width="300"> 
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Frequently Asked Questions (FAQs)</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<dl class="page-index">
+  <dt><a href="#question1">{{question}}</a></dt>
+  <dt><a href="#question2">{{question}}</a></dt>
+</dl>
+<h2><a name="question1"></a>{{question}}</h2>
+<p>{{answer}}</p>
+<h2><a name="question2"></a>{{question}}</h2>
+<p>{{answer}}</p>
+<hr>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 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/handle.html

@@ -1,322 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<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">
-
-    <title>Boost.Python - &lt;boost/python/handle.hpp&gt;</title>
-
-    <style type="text/css">
- p.c4 {font-style: italic}
- span.c3 {color: #ff0000}
- h2.c2 {text-align: center}
- h1.c1 {text-align: center}
-    </style>
-  </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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
-
-        <td valign="top">
-          <h1 class="c1">Boost.Python</h1>
-
-          <h2 class="c2">Header &lt;boost/python/handle.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="#handle-spec">Class template
-          <code>handle</code></a></dt>
-
-          <dd>
-            <dl class="page-index">
-              <dt><a href="#handle-spec-synopsis">Class <code>handle</code>
-              synopsis</a></dt>
-
-              <dt><a href="#handle-spec-ctors">Class <code>handle</code>
-              constructors and destructor</a></dt>
-
-              <dt><a href="#handle-spec-modifiers">Class <code>handle</code>
-              modifier functions</a></dt>
-
-              <dt><a href="#handle-spec-observers">Class <code>handle</code>
-              observer functions</a></dt>
-            </dl>
-          </dd>
-        </dl>
-      </dd>
-
-      <dt><a href="#functions">Functions</a></dt>
-
-      <dd>
-        <dl class="page-index">
-          <dt><a href="#borrowed-spec"><code>borrowed</code></a></dt>
-
-          <dt><a href="#allow_null-spec"><code>allow_null</code></a></dt>
-        </dl>
-      </dd>
-
-    </dl>
-    <hr>
-
-    <h2><a name="introduction"></a>Introduction</h2>
-
-    <p><code>&lt;boost/python/handle.hpp&gt;</code> provides
-    <code>class&nbsp;template&nbsp;handle</code>, a smart pointer for
-    managing reference-counted Python objects.</p>
-
-    <h2><a name="classes"></a>Classes</h2>
-
-    <h3><a name="handle-spec"></a>Class template <code>handle</code></h3>
-
-    <p><code>handle</code> is a smart pointer to a Python object type; it
-    holds a pointer of type <code>T*</code>, where T is its template
-    parameter. <code>T</code> must be either a type derived from
-    <code>PyObject</code> or a <a href="definitions.html#POD">POD</a>
-    type whose initial <code>sizeof(PyObject)</code> bytes are
-    layout-compatible with <code>PyObject</code>. Use
-    <code>handle&lt;&gt;</code> at the boundary between tehe
-    Python/'C' API and high-level code; prefer <code><a
-    href="object.html#object-spec">object</a></code> for a generalized
-    interface to Python objects.
-
-    <p><a name="upcast"></a>In this document, the term "upcast" refers to an
-    operation which converts a pointer <code>Y*</code> to a base class
-    pointer <code>T*</code> via <code>static_cast&lt;T*&gt;</code> if
-    <code>Y</code> is derived from <code>T</code>, or via C-style cast
-    <code>(T*)</code> if it is not. However, in the latter case the "upcast"
-    is ill-formed if the initial <code>sizeof(PyObject)</code> bytes of
-    <code>Y</code> are not layout-compatible with <code>PyObject</code>.</p>
-
-    <h4><a name="handle-spec-synopsis"></a>Class template handle
-    synopsis</h4>
-<pre>
-namespace boost { namespace python
-{
-  template &lt;class T&gt;
-  class handle
-  {
-      typedef <i>unspecified-member-function-pointer</i> bool_type;
-
-   public: // types
-      typedef T element_type;
-
-   public: // member functions
-      ~handle();
-
-      template &lt;class Y&gt;
-      explicit handle(detail::borrowed&lt;null_ok&lt;Y&gt; &gt;* p);
-
-      template &lt;class Y&gt;
-      explicit handle(null_ok&lt;detail::borrowed&lt;Y&gt; &gt;* p);
-
-      template &lt;class Y&gt;
-      explicit handle(detail::borrowed&lt;Y&gt;* p);
-
-      template &lt;class Y&gt;
-      explicit handle(null_ok&lt;Y&gt;* p);
-
-      template &lt;class Y&gt;
-      explicit handle(Y* p);
-
-      handle();
-
-      handle&amp; operator=(handle const&amp; r);
-
-      template&lt;typename Y&gt;
-      handle&amp; operator=(handle&lt;Y&gt; const &amp; r); // never throws
-
-
-      template &lt;typename Y&gt;
-      handle(handle&lt;Y&gt; const&amp; r);
-
-      handle(handle const&amp; r);
-
-      T* operator-&gt; () const;
-      T&amp; operator* () const;
-      T* get() const;
-      T* release();
-
-      operator bool_type() const; // never throws
-   private:
-      T* m_p;
-  };
-  
-  template &lt;class T&gt; struct null_ok;
-  namespace detail { template &lt;class T&gt; struct borrowed; }
-}}
-</pre>
-
-    <h4><a name="handle-spec-ctors">Class <code>handle</code> constructors
-    and destructor</a></h4>
-<pre>
-virtual ~handle();
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Effects:</b> <code>Py_XDECREF(m_p)</code></dt>
-    </dl>
-<pre>
-template &lt;class Y&gt;
-explicit handle(detail::borrowed&lt;null_ok&lt;Y&gt; &gt;* p);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Effects:</b> <code>Py_XDECREF(m_p)</code></dt>
-    </dl>
-<pre>
-template &lt;class Y&gt;
-explicit handle(null_ok&lt;detail::borrowed&lt;Y&gt; &gt;* p);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Effects:</b>
-      <code>m_p&nbsp;=&nbsp;</code><i>upcast</i><code>&lt;T*&gt;(p);</code></dt>
-    </dl>
-<pre>
-template &lt;class Y&gt;
-explicit handle(detail::borrowed&lt;Y&gt;* p);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Effects:</b>
-      <code>m_p&nbsp;=&nbsp;</code><i>upcast</i><code>&lt;T*&gt;(<a href=
-      "errors.html#expect_non_null-spec">expect_non_null</a>(p));</code></dt>
-    </dl>
-<pre>
-template &lt;class Y&gt;
-explicit handle(null_ok&lt;Y&gt;* p);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Effects:</b>
-      <code>Py_XINCREF(p);&nbsp;m_p&nbsp;=&nbsp;</code><i>upcast</i><code>&lt;T*&gt;(p);</code></dt>
-    </dl>
-<pre>
-template &lt;class Y&gt;
-explicit handle(Y* p);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Effects:</b>
-      <code>Py_XINCREF(p);&nbsp;m_p&nbsp;=&nbsp;</code><i>upcast</i><code>&lt;T*&gt;(<a
-       href=
-      "errors.html#expect_non_null-spec">expect_non_null</a>(p));</code></dt>
-    </dl>
-<pre>
-handle();
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Effects:</b> <code>m_p&nbsp;=&nbsp;0;</code></dt>
-    </dl>
-<pre>
-template &lt;typename Y&gt;
-handle(handle&lt;Y&gt; const&amp; r);
-handle(handle const&amp; r);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Effects:</b>
-      <code>m_p&nbsp;=&nbsp;r.m_p;&nbsp;Py_XINCREF(m_p);</code></dt>
-    </dl>
-
-    <h4><a name="handle-spec-modifiers">Class <code>handle</code>
-    modifiers</a></h4>
-<pre>
-handle&amp; operator=(handle const&amp; r);
-template&lt;typename Y&gt;
-handle&amp; operator=(handle&lt;Y&gt; const &amp; r); // never throws
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Effects:</b>
-      <code>Py_XINCREF(r.m_p);&nbsp;Py_XDECREF(m_p);&nbsp;m_p&nbsp;=&nbsp;r.m_p;</code></dt>
-    </dl>
-<pre>
-T* release();
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Effects:</b> <code>T* x = m_p;&nbsp;m_p&nbsp;=&nbsp;0;return
-      x;</code></dt>
-    </dl>
-
-    <h4><a name="handle-spec-observers">Class <code>handle</code>
-    observers</a></h4>
-<pre>
-T* operator-&gt; () const;
-T* get() const;
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Returns:</b> <code>m_p;</code></dt>
-    </dl>
-<pre>
-T&amp; operator* () const;
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Returns:</b> <code>*m_p;</code></dt>
-    </dl>
-<pre>
-operator bool_type() const; // never throws
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Returns:</b> 0 if <code>m_p&nbsp;==&nbsp;0</code>, a pointer
-      convertible to <code>true</code> otherwise.</dt>
-    </dl>
-
-    <h2><a name="functions"></a>Functions</h2>
-
-    <h3><a name="borrowed-spec"></a><code>borrowed</code></h3>
-<pre>
-template <class T>
-detail::borrowed<T>* borrowed(T* p)
-{
-    return (detail::borrowed<T>*)p;
-}
-</pre>
-
-    <h3><a name="allow_null-spec"></a><code>allow_null</code></h3>
-
-<pre>
-template <class T>
-null_ok<T>* allow_null(T* p)
-{
-    return (null_ok<T>*)p;
-}
-</pre>
-
-
-    <p>Revised 
-    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     03 October, 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-    </p>
-
-    <p class="c4">&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</p>
-  </body>
-</html>
-

doc/v2/has_back_reference.html

@@ -1,82 +1,77 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<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">
+    <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/has_back_reference.hpp&gt;</title>
-
-    <style type="text/css">
+    <title>Boost.Python -
+    &lt;boost/python/has_back_reference.hpp&gt;</title>
+<style type="text/css">
  p.c3 {font-style: italic}
  h2.c2 {text-align: center}
  h1.c1 {text-align: center}
-            </style>
-  </head>
+</style>
 
-  <body>
-    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
-    "header">
+    <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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
+          <h3><a href="../../../../index.htm"><img height="86"
+          width="277" alt="C++ Boost" src= 
+          "../../../../c++boost.gif" border="0"></a></h3>
 
         <td valign="top">
           <h1 class="c1">Boost.Python</h1>
 
           <h2 class="c2">Header
           &lt;boost/python/has_back_reference.hpp&gt;</h2>
-        </td>
-      </tr>
     </table>
     <hr>
 
     <h2>Contents</h2>
 
     <dl class="page-index">
-      <dt><a href="#introduction">Introduction</a></dt>
+      <dt><a href="#introduction">Introduction</a>
 
-      <dt><a href="#classes">Classes</a></dt>
+      <dt><a href="#classes">Classes</a>
 
       <dd>
         <dl class="page-index">
           <dt><a href="#has_back_reference-spec">Class template
-          <code>has_back_reference</code></a></dt>
+          <code>has_back_reference</code></a>
 
           <dd>
             <dl class="page-index">
-              <dt><a href="#has_back_reference-spec-synopsis">Class template
-              <code>has_back_reference</code> synopsis</a></dt>
+              <dt><a href=
+              "#has_back_reference-spec-synopsis">Class template
+              <code>has_back_reference</code> synopsis</a>
             </dl>
-          </dd>
 
-          <dt><a href="#examples">Example(s)</a></dt>
+          <dt><a href="#examples">Example(s)</a>
         </dl>
-      </dd>
     </dl>
     <hr>
 
     <h2><a name="introduction"></a>Introduction</h2>
 
-    <p><code>&lt;boost/python/has_back_reference.hpp&gt;</code> defines the
-    traits class template <code>has_back_reference&lt;&gt;</code>, which can
-    be specialized by the user to indicate that a wrapped class instance
-    holds a <code>PyObject*</code> corresponding to a Python object.</p>
+    <p><code>&lt;boost/python/has_back_reference.hpp&gt;</code>
+    defines the traits class template
+    <code>has_back_reference&lt;&gt;</code>, which can be
+    specialized by the user to indicate that a wrapped class
+    instance holds a <code>PyObject*</code> corresponding to a
+    Python object.
 
     <h2><a name="classes"></a>Classes</h2>
 
     <h3><a name="has_back_reference-spec"></a>Class template
     <code>has_back_reference</code></h3>
 
-    <p>A unary metafunction whose <code>value</code> is true iff its argument
-    is a <code>pointer_wrapper&lt;&gt;</code>.</p>
+    <p>A unary metafunction whose <code>value</code> is true iff
+    its argument is a <code>pointer_wrapper&lt;&gt;</code>.
 
-    <h4><a name="has_back_reference-spec-synopsis"></a>Class template
-    <code>has_back_reference</code> synopsis</h4>
+    <h4><a name="has_back_reference-spec-synopsis"></a>Class
+    template <code>has_back_reference</code> synopsis</h4>
 <pre>
 namespace boost { namespace python
 {
@@ -87,33 +82,36 @@ namespace boost { namespace python
 }}
 </pre>
 
-    <p>A "<a href="../../../../more/generic_programming.html#traits">traits
-    class</a>" which is inspected by Boost.Python to determine how wrapped
-    classes can be constructed.</p>
+    <p>A &quot;<a href= 
+    "../../../../more/generic_programming.html#traits">traits
+    class</a>&quot; which is inspected by Boost.Python to
+    determine how wrapped classes can be constructed.
 
     <dl class="traits-semantics">
-      <dt><code>value</code> is an integral constant convertible to bool of
-      unspecified type.</dt>
+
+      <dt><code>value</code> is an integral constant convertible
+      to bool of unspecified type.
 
       <dt>Specializations may substitute a value convertible to
-      <code>true</code> for <code>value</code> iff for each invocation of
-      <code>class_&lt;WrappedClass&gt;::def(init&lt;</code><i>type-sequence...</i><code>
-      &gt;())</code>, there exists a corresponding constructor
-      <code>WrappedClass::WrappedClass(PyObject*,&nbsp;</code><i>type-sequence...</i>
-      <code>)</code>. If such a specialization exists, the
-      <code>WrappedClass</code> constructors will be called with a "back
-      reference" pointer to the corresponding Python object whenever they are
-      invoked from Python.</dt>
+ <code>true</code> for <code>value</code> iff for each invocation of
+ <code>class_&lt;WrappedClass&gt;::def_init(args&lt;</code><i>type-sequence...</i><code>&gt;())</code>,
+ there exists a corresponding constructor
+ <code>WrappedClass::WrappedClass(PyObject*,&nbsp;</code><i>type-sequence...</i><code>)</code>. If
+ such a specialization exists, the <code>WrappedClass</code>
+ constructors will be called with a &quot;back reference&quot; pointer
+ to the corresponding Python object whenever they are invoked from
+ Python.
+
     </dl>
 
     <h2><a name="examples"></a>Example</h2>
 
-    <h3>C++ module definition</h3>
+<h3>C++ module definition</h3>
+
 <pre>
 #include &lt;boost/python/class.hpp&gt;
 #include &lt;boost/python/module.hpp&gt;
 #include &lt;boost/python/has_back_reference.hpp&gt;
-#include &lt;boost/python/handle.hpp&gt;
 #include &lt;boost/shared_ptr.hpp&gt;
 
 using namespace boost::python;
@@ -123,7 +121,7 @@ struct X
     X(PyObject* self) : m_self(self), m_x(0) {}
     X(PyObject* self, int x) : m_self(self), m_x(x) {}
     
-    handle&lt;&gt; self() { return handle&lt;&gt;(borrowed(m_self)); }
+    PyObject* self() { return m_self; }
     int get() { return m_x; }
     void set(int x) { m_x = x; }
 
@@ -153,29 +151,36 @@ struct Y
 
 boost::shared_ptr&lt;Y&gt; Y_self(boost::shared_ptr&lt;Y&gt; self) const { return self; }
 
-BOOST_PYTHON_MODULE(back_references)
+BOOST_PYTHON_MODULE_INIT(back_references)
 {
-    class_&lt;X&gt;("X")
-       .def(init&lt;int&gt;())
-       .def("self", &amp;X::self)
-       .def("get", &amp;X::get)
-       .def("set", &amp;X::set)
-       ;
-
-    class_&lt;Y, shared_ptr&lt;Y&gt; &gt;("Y")
-       .def(init&lt;int&gt;())
-       .def("get", &amp;Y::get)
-       .def("set", &amp;Y::set)
-       .def("self", Y_self)
-       ;
+    module(&quot;back_references&quot;)
+        .add(
+            class_&lt;X&gt;(&quot;X&quot;)
+               .def_init()
+               .def_init(args&lt;int&gt;())
+               .def(&quot;self&quot;, &amp;X::self)
+               .def(&quot;get&quot;, &amp;X::get)
+               .def(&quot;set&quot;, &amp;X::set)
+            )
+        .add(
+            class_&lt;Y, shared_ptr&lt;Y&gt; &gt;(&quot;Y&quot;)
+               .def_init()
+               .def_init(args&lt;int&gt;())
+               .def(&quot;get&quot;, &amp;Y::get)
+               .def(&quot;set&quot;, &amp;Y::set)
+               .def(&quot;self&quot;, Y_self)
+            )
+        ;
 }
 </pre>
-    The following Python session illustrates that <code>x.self()</code>
-    returns the same Python object on which it is invoked, while
-    <code>y.self()</code> must create a new Python object which refers to the
-    same Y instance. 
 
-    <h3>Python code</h3>
+The following Python session illustrates that <code>x.self()</code>
+returns the same Python object on which it is invoked, while
+<code>y.self()</code> must create a new Python object which refers to
+the same Y instance.
+
+<h3>Python code</h3>
+
 <pre>
 &gt;&gt;&gt; from back_references import *
 &gt;&gt;&gt; x = X(1)
@@ -202,13 +207,11 @@ BOOST_PYTHON_MODULE(back_references)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 September, 2002 
+     07 May, 2002 
     <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-    </p>
 
-    <p class="c3">&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</p>
-  </body>
-</html>
+
+    <p class="c3">&copy; Copyright <a href= 
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a>
+    2002. All Rights Reserved. 
 

doc/v2/implicit.html

@@ -1,60 +1,51 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-  <head>
-    <meta name="generator" content=
-    "HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
+    <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/implicit.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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
         <td valign="top">
           <h1 align="center">Boost.Python</h1>
 
           <h2 align="center">Header &lt;boost/python/implicit.hpp&gt;</h2>
-        </td>
-      </tr>
     </table>
     <hr>
 
     <h2>Contents</h2>
 
-    <dl class="page-index">
-      <dt><a href="#introduction">Introduction</a></dt>
+    <dl function="page-index">
+      <dt><a href="#introduction">Introduction</a>
 
-      <dt><a href="#functions">Functions</a></dt>
+
+      <dt><a href="#functions">Functions</a>
 
       <dd>
-        <dl class="page-index">
-          <dt><a href="#implicitly_convertible-spec">Function Template
-          <code>implicitly_convertible</code></a></dt>
-        </dl>
-      </dd>
+        <dl function="page-index">
+          <dt><a href="#implicitly_convertible-spec">Function Template <code>implicitly_convertible</code></a>
 
-      <dt><a href="#examples">Example</a></dt>
+        </dl>
+
+      <dt><a href="#examples">Example</a>
     </dl>
     <hr>
 
     <h2><a name="introduction"></a>Introduction</h2>
-    <code>implicitly_convertible</code> allows Boost.Python to implicitly
-    take advantage of a C++ implicit or explicit conversion when matching
-    Python objects to C++ argument types. 
+
+    <code>implicitly_convertible</code> allows Boost.Python to
+    implicitly take advantage of a C++ implicit or explicit conversion
+    when matching Python objects to C++ argument types.
 
     <h2><a name="functions"></a>Functions</h2>
 
-    <h3><a name="implicitly_convertible-spec"></a>Function template
-    <code>implicitly_convertible</code></h3>
+    <h3><a name="implicitly_convertible-spec"></a>Function template <code>implicitly_convertible</code></h3>
 <pre>
 template &lt;class Source, class Target&gt;
 void implicitly_convertible();
@@ -64,42 +55,40 @@ void implicitly_convertible();
       <caption>
         <b><code>implicitly_convertible</code> template parameters</b><br>
       </caption>
+      <tr>
+        <th>Parameter
+        <th>Description
 
       <tr>
-        <th>Parameter</th>
-
-        <th>Description</th>
-      </tr>
+        <td><code>Source</code> 
+        <td>The source type of the implicit conversion
 
       <tr>
-        <td><code>Source</code></td>
-
-        <td>The source type of the implicit conversion</td>
-      </tr>
-
+        <td><code>Target</code> 
+        <td>The target type of the implicit conversion
       <tr>
-        <td><code>Target</code></td>
-
-        <td>The target type of the implicit conversion</td>
-      </tr>
     </table>
 
     <dl class="function-semantics">
-      <dt><b>Requires:</b> The declaration <code>Target t(s);</code>, where
-      <code>s</code> is of type <code>Source</code>, is valid.</dt>
+      <dt><b>Requires:</b> The expression <code>Target(s)</code>,
+      where <code>s</code> is of type <code>Source</code>, is valid.
 
       <dt><b>Effects:</b> registers an rvalue <code>from_python</code>
       converter to <code>Target</code> which can succeed for any
-      <code>PyObject*&nbsp;p</code> iff there exists any registered converter
-      which can produce <code>Source</code> rvalues</dt>
+      <code>PyObject*&nbsp;p</code> iff there exists any registered
+      converter which can produce <code>Source</code> rvalues
 
-      <dt><b>Rationale:</b> C++ users expect to be able to take advantage of
-      the same sort of interoperability in Python as they do in C++.</dt>
+      <dt><b>Rationale:</b> C++ users expect to be able to take
+      advantage of the same sort of interoperability in Python as they
+      do in C++.
     </dl>
 
+
     <h2><a name="examples"></a>Example</h2>
 
-    <h3>C++ module definition</h3>
+
+<h3>C++ module definition</h3>
+
 <pre>
 #include &lt;boost/python/class.hpp&gt;
 #include &lt;boost/python/implicit.hpp&gt;
@@ -121,21 +110,23 @@ int x_value(X const&amp; x)
 
 X make_x(int n) { return X(n); }
 
-BOOST_PYTHON_MODULE(implicit_ext)
+BOOST_PYTHON_MODULE_INIT(implicit_ext)
 {
-    def("x_value", x_value);
-    def("make_x", make_x);
-
-    class_&lt;X&gt;("X", 
-        init&lt;int&gt;())
+    module(&quot;implicit_ext&quot;)
+        .def(&quot;x_value&quot;, x_value)
+        .def(&quot;make_x&quot;, make_x)
+        .add(
+            class_&lt;X&gt;(&quot;X&quot;)
+            .def_init(args&lt;int&gt;())
+            )
         ;
-
     implicitly_convertible&lt;X,int&gt;();
     implicitly_convertible&lt;int,X&gt;();
 }
 </pre>
 
-    <h3>Python code</h3>
+<h3>Python code</h3>
+
 <pre>
 &gt;&gt;&gt; from implicit_ext import *
 &gt;&gt;&gt; x_value(X(42))
@@ -149,13 +140,10 @@ BOOST_PYTHON_MODULE(implicit_ext)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 September, 2002 
+     08 May, 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>
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
 

doc/v2/index.html

@@ -1,17 +1,43 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
-
 <html>
-  <head>
-    <meta name="generator" content=
-    "HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
-    <meta http-equiv="refresh" content="0; URL=../index.html">
-
-    <title></title>
-  </head>
-
-  <body>
-    Automatic redirection failed, please go to <a href=
-    "../index.html">../index.html</a>.
-  </body>
+<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</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="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Index</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<h2>Contents</h2>
+<dl class="index">
+  <dt><a href="overview.html">Overview</a></dt>
+  <dt><a href="reference.html">Reference</a></dt>
+  <dt><a href="configuration.html">Configuration Information</a></dt>
+  <dt><a href="rationale.html">Rationale</a></dt>
+  <dt><a href="definitions.html">Definitions</a></dt>
+  <dt><a href="faq.html">Frequently Asked Questions (FAQs)</a></dt>
+  <dt><a href="progress_reports.html">Progress Reports</a></dt>
+  <dt><a href="bibliography.html">Bibliography</a></dt>
+  <dt><a href="acknowledgments.html">Acknowledgments</a></dt>
+</dl>
+<hr>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 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/init.html

@@ -1,249 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<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">
-
-    <title>Boost.Python - &lt;boost/python/init.hpp&gt;</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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
-
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
-
-          <h2 align="center">Headers &lt;boost/python/init.hpp&gt;</h2>
-        </td>
-      </tr>
-    </table>
-    <hr>
-
-    <h2>Contents</h2>
-
-    <dl class="page-index">
-      <dt><a href="#introduction">Introduction</a></dt>
-
-              <dt><a href=
-              "#init-expressions"><em>init-expressions</em></a></dt>
-
-      <dt><a href="#classes">Classes</a></dt>
-
-      <dd>
-        <dl class="page-index">
-          <dt><a href="#init-spec">Class template <code>init</code></a></dt>
-
-          <dd>
-            <dl class="page-index">
-              <dt><a href="#init-spec-synopsis">Class template
-              <code>init</code> synopsis</a></dt>
-
-              <dt><a href="#init-spec-ctors">Class <code>init</code>
-              constructors</a></dt>
-
-            </dl>
-          </dd>
-
-          <dt><a href="#optional-spec">Class template
-          <code>optional</code></a></dt>
-
-          <dd>
-            <dl class="page-index">
-              <dt><a href="#optional-spec-synopsis">Class template
-              <code>optional</code> synopsis</a></dt>
-            </dl>
-          </dd>
-        </dl>
-      </dd>
-
-      <dt><a href="#examples">Example(s)</a></dt>
-    </dl>
-    <hr>
-
-    <h2><a name="introduction"></a>Introduction</h2>
-
-    <p><code>&lt;boost/python/init.hpp&gt;</code> defines the interface for
-    exposing C++ constructors to Python as extension class
-    <code>__init__</code> functions.</p>
-
-    <h2><a name="init-expressions"><em>init-expressions</em></a></h2>
-    An <em>init-expression</em> is used to describe a family of
-    <code>__init__</code> methods to be generated for an extension class, and
-    the result has the following properties: 
-
-    <blockquote>
-      <dl class="properties">
-        <dt><b>docstring:</b> An <a href="definitions.html#ntbs">ntbs</a>
-        whose value will bound to the method's <code>__doc__</code>
-        attribute</dt>
-
-        <dt><b>keywords:</b> A <a href=
-        "args.html#keyword-expression">keyword-expression</a> which will be
-        used to name (a trailing subsequence of) the arguments to the
-        generated <code>__init__</code> function(s).</dt>
-
-        <dt><b>call policies:</b> An instance of a model of <a href=
-        "CallPolicies.html">CallPolicies</a>.</dt>
-
-        <dt><b>argument types:</b> An MPL sequence of C++ argument types
-        which will be used to construct the wrapped C++ object. An init
-        expression has one or more 
-        <b>valid prefixes</b> which are given by a sequence of
-        prefixes of its argument types.</dt>
-      </dl>
-    </blockquote>
-
-    <h2><a name="classes"></a>Classes</h2>
-
-    <h3><a name="init-spec"></a>Class template <code>init&lt;T1 =</code>
-    <i>unspecified</i><code>,&nbsp;T2 =</code>
-    <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
-    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=
-    "#optional-spec"><code>optional</code></a><code>&lt;</code>...<code>&gt;</code>.</p>
-
-    <h4><a name="init-spec-synopsis"></a>Class template <code>init</code>
-    synopsis</h4>
-<pre>
-namespace boost { namespace python
-{
-  template &lt;T1 = <i>unspecified</i>,...T<i>n</i> = <i>unspecified</i>&gt;
-  struct init
-  {
-      init(char const* doc = 0);
-      template &lt;class Keywords&gt; init(Keywords const&amp; kw, char const* doc = 0);
-      template &lt;class Keywords&gt; init(char const* doc, Keywords const&amp; kw);
-
-      template &lt;class CallPolicies&gt;
-      <em>unspecified</em> operator[](CallPolicies const&amp; policies) const
-  };
-}}
-</pre>
-
-    <h4><a name="init-spec-ctors"></a>Class template <code>init</code>
-    constructors</h4>
-<pre>
-init(char const* doc = 0);
-template &lt;class Keywords&gt; init(Keywords const&amp; kw, char const* doc = 0);
-template &lt;class Keywords&gt; init(char const* doc, Keywords const&amp; kw);
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> If supplied, <code>doc</code> is an <a href=
-      "definitions.html#ntbs">ntbs</a>. If supplied, <code>kw</code> is the
-      result of a <a href="args.html#keyword-expression"></a></dt>
-
-      <dt><b>Effects:</b> The result is an <em>init-expression</em> whose
-      <em>docstring</em> is <code>doc</code> and whose <em>keywords</em> are
-      a reference to <code>kw</code>. If the first form is used, the
-      resulting expression's <em>keywords</em> are empty. The expression's
-      <em>call policies</em> are an instance of <a href=
-      "default_call_policies.html#default_call_policies-spec">default_call_policies</a>.
-      If <code>T</code><i><small>n</small></i> is <a href=
-      "#optional-spec"><code>optional</code></a><code>&lt;U1,&nbsp;U2,</code>...
-      <code>U</code><small><i>m</i></small><code>&gt;</code>, the
-      expression's <em>valid prefixes</em> are given by:</dt>
-
-      <dd>
-        <blockquote>
-          (<code>T1,&nbsp;T2,</code>...<code>T</code><i><small>n-1</small></i>),
-          (<code>T1,&nbsp;T2,</code>...<code>T</code><i><small>n-1</small></i>
-          <code>,&nbsp;U1</code>),
-          (<code>T1,&nbsp;T2,</code>...<code>T</code><i><small>n-1</small></i>
-          <code>,&nbsp;U1,&nbsp;U2</code>),
-          ...(<code>T1,&nbsp;T2,</code>...<code>T</code><i><small>n-1</small></i>
-          <code>,&nbsp;U1,&nbsp;U2,</code>...<code>U</code><i><small>m</small></i>).
-        </blockquote>
-        Otherwise, the expression has one <em>valid prefix</em> given by the
-        the template arguments the user specified.
-      </dd>
-    </dl>
-
-    <h4><a name="init-spec-observers"></a>Class template <code>init</code>
-    observer functions</h4>
-<pre>
-template &lt;class Policies&gt;
-<em>unspecified</em> operator[](Policies const&amp; policies) const
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Requires:</b> Policies is a model of <a href=
-      "CallPolicies.html">CallPolicies</a>.</dt>
-
-      <dt><b>Effects:</b> Returns a new <a href=
-      "#init-expressions"><em>init-expression</em></a> with all the same
-      properties as the <code>init</code> object except that its <em>call
-      policies</em> are replaced by a reference to
-      <code>policies</code>.</dt>
-    </dl>
-
-    <h3><a name="optional-spec"></a>Class template <code>optional&lt;T1
-    =</code> <i>unspecified</i><code>,&nbsp;T2 =</code>
-    <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
-    can be used to specify the optional arguments to an <code>__init__</code>
-    function.</p>
-
-    <h4><a name="optional-spec-synopsis"></a>Class template
-    <code>optional</code> synopsis</h4>
-<pre>
-namespace boost { namespace python
-{
-  template &lt;T1 = <i>unspecified</i>,...T<i>n</i> = <i>unspecified</i>&gt;
-  struct optional {};
-}}
-</pre>
-
-    <h2><a name="examples"></a>Example(s)</h2>
-
-    <p>Given the C++ declarations:</p>
-<pre>
-class Y;
-class X
-{
- public:
-   X(int x, Y* y) : m_y(y) {}
-   X(double);
- private:
-   Y* m_y;
-};
-</pre>
-    A corresponding Boost.Python extension class can be created with: 
-<pre>
-using namespace boost::python;
-
-class_&lt;X&gt;("X", "This is X's docstring.",
-          init&lt;int,char const*&gt;(args("x","y"), "X.__init__'s docstring")[
-                with_custodian_and_ward&lt;1,3&gt;()]
-          )
-   .def(init&lt;double&gt;())
-   ;
-</pre>
-    <hr>
-    Revised 
-    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     1 October, 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></p>
-  </body>
-</html>
-

doc/v2/iterator.html

@@ -1,239 +1,216 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-  <head>
-    <meta name="generator" content=
-    "HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
+    <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/iterator.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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
         <td valign="top">
           <h1 align="center">Boost.Python</h1>
 
           <h2 align="center">Header &lt;boost/python/iterator.hpp&gt;</h2>
-        </td>
-      </tr>
     </table>
     <hr>
 
     <h2>Contents</h2>
 
     <dl class="page-index">
-      <dt><a href="#introduction">Introduction</a></dt>
+      <dt><a href="#introduction">Introduction</a>
 
-      <dt><a href="#classes">Classes</a></dt>
+      <dt><a href="#classes">Classes</a>
 
       <dd>
         <dl class="page-index">
-          <dt><a href="#iterator-spec">Class template
-          <code>iterator</code></a></dt>
+          <dt><a href="#iterator-spec">Class template <code>iterator</code></a>
 
           <dd>
             <dl class="page-index">
               <dt><a href="#iterator-spec-synopsis">Class
-              <code>iterator</code> synopsis</a></dt>
+              <code>iterator</code> synopsis</a>
 
-              <dt><a href="#iterator-spec-ctors">Class template
-              <code>iterator</code> constructor</a></dt>
+              <dt><a href="#iterator-spec-ctors">Class template <code>iterator</code>
+              constructor</a>
             </dl>
-          </dd>
-        </dl>
+         </dl>
 
         <dl class="page-index">
-          <dt><a href="#iterators-spec">Class template
-          <code>iterators</code></a></dt>
+          <dt><a href="#iterators-spec">Class template <code>iterators</code></a>
 
           <dd>
             <dl class="page-index">
               <dt><a href="#iterators-spec-synopsis">Class
-              <code>iterators</code> synopsis</a></dt>
-
+              <code>iterators</code> synopsis</a>
               <dt><a href="#iterators-spec-types">Class template
-              <code>iterators</code> nested types</a></dt>
-
+              <code>iterators</code> nested types</a>
               <dt><a href="#iterators-spec-statics">Class template
-              <code>iterators</code> static functions</a></dt>
+              <code>iterators</code> static functions</a>
             </dl>
-          </dd>
         </dl>
-      </dd>
 
-      <dt><a href="#functions">Functions</a></dt>
+      <dt><a href="#functions">Functions</a>
 
       <dd>
         <dl class="page-index">
-          <dt><a href="#range-spec">range</a></dt>
+          <dt><a href="#range-spec">range</a>
         </dl>
-      </dd>
 
-      <dt><a href="#examples">Examples</a></dt>
+      <dt><a href="#examples">Examples</a>
     </dl>
     <hr>
 
     <h2><a name="introduction"></a>Introduction</h2>
 
-    <p><code>&lt;boost/python/iterator.hpp&gt;</code> provides types and
-    functions for creating <a href=
-    "http://www.python.org/doc/current/lib/typeiter.html">Python
-    iterators</a> from <a href=
-    "http://www.sgi.com/tech/stl/Container.html">C++ Containers</a> and <a
+    <p><code>&lt;boost/python/iterator.hpp&gt;</code> provides types
+    and functions for creating <a
+    href="http://www.python.org/doc/current/lib/typeiter.html">Python
+    iterators</a> from <a
+    href="http://www.sgi.com/tech/stl/Container.html">C++
+    Containers</a> and <a
     href="http://www.sgi.com/tech/stl/Iterators.html">Iterators</a>. Note
     that if your <code>class_</code> supports random-access iterators,
-    implementing <code><a href=
-    "http://www.python.org/doc/current/ref/sequence-types.html#l2h-128">__getitem__</a></code>
-    (also known as the Sequence Protocol) may serve you better than using
-    this facility: Python will automatically create an iterator type for you
-    (see <a href=
-    "http://www.python.org/doc/current/lib/built-in-funcs.html#l2h-35">iter()</a>),
-    and each access can be range-checked, leaving no possiblity of accessing
-    through an invalidated C++ iterator.</p>
+    implementing 
+    <code><a
+    href="http://www.python.org/doc/current/ref/sequence-types.html#l2h-128">__getitem__</a></code>
+    (also known as the Sequence Protocol) may serve you better than
+    using this facility: Python will automatically create an iterator
+    type for you (see <a
+    href="http://www.python.org/doc/current/lib/built-in-funcs.html#l2h-35">iter()</a>),
+    and each access can be range-checked, leaving no possiblity of
+    accessing through an invalidated C++ iterator.
 
     <h2><a name="classes"></a>Classes</h2>
 
     <h3><a name="iterator-spec"></a>Class Template <code>iterator</code></h3>
 
-    <p>Instances of <code>iterator&lt;C,P&gt;</code> hold a reference to a
-    callable Python object which, when invoked from Python, expects a single
-    argument <code>c</code> convertible to <code>C</code> and creates a
-    Python iterator that traverses [<code>c.begin()</code>,
-    <code>c.end()</code>). The optional <a href=
-    "CallPolicies.html">CallPolicies</a> <code>P</code> can be used to
-    control how elements are returned during iteration.</p>
+    <p>Instances of <code>iterator&lt;C,P&gt;</code> hold a reference
+    to a callable Python object which, when invoked from Python,
+    expects a single argument <code>c</code> convertible to
+    <code>C</code> and creates a Python iterator that traverses
+    [<code>c.begin()</code>,
+    <code>c.end()</code>). The optional <a
+    href="CallPolicies.html">CallPolicies</a>
+    <code>P</code> can be used to control how elements are returned
+    during iteration.
 
-    <p>In the table below, <code><b>c</b></code> is an instance of
-    <code>Container</code>.</p>
+    <p>In the table below, <code><b>c</b></code> is an instance of <code>Container</code>.
 
     <table border="1" summary="iterator template parameters">
       <tr>
-        <th>Template Parameter</th>
+        <th>Template Parameter
 
-        <th>Requirements</th>
+        <th>Requirements
 
-        <th>Semantics</th>
+        <th>Semantics
 
-        <th>Default</th>
-      </tr>
+        <th>Default
 
       <tr>
-        <td><code>Container</code></td>
+        <td><code>Container</code> 
 
-        <td>[c.begin(),c.end()) is a valid <a href=
-        "http://www.sgi.com/tech/stl/Iterators.html">Iterator range</a>.</td>
+        <td>[c.begin(),c.end()) is a valid <a
+        href="http://www.sgi.com/tech/stl/Iterators.html">Iterator
+        range</a>.
+
+        <td>The result will convert its argument to
+        <code>c</code> and call
+        <code>c.begin()</code> and <code>c.end()</code> to acquire
+        iterators. To invoke <code>Container</code>'s
+        <code>const</code> <code>begin()</code> and <code>end()</code>
+        functions, make it <code>const</code>.
 
-        <td>The result will convert its argument to <code>c</code> and call
-        <code>c.begin()</code> and <code>c.end()</code> to acquire iterators.
-        To invoke <code>Container</code>'s <code>const</code>
-        <code>begin()</code> and <code>end()</code> functions, make it
-        <code>const</code>.</td>
-      </tr>
 
       <tr>
-        <td><code>NextPolicies</code></td>
+        <td><code>NextPolicies</code> 
 
-        <td>A default-constructible model of <a href=
-        "CallPolicies.html#CallPolicies-concept">CallPolicies</a>.</td>
+        <td>A default-constructible model of <a
+        href="CallPolicies.html#CallPolicies-concept">CallPolicies</a>.
 
-        <td>Applied to the resulting iterators' <code>next()</code>
-        method.</td>
+        <td>Applied to the resulting iterators' <code>next()</code> method.
+
+        <td>An unspecified model of <a
+        href="CallPolicies.html#CallPolicies-concept">CallPolicies</a>
+        which always makes a copy of the
+        result of deferencing the underlying C++ iterator
 
-        <td>An unspecified model of <a href=
-        "CallPolicies.html#CallPolicies-concept">CallPolicies</a> which
-        always makes a copy of the result of deferencing the underlying C++
-        iterator</td>
-      </tr>
     </table>
 
-    <h4><a name="iterator-spec-synopsis"></a>Class Template iterator
-    synopsis</h4>
+    <h4><a name="iterator-spec-synopsis"></a>Class Template iterator synopsis</h4>
 <pre>
 namespace boost { namespace python
 {
   template &lt;class Container
              , class NextPolicies = <i>unspecified</i>&gt;
-  struct iterator : <a href="object.html#object-spec">object</a>
+  struct iterator : reference&lt;PyObject*&gt;
   {
       iterator();
   };
 }}
 </pre>
+    <h4><a name="iterator-spec-constructors"></a>Class Template
+    iterator constructor</h4>
 
-    <h4><a name="iterator-spec-constructors"></a>Class Template iterator
-    constructor</h4>
 <pre>
 iterator()
 </pre>
 
     <dl class="function-semantics">
-      <dt><b>Effects:</b></dt>
-
-      <dd>
-        Initializes its base class with the result of: 
+      <dt><b>Effects:</b> Initializes its base class with the result
+      of:
 <pre>
 range&lt;NextPolicies&gt;(&amp;iterators&lt;Container&gt;::begin, &amp;iterators&lt;Container&gt;::end)
 </pre>
-      </dd>
 
-      <dt><b>Postconditions:</b> <code>this-&gt;get()</code> points to a
-      Python callable object which creates a Python iterator as described
-      above.</dt>
+      <dt><b>Postconditions:</b> <code>this-&gt;get()</code> points to
+      a Python callable object which creates a Python iterator as
+      described above.
 
-      <dt><b>Rationale:</b> Provides an easy way to create iterators for the
-      common case where a C++ class being wrapped provides
-      <code>begin()</code> and <code>end()</code>.</dt>
+      <dt><b>Rationale:</b> Provides an easy way to create iterators
+      for the common case where a C++ class being wrapped provides
+      <code>begin()</code> and <code>end()</code>.
     </dl>
-    <!-- -->
 
-    <h3><a name="iterators-spec"></a>Class Template
-    <code>iterators</code></h3>
+<!-- -->
 
-    <p>A utility class template which provides a way to reliably call its
-    argument's <code>begin()</code> and <code>end()</code> member functions.
-    Note that there is no portable way to take the address of a member
-    function of a C++ standard library container, so
-    <code>iterators&lt;&gt;</code> can be particularly helpful when wrapping
-    them.</p>
+    <h3><a name="iterators-spec"></a>Class Template <code>iterators</code></h3>
 
-    <p>In the table below, <code><b>x</b></code> is an instance of
-    <code>C</code>.</p>
+    <p>A utility class template which provides a way to reliably call
+    its argument's <code>begin()</code> and <code>end()</code> member
+    functions. Note that there is no portable way to take the address
+    of a member function of a C++ standard library container, so
+    <code>iterators&lt;&gt;</code> can be particularly helpful when
+    wrapping them.
+    
+
+    <p>In the table below, <code><b>x</b></code> is an instance of <code>C</code>.
 
     <table border="1" summary="iterator template parameters">
       <tr>
-        <th>Required Valid Expression</th>
+        <th>Required Valid Expression
 
-        <th>Type</th>
-      </tr>
+        <th>Type
 
       <tr>
-        <td><code>x.begin()</code></td>
-
-        <td>Convertible to <code>C::const_iterator</code> if <code>C</code>
-        is a <code>const</code> type; convertible to <code>C::iterator</code>
-        otherwise.</td>
-      </tr>
+        <td><code>x.begin()</code>
+        
+        <td>Convertible to <code>C::const_iterator</code> if <code>C</code> is a
+        <code>const</code> type; convertible to <code>C::iterator</code> otherwise.
 
       <tr>
-        <td><code>x.end()</code></td>
+        <td><code>x.end()</code>
+        
+        <td>Convertible to <code>C::const_iterator</code> if <code>C</code> is a
+        <code>const</code> type; convertible to <code>C::iterator</code> otherwise.
 
-        <td>Convertible to <code>C::const_iterator</code> if <code>C</code>
-        is a <code>const</code> type; convertible to <code>C::iterator</code>
-        otherwise.</td>
-      </tr>
     </table>
 
-    <h4><a name="iterators-spec-synopsis"></a>Class Template iterators
-    synopsis</h4>
+    <h4><a name="iterators-spec-synopsis"></a>Class Template iterators synopsis</h4>
 <pre>
 namespace boost { namespace python
 {
@@ -247,151 +224,141 @@ namespace boost { namespace python
 }}
 
 </pre>
+    <h4><a name="iterators-spec-types"></a>Class Template
+    iterators nested types</h4>
 
-    <h4><a name="iterators-spec-types"></a>Class Template iterators nested
-    types</h4>
-    If C is a <code>const</code> type, 
+If C is a <code>const</code> type,
 <pre>
 typedef typename C::const_iterator iterator;
 </pre>
-    Otherwise: 
+Otherwise:
 <pre>
 typedef typename C::iterator iterator;
 </pre>
 
-    <h4><a name="iterators-spec-statics"></a>Class Template iterators static
-    functions</h4>
+    <h4><a name="iterators-spec-statics"></a>Class Template
+    iterators static functions</h4>
+
 <pre>
 static iterator begin(C&amp;);
 </pre>
 
     <dl class="function-semantics">
-      <dt><b>Returns:</b> <code>x.begin()</code></dt>
+      <dt><b>Returns:</b> <code>x.begin()</code>
     </dl>
+
 <pre>
 static iterator end(C&amp;);
 </pre>
 
     <dl class="function-semantics">
-      <dt><b>Returns:</b> <code>x.end()</code></dt>
+      <dt><b>Returns:</b> <code>x.end()</code>
     </dl>
-    <!-- -->
+
+<!-- -->
 
     <h2><a name="functions"></a>Functions</h2>
 <pre>
 <a name=
 "range-spec">template</a> &lt;class NextPolicies, class Target, class Accessor1, class Accessor2&gt;
-<a href=
-"object.html#object-spec">object</a> range(Accessor1 start, Accessor2 finish);
+reference&lt;PyObject*&gt range(Accessor1 start, Accessor2 finish);
 
 template &lt;class NextPolicies, class Accessor1, class Accessor2&gt;
-<a href=
-"object.html#object-spec">object</a> range(Accessor1 start, Accessor2 finish);
+reference&lt;PyObject*&gt range(Accessor1 start, Accessor2 finish);
 
 template &lt;class Accessor1, class Accessor2&gt;
-<a href=
-"object.html#object-spec">object</a> range(Accessor1 start, Accessor2 finish);
+reference&lt;PyObject*&gt range(Accessor1 start, Accessor2 finish);
 </pre>
 
     <dl class="range-semantics">
       <dt><b>Requires:</b> <code>NextPolicies</code> is a
-      default-constructible model of <a href=
-      "CallPolicies.html#CallPolicies-concept">CallPolicies</a>.</dt>
+        default-constructible model of <a
+        href="CallPolicies.html#CallPolicies-concept">CallPolicies</a>.
 
-      <dt><b>Effects:</b></dt>
+      <dt><b>Effects:</b> <dl>
 
-      <dd>
-        <dl>
-          <dt>The first form creates a Python callable object which, when
-          invoked, converts its argument to a <code>Target</code> object
-          <code>x</code>, and creates a Python iterator which traverses
-          [<code><a href=
-          "../../../bind/bind.html">bind</a>(start,_1)(x)</code>,&nbsp;<code><a
-           href="../../../bind/bind.html">bind</a>(finish,_1)(x)</code>),
-          applying <code>NextPolicies</code> to the iterator's
-          <code>next()</code> function.</dt>
+The first form creates a Python callable
+      object which, when invoked, converts its argument to a
+      <code>Target</code> object
+      <code>x</code>, and creates a Python iterator which traverses
+       [<code><a
+       href="../../../bind/bind.html">bind</a>(start,_1)(x)</code>,&nbsp;<code><a
+       href="../../../bind/bind.html">bind</a>(finish,_1)(x)</code>),
+       applying <code>NextPolicies</code> to the iterator's
+       <code>next()</code> function. 
+<dd>
+       <dt>The second form is identical to
+       the first, except that <code>Target</code> is deduced from
+       <code>Accessor1</code> as follows:
+       <ol>
+       <li>If <code>Accessor1</code> is a function type,
+       <code>Target</code> is the type of its first argument.
+       <li>If <code>Accessor1</code> is a data member pointer of the
+       form <code>R&nbsp;(T::*)</code>, <code>Target</code> is
+       identical to <code>T</code>.
+       <li>If <code>Accessor1</code> is a member function pointer of
+       the form
+       <code>R&nbsp;(T::*)(</code><i>arguments...</i><code>)</code>&nbsp;<i>cv-opt</i>,
+       where <i>cv-opt</i> is an optional <code>cv-qualifier</code>,
+       <code>Target</code> is identical to <code>T</code>.
+        </ol>
+<dd>
 
-          <dt>The second form is identical to the first, except that
-          <code>Target</code> is deduced from <code>Accessor1</code> as
-          follows:</dt>
+       <dt>The third form is identical to the second, except that
+       <code>NextPolicies</code> is an unspecified model of <a
+        href="CallPolicies.html#CallPolicies-concept">CallPolicies</a>
+        which always makes a copy of the
+        result of deferencing the underlying C++ iterator<dd>
+</dl>
 
-          <dd>
-            <ol>
-              <li>If <code>Accessor1</code> is a function type,
-              <code>Target</code> is the type of its first argument.</li>
 
-              <li>If <code>Accessor1</code> is a data member pointer of the
-              form <code>R&nbsp;(T::*)</code>, <code>Target</code> is
-              identical to <code>T</code>.</li>
-
-              <li>If <code>Accessor1</code> is a member function pointer of
-              the form
-              <code>R&nbsp;(T::*)(</code><i>arguments...</i><code>)</code>&nbsp;
-              <i>cv-opt</i>, where <i>cv-opt</i> is an optional
-              <code>cv-qualifier</code>, <code>Target</code> is identical to
-              <code>T</code>.</li>
-            </ol>
-          </dd>
-
-          <dt>The third form is identical to the second, except that
-          <code>NextPolicies</code> is an unspecified model of <a href=
-          "CallPolicies.html#CallPolicies-concept">CallPolicies</a> which
-          always makes a copy of the result of deferencing the underlying C++
-          iterator</dt>
-        </dl>
-      </dd>
-
-      <dt><b>Rationale:</b> The use of <code><a href=
-      "../../../bind/bind.html">boost::bind</a>()</code> allows C++ iterators
-      to be accessed through functions, member functions or data member
-      pointers. Customization of <code>NextPolicies</code> (e.g. using
-      <code><a href=
-      "return_internal_reference.html#return_internal_reference-spec">return_internal_reference</a></code>)
-      is useful when it is expensive to copy sequence elements of a wrapped
-      class type. Customization of <code>Target</code> is useful when
-      <code>Accessor1</code> is a function object, or when a base class of
-      the intended target type would otherwise be deduced.</dt>
+      <dt><b>Rationale:</b> The use of <code><a
+      href="../../../bind/bind.html">boost::bind</a>()</code> allows
+      C++ iterators to be accessed through functions, member functions
+      or data member pointers. Customization of
+      <code>NextPolicies</code> (e.g. using <code><a
+      href="return_internal_reference.html#return_internal_reference-spec"
+      >return_internal_reference</a></code>) is useful when it is
+      expensive to copy sequence elements of a wrapped class
+      type. Customization of <code>Target</code> is useful when
+      <code>Accessor1</code> is a function object, or when a base
+      class of the intended target type would otherwise be deduced.
     </dl>
 
     <h2><a name="examples"></a>Examples</h2>
+
 <pre>
 #include &lt;boost/python/module.hpp&gt;
 #include &lt;boost/python/class.hpp&gt;
-
+#include &lt;boost/python/return_internal_reference.hpp&gt;
 #include &lt;vector&gt;
 
 using namespace boost::python;
-BOOST_PYTHON_MODULE(demo)
+BOOST_PYTHON_MODULE_INIT(demo)
 {
-    class_&lt;std::vector&lt;double&gt; &gt;("dvec")
-        .def("__iter__", iterator&lt;std::vector&lt;double&gt; &gt;())
-        ;
+   module(&quot;demo&quot;)
+      .add(
+         class_&lt;std::vector&lt;double&gt; &gt;(&quot;dvec&quot;)
+            .def(&quot;__iter__&quot;, iterator&lt;std::vector&lt;double&gt; &gt;())
+            ...
+         )
+      ;
 }
 </pre>
-    A more comprehensive example can be found in: 
 
-    <dl>
-      <dt><code><a href=
-      "../../test/iterator.cpp">libs/python/test/iterator.cpp</a></code></dt>
+A more comprehensive example can be found in:
+<code><dl>
+<dt><a href="../../test/iterator.cpp">libs/python/test/iterator.cpp</a><dd>
+<dt><a href="../../test/input_iterator.cpp">libs/python/test/input_iterator.cpp</a><dd>
+<dt><a href="../../test/iterator.py">libs/python/test/input_iterator.py</a><dd>
+</code>
 
-      <dt><code><a href=
-      "../../test/input_iterator.cpp">libs/python/test/input_iterator.cpp</a></code></dt>
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     17 May, 2002
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
-      <dt><code><a href=
-      "../../test/iterator.py">libs/python/test/input_iterator.py</a></code></dt>
 
-      <dd>
-        <p>Revised 
-        <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-         29 September, 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>
-      </dd>
-    </dl>
-  </body>
-</html>
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
 

doc/v2/list.html

@@ -1,140 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<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">
-
-    <title>Boost.Python - &lt;boost/python/list.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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
-
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
-
-          <h2 align="center">Header &lt;boost/python/list.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="#list-spec">Class <code>list</code></a></dt>
-
-          <dd>
-            <dl class="page-index">
-              <dt><a href="#list-spec-synopsis">Class <code>list</code>
-              synopsis</a></dt>
-            </dl>
-          </dd>
-        </dl>
-      </dd>
-
-      <dt><a href="#examples">Example(s)</a></dt>
-    </dl>
-    <hr>
-
-    <h2><a name="introduction"></a>Introduction</h2>
-
-    <p>Exposes a <a href=
-    "ObjectWrapper.html#TypeWrapper-concept">TypeWrapper</a> for the Python
-    <a href=
-    "http://www.python.org/doc/current/lib/typesseq-mutable.html">list</a>
-    type.</p>
-
-    <h2><a name="classes"></a>Classes</h2>
-
-    <h3><a name="list-spec"></a>Class <code>list</code></h3>
-
-    <p>Exposes the <a href=
-    "http://www.python.org/doc/current/lib/typesseq-mutable.html">mapping
-    protocol</a> of Python's built-in <code>list</code> type. The semantics
-    of the constructors and member functions defined below can be fully
-    understood by reading the <a href=
-    "ObjectWrapper.html#TypeWrapper-concept">TypeWrapper</a> concept
-    definition. Since <code>list</code> is publicly derived from <code><a
-    href="object.html#object-spec">object</a></code>, the public object
-    interface applies to <code>list</code> instances as well.</p>
-
-    <h4><a name="list-spec-synopsis"></a>Class <code>list</code>
-    synopsis</h4>
-<pre>
-namespace boost { namespace python
-{
-  class list : public object
-  {
-   public:
-      list(); // new list
-
-      template &lt;class T&gt;
-      explicit list(T const&amp; sequence);
-
-      template &lt;class T&gt;
-      void append(T const&amp; x);
-
-      template &lt;class T&gt;
-      long count(T const&amp; value) const;
-
-      template &lt;class T&gt;
-      void extend(T const&amp; x);
-
-      template &lt;class T&gt;
-      long index(T const&amp; x) const;
-
-      template &lt;class T&gt;
-      void insert(object const&amp; index, T const&amp; x); // insert object before index
-
-      object pop(); // remove and return item at index (default last)
-      object pop(long index);
-      object pop(object const&amp; index);
-
-      template &lt;class T&gt;
-      void remove(T const&amp; value);
-
-      void reverse(); // reverse *IN PLACE*
-
-      void sort(); //  sort *IN PLACE*; if given, cmpfunc(x, y) -&gt; -1, 0, 1
-
-      template &lt;class T&gt;
-      void sort(T const&amp; value);
-  };
-}}
-</pre>
-
-    <h2><a name="examples"></a>Example</h2>
-<pre>
-using namespace boost::python;
-
-// Return the number of zeroes in the list
-long zeroes(list l)
-{
-   return l.count(0);
-}
-</pre>
-
-    <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>
-  </body>
-</html>
-

doc/v2/long.html

@@ -1,117 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<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">
-
-    <title>Boost.Python - &lt;boost/python/long.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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
-
-        <td valign="top">
-          <h1 align="center">Boost.Python</h1>
-
-          <h2 align="center">Header &lt;boost/python/long.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="#long_-spec">Class <code>long_</code></a></dt>
-
-          <dd>
-            <dl class="page-index">
-              <dt><a href="#long_-spec-synopsis">Class <code>long_</code>
-              synopsis</a></dt>
-            </dl>
-          </dd>
-        </dl>
-      </dd>
-
-      <dt><a href="#examples">Example(s)</a></dt>
-    </dl>
-    <hr>
-
-    <h2><a name="introduction"></a>Introduction</h2>
-
-    <p>Exposes a <a href=
-    "ObjectWrapper.html#TypeWrapper-concept">TypeWrapper</a> for the Python
-    <a href=
-    "http://www.python.org/doc/current/lib/typesnumeric.html">long</a>
-    integer type.</p>
-
-    <h2><a name="classes"></a>Classes</h2>
-
-    <h3><a name="long_-spec"></a>Class <code>long_</code></h3>
-
-    <p>Exposes the <a href=
-    "http://www.python.org/doc/current/lib/typesnumeric.html">numeric type
-    protocol</a> of Python's built-in <code>long</code> type. The semantics
-    of the constructors and member functions defined below can be fully
-    understood by reading the <a href=
-    "ObjectWrapper.html#TypeWrapper-concept">TypeWrapper</a> concept
-    definition. Since <code>long_</code> is publicly derived from <code><a
-    href="object.html#object-spec">object</a></code>, the public object
-    interface applies to <code>long_</code> instances as well.</p>
-
-    <h4><a name="long_-spec-synopsis"></a>Class <code>long_</code>
-    synopsis</h4>
-<pre>
-namespace boost { namespace python
-{
-  class long_ : public object
-  {
-   public:
-      long_(); // new long_
-
-      template &lt;class T&gt;
-      explicit long_(T const&amp; rhs);
-
-      template &lt;class T, class U&gt;
-      long_(T const&amp; rhs, U const&amp; base);
-  };
-}}
-</pre>
-
-    <h2><a name="examples"></a>Example</h2>
-<pre>
-namespace python = boost::python;
-
-// compute a factorial without overflowing
-python::long_ fact(long n)
-{
-   if (n == 0)
-      return python::long_(1);
-   else
-      return n * fact(n - 1);
-}
-</pre>
-
-    <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>
-  </body>
-</html>
-

doc/v2/lvalue_from_pytype.html

@@ -1,145 +1,128 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-  <head>
-    <meta name="generator" content=
-    "HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
+    <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/lvalue_from_python.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="../../../../c++boost.gif" border="0"></a></h3>
-        </td>
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
         <td valign="top">
           <h1 align="center">Boost.Python</h1>
 
-          <h2 align="center">Header
-          &lt;boost/python/lvalue_from_pytype.hpp&gt;</h2>
-        </td>
-      </tr>
+          <h2 align="center">Header &lt;boost/python/lvalue_from_pytype.hpp&gt;</h2>
     </table>
     <hr>
 
     <h2>Contents</h2>
 
     <dl class="page-index">
-      <dt><a href="#introduction">Introduction</a></dt>
+      <dt><a href="#introduction">Introduction</a>
 
-      <dt><a href="#classes">Classes</a></dt>
+
+      <dt><a href="#classes">Classes</a>
 
       <dd>
         <dl class="page-index">
-          <dt><a href="#lvalue_from_pytype-spec">Class Template
-          <code>lvalue_from_pytype</code></a></dt>
+          <dt><a href="#lvalue_from_pytype-spec">Class Template <code>lvalue_from_pytype</code></a>
 
           <dd>
             <dl class="page-index">
+
               <dt><a href="#lvalue_from_pytype-spec-synopsis">Class Template
-              <code>lvalue_from_pytype</code> synopsis</a></dt>
+              <code>lvalue_from_pytype</code> synopsis</a>
 
               <dt><a href="#lvalue_from_pytype-spec-ctors">Class Template
-              <code>lvalue_from_pytype</code> constructor</a></dt>
+              <code>lvalue_from_pytype</code> constructor</a>
             </dl>
-          </dd>
         </dl>
 
         <dl class="page-index">
-          <dt><a href="#extract_identity-spec">Class Template
-          <code>extract_identity</code></a></dt>
-
+          <dt><a href="#extract_identity-spec">Class Template <code>extract_identity</code></a>
           <dd>
             <dl class="page-index">
+
               <dt><a href="#extract_identity-spec-synopsis">Class Template
-              <code>extract_identity</code> synopsis</a></dt>
+              <code>extract_identity</code> synopsis</a>
 
               <dt><a href="#extract_identity-spec-statics">Class Template
-              <code>extract_identity</code> static functions</a></dt>
+              <code>extract_identity</code> static functions</a>
             </dl>
-          </dd>
-
-          <dt><a href="#extract_member-spec">Class Template
-          <code>extract_member</code></a></dt>
-
+          <dt><a href="#extract_member-spec">Class Template <code>extract_member</code></a>
           <dd>
             <dl class="page-index">
+
               <dt><a href="#extract_member-spec-synopsis">Class Template
-              <code>extract_member</code> synopsis</a></dt>
+              <code>extract_member</code> synopsis</a>
 
               <dt><a href="#extract_member-spec-statics">Class Template
-              <code>extract_member</code> static functions</a></dt>
+              <code>extract_member</code> static functions</a>
             </dl>
-          </dd>
         </dl>
-      </dd>
 
-      <dt><a href="#examples">Example</a></dt>
+      <dt><a href="#examples">Example</a>
     </dl>
     <hr>
 
     <h2><a name="introduction"></a>Introduction</h2>
-    <code>&lt;boost/python/lvalue_from_pytype.hpp&gt;</code> supplies a
-    facility for extracting C++ objects from within Python instances of a
-    given type. This is typically useful for dealing with "traditional"
-    Python extension types. 
+
+    <code>&lt;boost/python/lvalue_from_pytype.hpp&gt;</code> supplies
+    a facility for extracting C++ objects from within Python instances
+    of a given type. This is typically useful for dealing with
+    &quot;traditional&quot; Python extension types.
 
     <h2><a name="classes"></a>Classes</h2>
 
-    <h3><a name="lvalue_from_pytype-spec"></a>Class template
-    <code>lvalue_from_pytype</code></h3>
+    <h3><a name="lvalue_from_pytype-spec"></a>Class template <code>lvalue_from_pytype</code></h3>
 
     <p>Class template <code>lvalue_from_pytype</code> will register
-    from_python converters which, given an object of the given Python type,
-    can extract references and pointers to a particular C++ type. Its
-    template arguments are:</p>
+    from_python converters which, given an object of the given Python
+    type, can extract references and pointers to a particular C++
+    type. Its template arguments are:
+
+    <p>
+
 
     <table border="1" summary="lvalue_from_pytype template parameters">
       <caption>
         <b><code>lvalue_from_pytype</code> Requirements</b><br>
-         In the table below, <b><code>x</code></b> denotes an object of type
-        <code>PythonObject&amp;</code>
+
+        In the table below, <b><code>x</code></b> denotes an object of type <code>PythonObject&amp;</code>
+
       </caption>
+      <tr>
+        <th>Parameter
+        
+        <th>Requirements
+
+        <th>Semantics
 
       <tr>
-        <th>Parameter</th>
+        <td><code>Extractor</code> 
 
-        <th>Requirements</th>
+        <td>a model of <a
+        href="Extractor.html#Extractor-concept">Extractor</a> whose
+        execute function returns a reference type.
 
-        <th>Semantics</th>
-      </tr>
+        <td>Extracts the lvalue from the Python object once its type has been confirmed
 
       <tr>
-        <td><code>Extractor</code></td>
+        <td><code>python_type</code> 
 
-        <td>a model of <a href=
-        "Extractor.html#Extractor-concept">Extractor</a> whose execute
-        function returns a reference type.</td>
+        <td>A compile-time constant <code><a
+        href="http://www.python.org/doc/2.2/ext/dnt-type-methods.html">PyTypeObject</a>*</code>
 
-        <td>Extracts the lvalue from the Python object once its type has been
-        confirmed</td>
-      </tr>
+        <td>The Python type of instances convertible by this
+        converter. Python subtypes are also convertible.
 
-      <tr>
-        <td><code>python_type</code></td>
-
-        <td>A compile-time constant <code><a href=
-        "http://www.python.org/doc/2.2/ext/dnt-type-methods.html">PyTypeObject</a>*</code></td>
-
-        <td>The Python type of instances convertible by this converter.
-        Python subtypes are also convertible.</td>
-      </tr>
     </table>
 
-    <h4><a name="lvalue_from_pytype-spec-synopsis"></a>Class template
-    <code>lvalue_from_pytype</code> synopsis</h4>
+    <h4><a name="lvalue_from_pytype-spec-synopsis"></a>Class template <code>lvalue_from_pytype</code> synopsis</h4>
 <pre>
 namespace boost { namespace python
 {
@@ -151,25 +134,25 @@ namespace boost { namespace python
 }}
 </pre>
 
-    <h4><a name="lvalue_from_pytype-spec-ctors"></a>Class template
-    <code>lvalue_from_pytype</code> constructor</h4>
+    <h4><a name="lvalue_from_pytype-spec-ctors"></a>Class template <code>lvalue_from_pytype</code> constructor</h4>
 <pre>
 lvalue_from_pytype();
 </pre>
 
     <dl class="function-semantics">
-      <dt><b>Effects:</b> Registers converters which can convert Python
-      objects of the given type to lvalues of the type returned by
-      <code>Extractor::execute</code>.</dt>
+
+      <dt><b>Effects:</b> Registers converters which can convert
+      Python objects of the given type to lvalues of the type returned
+      by <code>Extractor::execute</code>.
+
     </dl>
 
-    <h3><a name="extract_identity-spec"></a>Class template
-    <code>extract_identity</code></h3>
+    <h3><a name="extract_identity-spec"></a>Class template <code>extract_identity</code></h3>
 
-    <p><code>extract_identity</code> is a model of <a href=
-    "Extractor.html#Extractor-concept">Extractor</a> which can be used in the
-    common case where the C++ type to be extracted is the same as the Python
-    object type.</p>
+    <p><code>extract_identity</code> is a model of <a
+    href="Extractor.html#Extractor-concept">Extractor</a> which can be
+    used in the common case where the C++ type to be extracted is the
+    same as the Python object type.
 
     <h4><a name="extract_identity-spec-synopsis"></a>Class template
     <code>extract_identity</code> synopsis</h4>
@@ -184,26 +167,26 @@ namespace boost { namespace python
 }}
 </pre>
 
-    <h4><a name="extract_identity-spec-statics"></a>Class template
-    <code>extract_identity</code> static functions</h4>
+    <h4><a name="extract_identity-spec-statics"></a>Class template <code>extract_identity</code> static functions</h4>
 <pre>
 InstanceType&amp; execute(InstanceType&amp; c);
 </pre>
 
     <dl class="function-semantics">
-      <dt><b>Returns:</b> <code>c</code></dt>
+
+      <dt><b>Returns:</b> <code>c</code>
+
     </dl>
 
-    <h3><a name="extract_member-spec"></a>Class template
-    <code>extract_member</code></h3>
 
-    <p><code>extract_member</code> is a model of <a href=
-    "Extractor.html#Extractor-concept">Extractor</a> which can be used in the
-    common case in the common case where the C++ type to be extracted is a
-    member of the Python object.</p>
+    <h3><a name="extract_member-spec"></a>Class template <code>extract_member</code></h3>
 
-    <h4><a name="extract_member-spec-synopsis"></a>Class template
-    <code>extract_member</code> synopsis</h4>
+    <p><code>extract_member</code> is a model of <a
+    href="Extractor.html#Extractor-concept">Extractor</a> which can be
+    used in the common case in the common case where the C++
+    type to be extracted is a member of the Python object.
+
+    <h4><a name="extract_member-spec-synopsis"></a>Class template <code>extract_member</code> synopsis</h4>
 <pre>
 namespace boost { namespace python
 {
@@ -215,28 +198,31 @@ namespace boost { namespace python
 }}
 </pre>
 
-    <h4><a name="extract_member-spec-statics"></a>Class template
-    <code>extract_member</code> static functions</h4>
+    <h4><a name="extract_member-spec-statics"></a>Class template <code>extract_member</code> static functions</h4>
 <pre>
 static MemberType&amp; execute(InstanceType&amp; c);
 </pre>
 
     <dl class="function-semantics">
-      <dt><b>Returns:</b> <code>c.*member</code></dt>
+
+      <dt><b>Returns:</b> <code>c.*member</code>
+
     </dl>
 
     <h2><a name="examples"></a>Example</h2>
-    This example presumes that someone has implemented the standard <a href=
-    "http://www.python.org/doc/2.2/ext/dnt-basics.html">noddy example
-    module</a> from the Python documentation, and we want to build a module
-    which manipulates <code>Noddy</code>s. Since
-    <code>noddy_NoddyObject</code> is so simple that it carries no
-    interesting information, the example is a bit contrived: it assumes you
-    want to keep track of one particular object for some reason. This module
-    would have to be dynamically linked to the module which defines
-    <code>noddy_NoddyType</code>. 
 
-    <h3>C++ module definition</h3>
+This example presumes that someone has implemented the standard <a
+href="http://www.python.org/doc/2.2/ext/dnt-basics.html">noddy
+example module</a> from the Python documentation, and we want to build
+a module which manipulates <code>Noddy</code>s. Since
+<code>noddy_NoddyObject</code> is so simple that it carries no
+interesting information, the example is a bit contrived: it assumes
+you want to keep track of one particular object for some reason. This
+module would have to be dynamically linked to the module which defines
+<code>noddy_NoddyType</code>.
+
+<h3>C++ module definition</h3>
+
 <pre>
 #include &lt;boost/python/reference.hpp&gt;
 #include &lt;boost/python/module.hpp&gt;
@@ -259,17 +245,20 @@ void set_cache(noddy_NoddyObject* x)
    cache.reset((PyObject*)x, ref::increment_count);
 }
 
-BOOST_PYTHON_MODULE(noddy_cache)
+BOOST_PYTHON_MODULE_INIT(noddy_cache)
 {
-   def("is_cached", is_cached);
-   def("set_cache", set_cache);
+   module noddy_cache(&quot;noddy_cache&quot;)
+      .def(&quot;is_cached&quot;, is_cached)
+      .def(&quot;set_cache&quot;, set_cache)
+      ;
 
    // register Noddy lvalue converter
    lvalue_from_pytype&lt;extract_identity&lt;noddy_NoddyObject&gt;,&amp;noddy_NoddyType&gt;();
 }
 </pre>
 
-    <h3>Python code</h3>
+<h3>Python code</h3>
+
 <pre>
 &gt;&gt;&gt; import noddy
 &gt;&gt;&gt; n = noddy.new_noddy()
@@ -285,13 +274,10 @@ BOOST_PYTHON_MODULE(noddy_cache)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 September, 2001 
+     05 November, 2001 
     <!--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>
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>