This commit was manufactured by cvs2svn to create tag

'Version_1_25_1_BGL'.

[SVN r11635]

build/Jamfile

@@ -0,0 +1,285 @@
+#  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+#  distribute this software is granted provided this copyright notice appears
+#  in all copies. This software is provided "as is" without express or implied
+#  warranty, and with no claim as to its suitability for any purpose.
+#
+# Boost.Python 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, a static link 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 ;
+
+# grab variables from command-line or environment.
+local PYTHON_VERSION = $(PYTHON_VERSION) ;
+local PYTHON_ROOT = $(PYTHON_ROOT) ;
+local PYTHON_INCLUDES = $(PYTHON_INCLUDES) ;
+local PYTHON_LIBS = $(PYTHON_LIBS) ;
+local PYTHON_LIB_PATH = $(PYTHON_LIB_PATH) ;
+local PYTHON_PROPERTIES = $(PYTHON_PROPERTIES) ;
+
+# Do some OS-specific setup
+if $(NT)
+{
+    PYTHON_VERSION ?= 2.1 ;
+    PYTHON_ROOT ?= c:/tools/python ;
+    PYTHON_INCLUDES ?= <include>$(PYTHON_ROOT)/include <gcc><*><include>/usr/include/python$(PYTHON_VERSION) ;
+    PYTHON_LIBS ?= c:/cygnus/lib/python$(PYTHON_VERSION)/config/libpython$(PYTHON_VERSION).dll.a ;
+    PYTHON_LIB_PATH = $(PYTHON_ROOT)/libs ;
+
+    # common properties required for compiling any Python module.
+    PYTHON_PROPERTIES ?=
+        <gcc><*><define>SIZEOF_LONG=4
+        <gcc><*><define>USE_DL_IMPORT
+        <runtime-link>dynamic
+        ;
+                        
+}
+else if $(UNIX)
+{
+    PYTHON_VERSION ?= 1.5 ;
+    PYTHON_INCLUDES ?= <include>/usr/include/python$(PYTHON_VERSION) ;
+    PYTHON_LIBS ?= /usr/lib/python$(PYTHON_VERSION)/config/libpython$(PYTHON_VERSION).a ;
+}
+
+# how do we invoke python?
+local PYTHON = $(PYTHON) ;
+PYTHON ?= python ;
+PYTHON = [ FAppendSuffix $(PYTHON:G=<executable-grist>) : $(SUFEXE) ] ;
+SEARCH on $(PYTHON) = $(PATH) ;
+
+#######################
+
+#
+# Declare the boost python static link library
+#
+
+# standard include requirements for anything using Boost.Python
+local BOOST_PYTHON_INCLUDES = <include>$(BOOST_ROOT) $(PYTHON_INCLUDES) ;
+
+# Base names of the source files for libboost_python
+local CPP_SOURCES =
+    classes conversions extension_class functions 
+    init_function module_builder objects types cross_module ;
+
+lib libboost_python : ../src/$(CPP_SOURCES).cpp
+    # requirements
+    : $(BOOST_PYTHON_INCLUDES)
+    <shared-linkable>true
+    $(PYTHON_PROPERTIES) ;
+    
+#######################
+
+# boost-python name : sources : requirements : default-BUILD
+#
+# Declare a boost python module. Return a list of the DLL files generated.
+rule boost-python
+{
+    # declare a DLL; add the boost python library to sources
+     dll $(<) : <lib>libboost_python $(>)
+            
+            # Requirements
+            : $(3) # caller-specified requirements
+            
+                # standard requirements
+                $(BOOST_PYTHON_INCLUDES)
+                <msvc><*><library-path>$(PYTHON_LIB_PATH)
+                <gcc><*><library-file>$(PYTHON_LIBS)
+                $(PYTHON_PROPERTIES)
+                
+        : $(4) ;                      # pass on the default-BUILD, if any
+}
+
+# boost-python-test name : sources : requirements : default-BUILD
+#
+# Just like boost-python, but the result becomes part of the test pseudotarget
+# instead of being built by 'all'
+rule boost-python-test
+{
+    type-DEPENDS test : $(<) ;
+    
+    local gSUPPRESS_FAKE_TARGETS = true ;
+    boost-python $(1) : $(2) : $(3) : $(4) ;
+}
+
+#######################
+
+# boost-python-runtest target : python-script sources : requirements : local-build : args
+#
+# declare two python module tests: $(<).test which builds when out-of-date, and
+# $(<).run which builds unconditionally.
+rule boost-python-runtest
+{
+    # tell Jam that the python script is relative to this directory
+    SEARCH on $(>[1]) = $(SEARCH_SOURCE) ;
+    
+    # required command-line args can be specified in argument 5
+    # The user can add additional arguments in PYTHON_TEST_ARGS.
+    local gPYTHON_TEST_ARGS = $(5) $(PYTHON_TEST_ARGS) ;
+
+    # declare the two subsidiary tests.
+    declare-local-target $(<:S=.test) : $(>) : $(PYTHON_PROPERTIES) : $(4) : PYTHON_TEST ;
+    declare-local-target $(<:S=.run) : $(>) : $(PYTHON_PROPERTIES) : $(4) : PYTHON_RUNTEST ;
+}
+
+# special rules for two new target types: PYTHON_TEST and PYTHON_RUNTEST.
+# These are identical except that PYTHON_TEST runs the test when out-of-date, and
+# PYTHON_RUNTEST runs the test unconditionally. These are used by boost-python-runtest.
+SUFPYTHON_TEST = .test ;
+gGENERATOR_FUNCTION(PYTHON_TEST) = python-test-target ;
+rule python-test-target # test-target : sources : 
+{
+    python-runtest-aux $(<) : $(>) ;
+    Clean clean : $(<) ; # remove the test-target as part of any clean operation
+    type-DEPENDS test : $(<) ;
+    MakeLocate $(<) : $(LOCATE_TARGET) ;
+}
+actions python-test-target bind PYTHON
+{
+    $(SHELL_SET)PYTHONPATH=$(PYTHONPATH)
+    $(SHELL_EXPORT)PYTHONPATH
+    $(PYTHON) "$(>)" $(ARGS) > "$(<)"
+}
+
+SUFPYTHON_RUNTEST = .run ;
+gGENERATOR_FUNCTION(PYTHON_RUNTEST) = python-runtest-target ;
+rule python-runtest-target # test-target : sources : 
+{
+    python-runtest-aux $(<) : $(>) ;
+    NOTFILE $(<) ;
+    ALWAYS $(<) ;
+}
+actions python-runtest-target bind PYTHON
+{
+    $(SHELL_SET)PYTHONPATH=$(PYTHONPATH)
+    $(SHELL_EXPORT)PYTHONPATH
+    $(PYTHON) "$(>)" $(ARGS)
+}
+
+rule python-runtest-aux # target : sources
+{
+    DEPENDS $(<) : $(>) ;
+
+    ARGS on $(<) += $(gPYTHON_TEST_ARGS) ;
+    
+    # Some tests need an extra command-line arg if built with
+    # msvc. Checking the target grist is a cheap way to
+    # find out. 
+    switch $(<)
+    {
+        case <*\\\\msvc\\\\*>* : ARGS on $(<) += --broken-auto-ptr ;
+    }
+
+    # compute the PYTHONPATH environment variable that will allow the test to
+    # find all of the modules on which it depends.
+    PYTHONPATH on $(<) = [ join
+        $(gLOCATE($(>[1])))                     # location of python test file
+        $(gRUN_PATH($(<)))                      # location of module dependencies
+        [ join-path $(TOP) libs python test ]   # location of doctest
+        $(PYTHONPATH)                           # base PYTHONPATH from environment
+        : $(SPLITPATH) ] ;                      # platform path separator
+
+    PYTHON on $(<) = $(PYTHON) ;
+    DEPENDS $(<) : $(PYTHON) ;
+}
+
+############# comprehensive module and test ###########
+boost-python-test boost_python_test : ../test/comprehensive.cpp ;
+
+boost-python-runtest comprehensive
+         : [ join-path $(DOTDOT) test comprehensive.py ]
+           <lib>boost_python_test ;
+
+############# simple tests from ../example ############
+
+rule boost-python-example-runtest
+{
+    boost-python-test $(<) : ../example/$(<).cpp ;
+    boost-python-runtest $(<) : [ join-path $(DOTDOT) example test_$(<).py ] <lib>$(<) ;
+}
+
+
+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 ;
+
+
+boost-python-test ivect : ../example/ivect.cpp ;
+boost-python-test dvect : ../example/dvect.cpp ;
+boost-python-test noncopyable_export : ../example/noncopyable_export.cpp ;
+boost-python-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 : python-file libs
+{
+    boost-python-runtest $(<)
+        : ../example/tst_$(<).py <lib>$(>)
+        : : : $(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/filemgr.py

@@ -23,7 +23,8 @@ bpl_exa + "/abstract.cpp",
 bpl_exa + "/getting_started1.cpp",
 bpl_exa + "/getting_started2.cpp",
 bpl_exa + "/simple_vector.cpp",
-bpl_exa + "/do_it_yourself_converters.cpp",
+bpl_exa + "/do_it_yourself_convts.cpp",
+bpl_exa + "/nested.cpp",
 bpl_exa + "/pickle1.cpp",
 bpl_exa + "/pickle2.cpp",
 bpl_exa + "/pickle3.cpp",
@@ -31,7 +32,8 @@ 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_converters.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",
@@ -52,6 +54,13 @@ 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 = (
@@ -60,7 +69,8 @@ defs = (
 "getting_started1",
 "getting_started2",
 "simple_vector",
-"do_it_yourself_converters",
+"do_it_yourself_convts",
+"nested",
 "pickle1",
 "pickle2",
 "pickle3",
@@ -68,6 +78,9 @@ defs = (
 "noncopyable_import",
 "ivect",
 "dvect",
+"richcmp1",
+"richcmp2",
+"richcmp3",
 )
 
 if (__name__ == "__main__"):

build/irix_CC.mak

@@ -17,10 +17,10 @@
 ROOT=$(HOME)
 BOOST=$(ROOT)/boost
 
-PYEXE=/usr/local/Python-1.5.2/bin/python
+PYEXE=PYTHONPATH=. /usr/local/Python-1.5.2/bin/python
 PYINC=-I/usr/local/Python-1.5.2/include/python1.5
-#PYEXE=/usr/local/Python-2.0/bin/python
-#PYINC=-I/usr/local/Python-2.0/include/python2.0
+#PYEXE=PYTHONPATH=. /usr/local/Python-2.1/bin/python
+#PYINC=-I/usr/local/Python-2.1/include/python2.1
 STLPORTINC=-I$(BOOST)/boost/compatibility/cpp_c_headers
 
 STDOPTS=
@@ -43,10 +43,12 @@ DEPOBJ=$(OBJ) \
        abstract.o \
        getting_started1.o getting_started2.o \
        simple_vector.o \
-       do_it_yourself_converters.o \
+       do_it_yourself_convts.o \
+       nested.o \
        pickle1.o pickle2.o pickle3.o \
        noncopyable_export.o noncopyable_import.o \
-       ivect.o dvect.o
+       ivect.o dvect.o \
+       richcmp1.o richcmp2.o richcmp3.o
 
 .SUFFIXES: .o .cpp
 
@@ -55,10 +57,12 @@ all: libboost_python.a \
      abstract.so \
      getting_started1.so getting_started2.so \
      simple_vector.so \
-     do_it_yourself_converters.so \
+     do_it_yourself_convts.so \
+     nested.so \
      pickle1.so pickle2.so pickle3.so \
      noncopyable_export.so noncopyable_import.so \
-     ivect.so dvect.so
+     ivect.so dvect.so \
+     richcmp1.so richcmp2.so richcmp3.so
 
 libboost_python.a: $(OBJ)
 	rm -f libboost_python.a
@@ -79,8 +83,11 @@ getting_started2.so: $(OBJ) getting_started2.o
 simple_vector.so: $(OBJ) simple_vector.o
 	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
 
-do_it_yourself_converters.so: $(OBJ) do_it_yourself_converters.o
-	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_converters.o -o do_it_yourself_converters.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
@@ -105,6 +112,15 @@ ivect.so: $(OBJ) ivect.o
 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
 
@@ -114,11 +130,15 @@ test:
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_simple_vector.py
-	$(PYEXE) test_do_it_yourself_converters.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
@@ -127,7 +147,8 @@ clean:
 	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_converters.o do_it_yourself_converters.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
@@ -135,6 +156,9 @@ clean:
 	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
 

build/linux_gcc.mak

@@ -19,10 +19,10 @@ BOOST=$(ROOT)/boost
 
 PYEXE=PYTHONPATH=. /usr/bin/python
 PYINC=-I/usr/include/python1.5
-#PYEXE=/usr/local/Python-1.5.2/bin/python
+#PYEXE=PYTHONPATH=. /usr/local/Python-1.5.2/bin/python
 #PYINC=-I/usr/local/Python-1.5.2/include/python1.5
-#PYEXE=/usr/local/Python-2.0/bin/python
-#PYINC=-I/usr/local/Python-2.0/include/python2.0
+#PYEXE=PYTHONPATH=. /usr/local/Python-2.1/bin/python
+#PYINC=-I/usr/local/Python-2.1/include/python2.1
 
 STDOPTS=-fPIC -ftemplate-depth-21
 WARNOPTS=
@@ -44,10 +44,12 @@ DEPOBJ=$(OBJ) \
        abstract.o \
        getting_started1.o getting_started2.o \
        simple_vector.o \
-       do_it_yourself_converters.o \
+       do_it_yourself_convts.o \
+       nested.o \
        pickle1.o pickle2.o pickle3.o \
        noncopyable_export.o noncopyable_import.o \
-       ivect.o dvect.o
+       ivect.o dvect.o \
+       richcmp1.o richcmp2.o richcmp3.o
 
 .SUFFIXES: .o .cpp
 
@@ -56,10 +58,12 @@ all: libboost_python.a \
      abstract.so \
      getting_started1.so getting_started2.so \
      simple_vector.so \
-     do_it_yourself_converters.so \
+     do_it_yourself_convts.so \
+     nested.so \
      pickle1.so pickle2.so pickle3.so \
      noncopyable_export.so noncopyable_import.so \
-     ivect.so dvect.so
+     ivect.so dvect.so \
+     richcmp1.so richcmp2.so richcmp3.so
 
 libboost_python.a: $(OBJ)
 	rm -f libboost_python.a
@@ -80,8 +84,11 @@ getting_started2.so: $(OBJ) getting_started2.o
 simple_vector.so: $(OBJ) simple_vector.o
 	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
 
-do_it_yourself_converters.so: $(OBJ) do_it_yourself_converters.o
-	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_converters.o -o do_it_yourself_converters.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
@@ -106,6 +113,15 @@ ivect.so: $(OBJ) ivect.o
 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
 
@@ -115,11 +131,15 @@ test:
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_simple_vector.py
-	$(PYEXE) test_do_it_yourself_converters.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
@@ -128,7 +148,8 @@ clean:
 	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_converters.o do_it_yourself_converters.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
@@ -136,6 +157,9 @@ clean:
 	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:

build/mingw32.mak

@@ -30,13 +30,16 @@
 # -fvtable-thunks eliminates the compiler warning, but
 #                 "import boost_python_test" still causes a crash.
 
-ROOT=L:
+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=
@@ -59,13 +62,15 @@ all: libboost_python.a \
      abstract.pyd \
      getting_started1.pyd getting_started2.pyd \
      simple_vector.pyd \
-     do_it_yourself_converters.pyd \
+     do_it_yourself_convts.pyd \
+     nested.pyd \
      pickle1.pyd pickle2.pyd pickle3.pyd \
      noncopyable_export.pyd noncopyable_import.pyd \
-     ivect.pyd dvect.pyd
+     ivect.pyd dvect.pyd \
+     richcmp1.pyd richcmp2.pyd richcmp3.pyd
 
 libboost_python.a: $(OBJ)
-	del libboost_python.a
+	-del libboost_python.a
 	ar r libboost_python.a $(OBJ)
 
 DLLWRAPOPTS=-s --driver-name g++ -s \
@@ -101,11 +106,17 @@ simple_vector.pyd: $(OBJ) simple_vector.o
           --def simple_vector.def \
           $(OBJ) simple_vector.o $(PYLIB)
 
-do_it_yourself_converters.pyd: $(OBJ) do_it_yourself_converters.o
+do_it_yourself_convts.pyd: $(OBJ) do_it_yourself_convts.o
 	dllwrap $(DLLWRAPOPTS) \
-          --dllname do_it_yourself_converters.pyd \
-          --def do_it_yourself_converters.def \
-          $(OBJ) do_it_yourself_converters.o $(PYLIB)
+          --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) \
@@ -149,6 +160,24 @@ dvect.pyd: $(OBJ) dvect.o
           --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
 
@@ -158,17 +187,21 @@ test:
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_simple_vector.py
-	$(PYEXE) test_do_it_yourself_converters.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
+	-del *.o
+	-del *.a
+	-del *.pyd
+	-del *.pyc
 
 softlinks:
 	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) softlinks

build/tru64_cxx.mak

@@ -17,10 +17,10 @@
 ROOT=$(HOME)
 BOOST=$(ROOT)/boost
 
-PYEXE=/usr/local/Python-1.5.2/bin/python
+PYEXE=PYTHONPATH=. /usr/local/Python-1.5.2/bin/python
 PYINC=-I/usr/local/Python-1.5.2/include/python1.5
-#PYEXE=/usr/local/Python-2.0/bin/python
-#PYINC=-I/usr/local/Python-2.0/include/python2.0
+#PYEXE=PYTHONPATH=. /usr/local/Python-2.1/bin/python
+#PYINC=-I/usr/local/Python-2.1/include/python2.1
 #STLPORTINC=-I/usr/local/STLport-4.1b3/stlport
 #STLPORTINC=-I/usr/local/STLport-4.1b4/stlport
 #STLPORTOPTS= \
@@ -54,10 +54,12 @@ DEPOBJ=$(OBJ) \
        abstract.o \
        getting_started1.o getting_started2.o \
        simple_vector.o \
-       do_it_yourself_converters.o \
+       do_it_yourself_convts.o \
+       nested.o \
        pickle1.o pickle2.o pickle3.o \
        noncopyable_export.o noncopyable_import.o \
-       ivect.o dvect.o
+       ivect.o dvect.o \
+       richcmp1.o richcmp2.o richcmp3.o
 
 .SUFFIXES: .o .cpp
 
@@ -66,10 +68,12 @@ all: libboost_python.a \
      abstract.so \
      getting_started1.so getting_started2.so \
      simple_vector.so \
-     do_it_yourself_converters.so \
+     do_it_yourself_convts.so \
+     nested.so \
      pickle1.so pickle2.so pickle3.so \
      noncopyable_export.so noncopyable_import.so \
-     ivect.so dvect.so
+     ivect.so dvect.so \
+     richcmp1.so richcmp2.so richcmp3.so
 
 libboost_python.a: $(OBJ)
 	rm -f libboost_python.a
@@ -94,8 +98,11 @@ getting_started2.so: $(OBJ) getting_started2.o
 simple_vector.so: $(OBJ) simple_vector.o
 	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
 
-do_it_yourself_converters.so: $(OBJ) do_it_yourself_converters.o
-	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_converters.o -o do_it_yourself_converters.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
@@ -120,6 +127,15 @@ ivect.so: $(OBJ) ivect.o
 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
 
@@ -129,11 +145,15 @@ test:
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_simple_vector.py
-	$(PYEXE) test_do_it_yourself_converters.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
@@ -142,7 +162,8 @@ clean:
 	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_converters.o do_it_yourself_converters.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
@@ -150,6 +171,9 @@ clean:
 	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
 

build/vc60.mak

@@ -10,13 +10,16 @@
 #   12 Apr 01 new macro ROOT to simplify configuration (R.W. Grosse-Kunstleve)
 #   Initial version: R.W. Grosse-Kunstleve
 
-ROOT=L:
+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 /Zm200
 WARNOPTS=
@@ -40,10 +43,12 @@ all: boost_python.lib \
      abstract.pyd \
      getting_started1.pyd getting_started2.pyd \
      simple_vector.pyd \
-     do_it_yourself_converters.pyd \
+     do_it_yourself_convts.pyd \
+     nested.pyd \
      pickle1.pyd pickle2.pyd pickle3.pyd \
      noncopyable_export.pyd noncopyable_import.pyd \
-     ivect.pyd dvect.pyd
+     ivect.pyd dvect.pyd \
+     richcmp1.pyd richcmp2.pyd richcmp3.pyd
 
 boost_python.lib: $(OBJ)
 	$(LD) -lib /nologo /out:boost_python.lib $(OBJ)
@@ -63,8 +68,11 @@ getting_started2.pyd: $(OBJ) getting_started2.obj
 simple_vector.pyd: $(OBJ) simple_vector.obj
 	$(LD) $(LDOPTS) $(OBJ) simple_vector.obj $(PYLIB) /export:initsimple_vector /out:"simple_vector.pyd"
 
-do_it_yourself_converters.pyd: $(OBJ) do_it_yourself_converters.obj
-	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_converters.obj $(PYLIB) /export:initdo_it_yourself_converters /out:"do_it_yourself_converters.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"
@@ -87,6 +95,15 @@ ivect.pyd: $(OBJ) ivect.obj
 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
 
@@ -96,19 +113,23 @@ test:
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_simple_vector.py
-	$(PYEXE) test_do_it_yourself_converters.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
+	-del *.obj
+	-del *.lib
+	-del *.exp
+	-del *.idb
+	-del *.pyd
+	-del *.pyc
 
 softlinks:
 	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) softlinks

doc/enums.html

@@ -91,8 +91,8 @@ initialization. These bind the corresponding enum values to the appropriate
 names so they can be used from Python:
 
 <blockquote><pre>
-mymodule.add(boost::python::to_python(enum_value_1), "enum_value_1");
-mymodule.add(boost::python::to_python(enum_value_2), "enum_value_2");
+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>
 

doc/pointers.html

@@ -85,7 +85,7 @@ code before the last Python reference to it disappears:
 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<Foo&gt::ptr_to_python(p);
+      return boost::python::python_extension_class_converters<Foo>::smart_ptr_to_python(p);
   }
 
   PyObject* to_python(const Foo* p)

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

@@ -60,13 +60,27 @@
           <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, used to implement comparison operators
-          (&lt; etc.) Should return a negative integer if <code> self < other
-          </code> , zero if <code> self == other </code> , a positive integer if
-          <code> self > other </code>.
+	  Three-way compare function.
+          See <a href="richcmp.html">Rich Comparisons</a>.
         <dt>
           <b><tt class='method'>__hash__</tt></b>(<i>self</i>)
         <dd>
@@ -544,17 +558,42 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <code>__cmp__, __rcmp__</code>
           <td>
             <code>cmp(left, right)</code><br>
-             <code>left &lt; right</code><br>
-             <code>left &lt;= right</code><br>
-             <code>left &gt; right</code><br>
-             <code>left &gt;= right</code><br>
-             <code>left == right</code><br>
-             <code>left != right</code>
+            <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>

doc/under-the-hood.html

@@ -35,8 +35,7 @@
       "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= 
-      "http://www.boost.org/libs/utility/operators.htm">the boost operators
+      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

example/README

@@ -10,7 +10,7 @@ See also: libs/python/doc/pickle.html
 Other advanced concepts are introduced by:
   abstract.cpp
   simple_vector.cpp
-  do_it_yourself_converters.cpp
+  do_it_yourself_convts.cpp
 
 Examples for the cross-module support are provided by:
   noncopyable_export.cpp

example/do_it_yourself_convts.cpp

@@ -105,12 +105,12 @@ BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
 BOOST_PYTHON_END_CONVERSION_NAMESPACE
 
-BOOST_PYTHON_MODULE_INIT(do_it_yourself_converters)
+BOOST_PYTHON_MODULE_INIT(do_it_yourself_convts)
 {
   try
   {
     // Create an object representing this extension module.
-    python::module_builder this_module("do_it_yourself_converters");
+    python::module_builder this_module("do_it_yourself_convts");
 
     // Create the Python type object for our extension class.
     python::class_builder<IndexingSet> ixset_class(this_module, "IndexingSet");

example/dvect.h

@@ -9,7 +9,7 @@ namespace vects {
   struct dvect : public std::vector<double>
   {
     dvect() : std::vector<double>() {}
-    dvect(size_t n) : std::vector<double>(n) {}
+    dvect(std::size_t n) : std::vector<double>(n) {}
     dvect(boost::python::tuple tuple) : std::vector<double>(tuple.size())
     {
       std::vector<double>::iterator v_it = begin();

example/ivect.h

@@ -9,7 +9,7 @@ namespace vects {
   struct ivect : public std::vector<int>
   {
     ivect() : std::vector<int>() {}
-    ivect(size_t n) : std::vector<int>(n) {}
+    ivect(std::size_t n) : std::vector<int>(n) {}
     ivect(boost::python::tuple tuple) : std::vector<int>(tuple.size())
     {
       std::vector<int>::iterator v_it = begin();

example/nested.cpp

@@ -0,0 +1,44 @@
+// Example by Ralf W. Grosse-Kunstleve
+
+/*
+    This example shows how convert a nested Python tuple.
+ */
+
+#include <boost/python/class_builder.hpp>
+#include <stdio.h>
+
+namespace {
+
+  boost::python::list
+  show_nested_tuples(boost::python::tuple outer)
+  {
+    boost::python::list result;
+    for (int i = 0; i < outer.size(); i++) {
+      boost::python::tuple inner(
+        BOOST_PYTHON_CONVERSION::from_python(outer[i].get(),
+        boost::python::type<boost::python::tuple>()));
+      for (int j = 0; j < inner.size(); j++) {
+        double x = BOOST_PYTHON_CONVERSION::from_python(inner[j].get(),
+          boost::python::type<double>());
+        char buf[128];
+        sprintf(buf, "(%d,%d) %.6g", i, j, x);
+        result.append(BOOST_PYTHON_CONVERSION::to_python(std::string(buf)));
+      }
+    }
+    return result;
+  }
+
+}
+
+BOOST_PYTHON_MODULE_INIT(nested)
+{
+  try
+  {
+    boost::python::module_builder this_module("nested");
+    this_module.def(show_nested_tuples, "show_nested_tuples");
+  }
+  catch(...)
+  {
+    boost::python::handle_exception();
+  }
+}

example/pickle3.cpp

@@ -106,7 +106,7 @@ namespace {
   {
       if(args.size() != 1 || keywords.size() != 0) {
           PyErr_SetString(PyExc_TypeError, "wrong number of arguments");
-          throw boost::python::argument_error();
+          throw boost::python::error_already_set();
       }
       const world& w = from_python(args[0].get(), type<const world&>());
       ref mydict = getattr(args[0], "__dict__");
@@ -122,7 +122,7 @@ namespace {
   {
       if(args.size() != 2 || keywords.size() != 0) {
           PyErr_SetString(PyExc_TypeError, "wrong number of arguments");
-          throw boost::python::argument_error();
+          throw boost::python::error_already_set();
       }
       world& w = from_python(args[0].get(), type<world&>());
       ref mydict = getattr(args[0], "__dict__");

example/richcmp1.cpp

@@ -0,0 +1,87 @@
+// Example by Ralf W. Grosse-Kunstleve & Nicholas K. Sauter
+// This example shows how to use rich comparisons for a vector type.
+// It also shows how to template the entire wrapping of a std::vector.
+// See vector_wrapper.h.
+
+#include <boost/python/class_builder.hpp>
+#include "vector_wrapper.h"
+
+namespace vects {
+
+  struct dvect : public std::vector<double>
+  {
+    dvect() : std::vector<double>() {}
+    dvect(size_t n) : std::vector<double>(n) {}
+    dvect(boost::python::tuple tuple) : std::vector<double>(tuple.size())
+    {
+      std::vector<double>::iterator v_it = begin();
+      for (std::size_t i = 0; i < tuple.size(); i++)
+        v_it[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
+          boost::python::type<double>());
+    }
+
+    boost::python::tuple as_tuple() const
+    {
+      boost::python::tuple t(size());
+      for (std::size_t i = 0; i < size(); i++)
+        t.set_item(i,
+          boost::python::ref(BOOST_PYTHON_CONVERSION::to_python((*this)[i])));
+      return t;
+    }
+
+#   define DVECT_BINARY_OPERATORS(oper) \
+    friend std::vector<bool> \
+    operator##oper(const dvect& lhs, const dvect& rhs) \
+    { \
+      if (lhs.size() != rhs.size()) { \
+        PyErr_SetString(PyExc_ValueError, "vectors have different sizes"); \
+        throw boost::python::error_already_set(); \
+      } \
+      std::vector<bool> result(lhs.size()); \
+      for (std::size_t i=0; i<lhs.size(); i++) { \
+        result[i] = (lhs[i] ##oper rhs[i]); \
+      } \
+      return result; \
+    }
+    DVECT_BINARY_OPERATORS(<)
+    DVECT_BINARY_OPERATORS(<=)
+    DVECT_BINARY_OPERATORS(==)
+    DVECT_BINARY_OPERATORS(!=)
+    DVECT_BINARY_OPERATORS(>)
+    DVECT_BINARY_OPERATORS(>=)
+#   undef VECTOR_BINARY_OPERATORS
+  };
+
+} // namespace <anonymous>
+
+
+namespace {
+
+  void init_module(boost::python::module_builder& this_module)
+  {
+    (void) example::wrap_vector(this_module, "vector_of_bool", bool());
+
+    boost::python::class_builder<vects::dvect> py_dvect(this_module, "dvect");
+
+    py_dvect.def(boost::python::constructor<boost::python::tuple>());
+    py_dvect.def(&vects::dvect::as_tuple, "as_tuple");
+
+    const long
+    comp_operators = (  boost::python::op_lt | boost::python::op_le
+                      | boost::python::op_eq | boost::python::op_ne
+                      | boost::python::op_gt | boost::python::op_ge);
+    py_dvect.def(boost::python::operators<comp_operators>());
+  }
+
+} // namespace <anonymous>
+
+BOOST_PYTHON_MODULE_INIT(richcmp1)
+{
+  try {
+    boost::python::module_builder this_module("richcmp1");
+    // The actual work is done in a separate function in order
+    // to suppress a bogus VC60 warning.
+    init_module(this_module);
+  }
+  catch (...) { boost::python::handle_exception(); }
+}

example/richcmp2.cpp

@@ -0,0 +1,65 @@
+// Example by Ralf W. Grosse-Kunstleve
+// This example shows how to use rich comparisons for a type that
+// does not support all six operators (<, <=, ==, !=, >, >=).
+// To keep the example simple, we are using a "code" type does
+// not really require rich comparisons. __cmp__ would be sufficient.
+// However, with a more complicated type the main point of this
+// example would be in danger of getting lost.
+
+#include <boost/python/class_builder.hpp>
+
+namespace {
+
+  // suppose operator< and operator> are not meaningful for code
+  class code {
+    public:
+      code(int c = 0) : m_code(c) {}
+      inline friend bool operator==(const code& lhs, const code& rhs) {
+        return lhs.m_code == rhs.m_code;
+      }
+      inline friend bool operator!=(const code& lhs, const code& rhs) {
+        return lhs.m_code != rhs.m_code;
+      }
+    private:
+      int m_code;
+  };
+
+#if PYTHON_API_VERSION >= 1010
+  boost::python::ref
+  NotImplemented(const code&, const code&) {
+    return
+    boost::python::ref(Py_NotImplemented, boost::python::ref::increment_count);
+  }
+#endif
+}
+
+namespace {
+
+  void init_module(boost::python::module_builder& this_module)
+  {
+    boost::python::class_builder<code> py_code(this_module, "code");
+
+    py_code.def(boost::python::constructor<>());
+    py_code.def(boost::python::constructor<int>());
+    py_code.def(boost::python::operators<(  boost::python::op_eq
+                                          | boost::python::op_ne)>());
+#if PYTHON_API_VERSION >= 1010
+    py_code.def(NotImplemented, "__lt__");
+    py_code.def(NotImplemented, "__le__");
+    py_code.def(NotImplemented, "__gt__");
+    py_code.def(NotImplemented, "__ge__");
+#endif
+  }
+
+} // namespace <anonymous>
+
+BOOST_PYTHON_MODULE_INIT(richcmp2)
+{
+  try {
+    boost::python::module_builder this_module("richcmp2");
+    // The actual work is done in a separate function in order
+    // to suppress a bogus VC60 warning.
+    init_module(this_module);
+  }
+  catch (...) { boost::python::handle_exception(); }
+}

example/richcmp3.cpp

@@ -0,0 +1,178 @@
+// Example by Ralf W. Grosse-Kunstleve & Nicholas K. Sauter.
+// Comprehensive operator overloading for two vector types and scalars.
+
+#include <boost/python/class_builder.hpp>
+#include "vector_wrapper.h"
+#include "dvect.h"
+#include "ivect.h"
+
+#define VECT_VECT_OPERATORS(result_type, vect_type1, oper, vect_type2) \
+namespace vects { \
+  result_type \
+  operator##oper (const vect_type1& lhs, const vect_type2& rhs) { \
+    if (lhs.size() != rhs.size()) { \
+      PyErr_SetString(PyExc_ValueError, "vectors have different sizes"); \
+      throw boost::python::error_already_set(); \
+    } \
+    result_type result(lhs.size()); \
+    for (std::size_t i=0; i<lhs.size(); i++) { \
+      result[i] = (lhs[i] ##oper rhs[i]); \
+    } \
+    return result; \
+  } \
+}
+
+#define VECT_SCALAR_OPERATORS(result_type, vect_type, oper, scalar_type) \
+namespace vects { \
+  result_type \
+  operator##oper (const vect_type& lhs, const scalar_type& rhs) { \
+    result_type result(lhs.size()); \
+    for (std::size_t i=0; i<lhs.size(); i++) { \
+      result[i] = (lhs[i] ##oper rhs ); \
+    } \
+    return result; \
+  } \
+}
+
+#define SCALAR_VECT_OPERATORS(result_type, scalar_type, oper, vect_type) \
+namespace vects { \
+  result_type \
+  operator##oper (const scalar_type& lhs, const vect_type& rhs) { \
+    result_type result(rhs.size()); \
+    for (std::size_t i=0; i<rhs.size(); i++) { \
+      result[i] = (lhs ##oper rhs[i]); \
+    } \
+    return result; \
+  } \
+}
+
+#define MATH_VECT_VECT_OPERATORS(result_type, vect_type1, vect_type2) \
+  VECT_VECT_OPERATORS(result_type, vect_type1, +, vect_type2) \
+  VECT_VECT_OPERATORS(result_type, vect_type1, -, vect_type2) \
+  VECT_VECT_OPERATORS(result_type, vect_type1, *, vect_type2) \
+  VECT_VECT_OPERATORS(result_type, vect_type1, /, vect_type2)
+
+#define COMP_VECT_VECT_OPERATORS(vect_type1, vect_type2) \
+  VECT_VECT_OPERATORS(std::vector<bool>, vect_type1, <,  vect_type2) \
+  VECT_VECT_OPERATORS(std::vector<bool>, vect_type1, <=, vect_type2) \
+  VECT_VECT_OPERATORS(std::vector<bool>, vect_type1, ==, vect_type2) \
+  VECT_VECT_OPERATORS(std::vector<bool>, vect_type1, !=, vect_type2) \
+  VECT_VECT_OPERATORS(std::vector<bool>, vect_type1, >,  vect_type2) \
+  VECT_VECT_OPERATORS(std::vector<bool>, vect_type1, >=, vect_type2)
+
+#define MATH_VECT_SCALAR_OPERATORS(result_type, vect_type, scalar_type) \
+  VECT_SCALAR_OPERATORS(result_type, vect_type, +, scalar_type) \
+  VECT_SCALAR_OPERATORS(result_type, vect_type, -, scalar_type) \
+  VECT_SCALAR_OPERATORS(result_type, vect_type, *, scalar_type) \
+  VECT_SCALAR_OPERATORS(result_type, vect_type, /, scalar_type)
+
+#define COMP_VECT_SCALAR_OPERATORS(vect_type, scalar_type) \
+  VECT_SCALAR_OPERATORS(std::vector<bool>, vect_type, <,  scalar_type) \
+  VECT_SCALAR_OPERATORS(std::vector<bool>, vect_type, <=, scalar_type) \
+  VECT_SCALAR_OPERATORS(std::vector<bool>, vect_type, ==, scalar_type) \
+  VECT_SCALAR_OPERATORS(std::vector<bool>, vect_type, !=, scalar_type) \
+  VECT_SCALAR_OPERATORS(std::vector<bool>, vect_type, >,  scalar_type) \
+  VECT_SCALAR_OPERATORS(std::vector<bool>, vect_type, >=, scalar_type)
+
+#define MATH_SCALAR_VECT_OPERATORS(result_type, scalar_type, vect_type) \
+  SCALAR_VECT_OPERATORS(result_type, scalar_type, +, vect_type) \
+  SCALAR_VECT_OPERATORS(result_type, scalar_type, -, vect_type) \
+  SCALAR_VECT_OPERATORS(result_type, scalar_type, *, vect_type) \
+  SCALAR_VECT_OPERATORS(result_type, scalar_type, /, vect_type)
+
+MATH_VECT_VECT_OPERATORS(dvect, dvect, dvect)
+COMP_VECT_VECT_OPERATORS(       dvect, dvect)
+MATH_VECT_SCALAR_OPERATORS(dvect, dvect, double)
+COMP_VECT_SCALAR_OPERATORS(       dvect, double)
+MATH_SCALAR_VECT_OPERATORS(dvect, double, dvect)
+// comparison operators not needed since Python uses reflection
+
+MATH_VECT_VECT_OPERATORS(ivect, ivect, ivect)
+COMP_VECT_VECT_OPERATORS(       ivect, ivect)
+MATH_VECT_SCALAR_OPERATORS(ivect, ivect, int)
+COMP_VECT_SCALAR_OPERATORS(       ivect, int)
+MATH_SCALAR_VECT_OPERATORS(ivect, int, ivect)
+// comparison operators not needed since Python uses reflection
+
+MATH_VECT_VECT_OPERATORS(dvect, dvect, ivect)
+COMP_VECT_VECT_OPERATORS(       dvect, ivect)
+MATH_VECT_VECT_OPERATORS(dvect, ivect, dvect)
+COMP_VECT_VECT_OPERATORS(       ivect, dvect)
+
+#undef VECT_VECT_OPERATORS
+#undef SCALAR_VECT_OPERATORS
+#undef VECT_SCALAR_OPERATORS
+#undef MATH_VECT_VECT_OPERATORS
+#undef COMP_VECT_VECT_OPERATORS
+#undef MATH_VECT_SCALAR_OPERATORS
+#undef COMP_VECT_SCALAR_OPERATORS
+#undef MATH_SCALAR_VECT_OPERATORS
+
+namespace {
+
+  void init_module(boost::python::module_builder& this_module)
+  {
+    (void) example::wrap_vector(this_module, "vector_of_bool", bool());
+
+    const long
+    math_operators (  boost::python::op_mul | boost::python::op_add
+                    | boost::python::op_div | boost::python::op_sub);
+    const long
+    comp_operators = (  boost::python::op_lt | boost::python::op_le
+                      | boost::python::op_eq | boost::python::op_ne
+                      | boost::python::op_gt | boost::python::op_ge);
+
+    boost::python::class_builder<vects::dvect>
+      dvect_class(this_module, "dvect");
+    boost::python::class_builder<vects::ivect>
+      ivect_class(this_module, "ivect");
+
+    dvect_class.def(boost::python::constructor<boost::python::tuple>());
+    dvect_class.def(&vects::dvect::as_tuple,"as_tuple");
+
+    dvect_class.def(boost::python::operators<math_operators>());
+    dvect_class.def(boost::python::operators<math_operators>(),
+      boost::python::right_operand<double>() );
+    dvect_class.def(boost::python::operators<math_operators>(),
+      boost::python::left_operand<double>() );
+    dvect_class.def(boost::python::operators<math_operators>(),
+      boost::python::right_operand<vects::ivect>() );
+
+    dvect_class.def(boost::python::operators<comp_operators>());
+    dvect_class.def(boost::python::operators<comp_operators>(),
+      boost::python::right_operand<double>() );
+    // left_operand not needed since Python uses reflection
+    dvect_class.def(boost::python::operators<comp_operators>(),
+      boost::python::right_operand<vects::ivect>() );
+
+    ivect_class.def(boost::python::constructor<boost::python::tuple>());
+    ivect_class.def(&vects::ivect::as_tuple,"as_tuple");
+
+    ivect_class.def(boost::python::operators<math_operators>());
+    ivect_class.def(boost::python::operators<math_operators>(),
+      boost::python::right_operand<int>() );
+    ivect_class.def(boost::python::operators<math_operators>(),
+      boost::python::left_operand<int>() );
+    ivect_class.def(boost::python::operators<math_operators>(),
+      boost::python::right_operand<vects::dvect>() );
+
+    ivect_class.def(boost::python::operators<comp_operators>());
+    ivect_class.def(boost::python::operators<comp_operators>(),
+      boost::python::right_operand<int>() );
+    // left_operand not needed since Python uses reflection
+    ivect_class.def(boost::python::operators<comp_operators>(),
+      boost::python::right_operand<vects::dvect>() );
+  }
+
+} // namespace <anonymous>
+
+BOOST_PYTHON_MODULE_INIT(richcmp3)
+{
+  try {
+    boost::python::module_builder this_module("richcmp3");
+    // The actual work is done in a separate function in order
+    // to suppress a bogus VC60 warning.
+    init_module(this_module);
+  }
+  catch (...) { boost::python::handle_exception(); }
+}

example/test_do_it_yourself_convts.py

@@ -1,5 +1,5 @@
-r'''>>> import do_it_yourself_converters
-    >>> ixset = do_it_yourself_converters.IndexingSet()
+r'''>>> import do_it_yourself_convts
+    >>> ixset = do_it_yourself_convts.IndexingSet()
     >>> ixset.add((1,2,3))
     >>> ixset.add((4,5,6))
     >>> ixset.add((7,8,9))
@@ -15,8 +15,8 @@ def run(args = None):
     if args is not None:
         import sys
         sys.argv = args
-    import doctest, test_do_it_yourself_converters
-    return doctest.testmod(test_do_it_yourself_converters)
+    import doctest, test_do_it_yourself_convts
+    return doctest.testmod(test_do_it_yourself_convts)
 
 if __name__ == '__main__':
     import sys

example/test_nested.py

@@ -0,0 +1,23 @@
+r'''>>> import nested
+    >>> s = nested.show_nested_tuples(((1,2,3), (4,5,6,7)))
+    >>> for l in s:
+    ...   print l
+    (0,0) 1
+    (0,1) 2
+    (0,2) 3
+    (1,0) 4
+    (1,1) 5
+    (1,2) 6
+    (1,3) 7
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_nested
+    return doctest.testmod(test_nested)
+
+if __name__ == '__main__':
+    import sys
+    sys.exit(run()[0])

example/test_pickle3.py

@@ -19,12 +19,12 @@ r'''>>> import pickle3
     ...   wd.z = 3. * number
     ...   pstr = pickle.dumps(wd)
     ...   wl = pickle.loads(pstr)
-    ...   print wd.greet(), wd.get_secret_number(), wd.__dict__
-    ...   print wl.greet(), wl.get_secret_number(), wl.__dict__
-    Hello from California! 24 {'z': 72.0, 'x': 48, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyy'}
-    Hello from California! 24 {'z': 72.0, 'x': 48, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyy'}
-    Hello from California! 42 {'z': 126.0, 'x': 84, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'}
-    Hello from California! 0 {'z': 126.0, 'x': 84, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'}
+    ...   print wd.greet(), wd.get_secret_number(), wd.x, wd.y, wd.z
+    ...   print wl.greet(), wl.get_secret_number(), wl.x, wl.y, wl.z
+    Hello from California! 24 48 yyyyyyyyyyyyyyyyyyyyyyyy 72.0
+    Hello from California! 24 48 yyyyyyyyyyyyyyyyyyyyyyyy 72.0
+    Hello from California! 42 84 yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy 126.0
+    Hello from California! 0 84 yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy 126.0
 '''
 
 def run(args = None):

example/test_richcmp1.py

@@ -0,0 +1,40 @@
+r'''>>> import richcmp1
+    >>> d1 = richcmp1.dvect((0, 1, 3, 3, 6, 7))
+    >>> d2 = richcmp1.dvect((1, 2, 3, 4, 5, 6))
+    >>> print d1.as_tuple()
+    (0.0, 1.0, 3.0, 3.0, 6.0, 7.0)
+    >>> print d2.as_tuple()
+    (1.0, 2.0, 3.0, 4.0, 5.0, 6.0)
+    >>> print (d1 < d2).as_tuple()
+    (1, 1, 0, 1, 0, 0)
+    >>> print (d1 <= d2).as_tuple()
+    (1, 1, 1, 1, 0, 0)
+    >>> print (d1 == d2).as_tuple()
+    (0, 0, 1, 0, 0, 0)
+    >>> print (d1 != d2).as_tuple()
+    (1, 1, 0, 1, 1, 1)
+    >>> print (d1 > d2).as_tuple()
+    (0, 0, 0, 0, 1, 1)
+    >>> print (d1 >= d2).as_tuple()
+    (0, 0, 1, 0, 1, 1)
+    >>> try: d1 == richcmp1.dvect((1, 2, 3, 4, 5))
+    ... except ValueError, e: print str(e)
+    ...
+    vectors have different sizes
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_richcmp1
+    return doctest.testmod(test_richcmp1)
+
+if __name__ == '__main__':
+    import sys
+    if (    hasattr(sys, 'version_info')
+        and (   (sys.version_info[0] == 2 and sys.version_info[1] >= 1)
+             or sys.version_info[0] > 2)):
+      sys.exit(run()[0])
+    else:
+      print "Python version 2.1 or higher required. Test skipped."

example/test_richcmp2.py

@@ -0,0 +1,41 @@
+r'''>>> import richcmp2
+    >>> c1 = richcmp2.code(1)
+    >>> c2 = richcmp2.code(2)
+    >>> c3 = richcmp2.code(2)
+    >>> print c1 == c2
+    0
+    >>> print c1 != c2
+    1
+    >>> print c2 == c3
+    1
+    >>> print c2 != c3
+    0
+    >>> print c1 < c2
+    1
+    >>> print c1 <= c2
+    1
+    >>> print c1 == c2
+    0
+    >>> print c1 != c2
+    1
+    >>> print c1 > c2
+    0
+    >>> print c1 >= c2
+    0
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_richcmp1
+    return doctest.testmod(test_richcmp1)
+
+if __name__ == '__main__':
+    import sys
+    if (    hasattr(sys, 'version_info')
+        and (   (sys.version_info[0] == 2 and sys.version_info[1] >= 1)
+             or sys.version_info[0] > 2)):
+      sys.exit(run()[0])
+    else:
+      print "Python version 2.1 or higher required. Test skipped."

example/test_richcmp3.py

@@ -0,0 +1,77 @@
+r'''>>> import richcmp3
+    >>>
+    >>> iv = richcmp3.ivect((1,2,3,4,5))
+    >>> print iv.as_tuple()
+    (1, 2, 3, 4, 5)
+    >>> dv = richcmp3.dvect((2,-2,3,8,-5))
+    >>> print dv.as_tuple()
+    (2.0, -2.0, 3.0, 8.0, -5.0)
+    >>>
+    >>> print (iv+dv).as_tuple()
+    (3.0, 0.0, 6.0, 12.0, 0.0)
+    >>> print (iv+3).as_tuple()
+    (4, 5, 6, 7, 8)
+    >>> print (3+iv).as_tuple()
+    (4, 5, 6, 7, 8)
+    >>>
+    >>> print "vect vs. vect Comparisons:"
+    vect vs. vect Comparisons:
+    >>> print (iv < dv).as_tuple()
+    (1, 0, 0, 1, 0)
+    >>> print (iv <= dv).as_tuple()
+    (1, 0, 1, 1, 0)
+    >>> print (iv == dv).as_tuple()
+    (0, 0, 1, 0, 0)
+    >>> print (iv != dv).as_tuple()
+    (1, 1, 0, 1, 1)
+    >>> print (iv > dv).as_tuple()
+    (0, 1, 0, 0, 1)
+    >>> print (iv >= dv).as_tuple()
+    (0, 1, 1, 0, 1)
+    >>>
+    >>> print "vect vs. scalar Comparisons:"
+    vect vs. scalar Comparisons:
+    >>> print (iv < 3).as_tuple()
+    (1, 1, 0, 0, 0)
+    >>> print (iv <= 3).as_tuple()
+    (1, 1, 1, 0, 0)
+    >>> print (iv == 3).as_tuple()
+    (0, 0, 1, 0, 0)
+    >>> print (iv != 3).as_tuple()
+    (1, 1, 0, 1, 1)
+    >>> print (iv > 3).as_tuple()
+    (0, 0, 0, 1, 1)
+    >>> print (iv >= 3).as_tuple()
+    (0, 0, 1, 1, 1)
+    >>>
+    >>> print "scalar  vs. vect Comparisons:"
+    scalar  vs. vect Comparisons:
+    >>> print (3 < iv).as_tuple()
+    (0, 0, 0, 1, 1)
+    >>> print (3 <= iv).as_tuple()
+    (0, 0, 1, 1, 1)
+    >>> print (3 == iv).as_tuple()
+    (0, 0, 1, 0, 0)
+    >>> print (3 != iv).as_tuple()
+    (1, 1, 0, 1, 1)
+    >>> print (3 > iv).as_tuple()
+    (1, 1, 0, 0, 0)
+    >>> print (3 >= iv).as_tuple()
+    (1, 1, 1, 0, 0)
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_richcmp3
+    return doctest.testmod(test_richcmp3)
+
+if __name__ == '__main__':
+    import sys
+    if (    hasattr(sys, 'version_info')
+        and (   (sys.version_info[0] == 2 and sys.version_info[1] >= 1)
+             or sys.version_info[0] > 2)):
+      sys.exit(run()[0])
+    else:
+      print "Python version 2.1 or higher required. Test skipped."

example/vector_wrapper.h

@@ -0,0 +1,117 @@
+// Based on wrapVector.hh by Mike Owen and Jeff Johnson.
+// http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/spheral/src/src/BPLWraps/CXXWraps/
+
+#ifndef BOOST_PYTHON_EXAMPLE_VECTOR_WRAPPER_H
+#define BOOST_PYTHON_EXAMPLE_VECTOR_WRAPPER_H
+
+#include <boost/python/class_builder.hpp>
+
+namespace example {
+
+  // A wrapper is used to define additional constructors. This wrapper
+  // is templated on the template parameter for its corresponding vector.
+  template <typename T>
+  struct vector_wrapper: std::vector<T>
+  {
+    // Tell the compiler how to convert a base class object to
+    // this wrapper object.
+    vector_wrapper(PyObject*,
+                  const std::vector<T>& vec):
+      std::vector<T>(vec) {}
+
+    vector_wrapper(PyObject* self):
+      std::vector<T>() {}
+
+    vector_wrapper(PyObject* self,
+                   std::size_t n):
+      std::vector<T>(n) {}
+
+    vector_wrapper(PyObject* self,
+                   boost::python::tuple tuple):
+      std::vector<T>(tuple.size())
+    {
+      std::vector<T>::iterator vec = begin();
+      for (std::size_t i = 0; i < tuple.size(); i++)
+        vec[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
+                                            boost::python::type<T>());
+    }
+  };
+
+  void raise_vector_IndexError() {
+    PyErr_SetString(PyExc_IndexError, "vector index out of range");
+    throw boost::python::error_already_set();
+  }
+
+  template <typename T>
+  struct vector_access
+  {
+    static
+    T
+    getitem(const std::vector<T>& vec,
+            std::size_t key)
+    {
+      if (key >= vec.size()) raise_vector_IndexError();
+      return vec[key];
+    }
+
+    static
+    void
+    setitem(std::vector<T>& vec,
+            std::size_t key,
+            const T &value)
+    {
+      if (key >= vec.size()) raise_vector_IndexError();
+      vec[key] = value;
+    }
+
+    static
+    void
+    delitem(std::vector<T>& vec,
+            std::size_t key)
+    {
+      if (key >= vec.size()) raise_vector_IndexError();
+      vec.erase(vec.begin() + key);
+    }
+
+    // Convert vector<T> to a regular Python tuple.
+    static
+    boost::python::tuple
+    as_tuple(const std::vector<T>& vec)
+    {
+      // Create a python type of size vec.size().
+      boost::python::tuple t(vec.size());
+      for (std::size_t i = 0; i < vec.size(); i++) {
+        t.set_item(i,
+          boost::python::ref(BOOST_PYTHON_CONVERSION::to_python(vec[i])));
+      }
+      return t;
+    }
+  };
+
+  // This function will build a vector<T> and add it to the given
+  // module with the given name.
+  template <typename T>
+  boost::python::class_builder<std::vector<T>, vector_wrapper<T> >
+  wrap_vector(boost::python::module_builder& module,
+              const std::string& vector_name,
+              const T&)
+  {
+    // Add the vector<T> to the module.
+    boost::python::class_builder<std::vector<T>, vector_wrapper<T> >
+    py_vector(module, vector_name.c_str());
+
+    // Define constructors and methods for the vector<T>.
+    py_vector.def(boost::python::constructor<>());
+    py_vector.def(boost::python::constructor<std::size_t>());
+    py_vector.def(boost::python::constructor<boost::python::tuple>());
+    py_vector.def(&std::vector<T>::size, "__len__");
+    py_vector.def(&vector_access<T>::getitem, "__getitem__");
+    py_vector.def(&vector_access<T>::setitem, "__setitem__");
+    py_vector.def(&vector_access<T>::delitem, "__delitem__");
+    py_vector.def(&vector_access<T>::as_tuple, "as_tuple");
+
+    return py_vector;
+  }
+}
+
+#endif // BOOST_PYTHON_EXAMPLE_VECTOR_WRAPPER_H

include/boost/python/classes.hpp

@@ -70,6 +70,14 @@ class instance
     PyObject* oct();
     PyObject* hex();
 
+    // Rich comparisons
+    PyObject* lt(PyObject* other);
+    PyObject* le(PyObject* other);
+    PyObject* eq(PyObject* other);
+    PyObject* ne(PyObject* other);
+    PyObject* gt(PyObject* other);
+    PyObject* ge(PyObject* other);
+
  private: // noncopyable, without the size bloat
     instance(const instance&);
     void operator=(const instance&);
@@ -169,6 +177,14 @@ class class_t
     PyObject* instance_number_float(PyObject*) const;
     PyObject* instance_number_oct(PyObject*) const;
     PyObject* instance_number_hex(PyObject*) const;
+
+ private: // Implement rich comparisons
+    PyObject* instance_lt(PyObject*, PyObject*) const;
+    PyObject* instance_le(PyObject*, PyObject*) const;
+    PyObject* instance_eq(PyObject*, PyObject*) const;
+    PyObject* instance_ne(PyObject*, PyObject*) const;
+    PyObject* instance_gt(PyObject*, PyObject*) const;
+    PyObject* instance_ge(PyObject*, PyObject*) const;
     
  private: // Miscellaneous "special" methods
     PyObject* instance_call(PyObject* obj, PyObject* args, PyObject* keywords) const;
@@ -477,6 +493,42 @@ PyObject* class_t<T>::instance_number_hex(PyObject* obj) const
     return downcast<T>(obj)->hex();
 }
 
+template <class T>
+PyObject* class_t<T>::instance_lt(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->lt(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_le(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->le(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_eq(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->eq(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_ne(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->ne(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_gt(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->gt(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_ge(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->ge(other);
+}
+
 namespace detail {
   inline dictionary& class_base::dict()
   {

include/boost/python/conversions.hpp

@@ -7,6 +7,7 @@
 //  producing this work.
 //
 // Revision History:
+// 31 Jul 01  convert int/double to complex (Peter Bienstman)
 // 04 Mar 01  Fixed std::complex<> stuff to work with MSVC (David Abrahams)
 // 03 Mar 01  added: converters for [plain] char and std::complex
 //            (Ralf W. Grosse-Kunstleve)
@@ -93,6 +94,10 @@ namespace detail {
   template <class T>
   std::complex<T> complex_from_python(PyObject* p, boost::python::type<T>)
   {
+      if (PyInt_Check(p)) return std::complex<T>(PyInt_AS_LONG(p));
+      if (PyLong_Check(p)) return std::complex<T>(PyLong_AsDouble(p));
+      if (PyFloat_Check(p)) return std::complex<T>(PyFloat_AS_DOUBLE(p));
+
       expect_complex(p);
 
       return std::complex<T>(

include/boost/python/detail/base_object.hpp

@@ -21,10 +21,10 @@ namespace boost { namespace python { namespace detail {
 
 // base_object - adds a constructor and non-virtual destructor to a
 // base Python type (e.g. PyObject, PyTypeObject).
-template <class python_type>
-struct base_object : python_type
+template <class PythonType>
+struct base_object : PythonType
 {
-    typedef python_type base_python_type;
+    typedef PythonType base_python_type;
 
     // Initializes type and reference count. All other fields of base_python_type are 0
     base_object(PyTypeObject* type_obj);
@@ -39,10 +39,10 @@ typedef base_object<PyTypeObject> python_type;
 
 
 //
-// class_t template member function implementations 
+// base_object member function implementations 
 //
-template <class python_type>
-base_object<python_type>::base_object(PyTypeObject* type_obj)
+template <class PythonType>
+base_object<PythonType>::base_object(PyTypeObject* type_obj)
 {
     base_python_type* bp = this;
 #if !defined(_MSC_VER) || defined(__STLPORT)
@@ -53,8 +53,8 @@ base_object<python_type>::base_object(PyTypeObject* type_obj)
     PyObject_INIT(bp, type_obj);
 }
 
-template <class python_type>
-inline base_object<python_type>::~base_object()
+template <class PythonType>
+inline base_object<PythonType>::~base_object()
 {
     Py_DECREF(ob_type);
 }

include/boost/python/detail/cast.hpp

@@ -15,14 +15,6 @@
 namespace boost { namespace python {
 
 namespace detail {
-  // The default way of converting a PyObject* or PyTypeObject* to a T*
-  template <class T>
-  struct downcast_traits
-  {
-      template <class U>
-      static T* cast(U* p) { return static_cast<T*>(p); }
-  };
-
   inline PyTypeObject* as_base_object(const PyTypeObject*, PyObject* p)
   {
       return reinterpret_cast<PyTypeObject*>(p);
@@ -51,25 +43,30 @@ inline PyObject* as_object(PyTypeObject* p) { return reinterpret_cast<PyObject*>
 // If I didn't have to support stupid MSVC6 we could just use a simple template function:
 // template <class T> T* downcast(PyObject*).
 template <class T>
-struct downcast : boost::dereferenceable<downcast<T>, T*>
+struct downcast
 {
     downcast(PyObject* p)
-        : m_p(detail::downcast_traits<T>::cast(detail::as_base_object((T*)0, p)))
+        : m_p(static_cast<T*>(detail::as_base_object((T*)0, p)))
         {}
     
     downcast(const PyObject* p)
-        : m_p(detail::downcast_traits<T>::cast(detail::as_base_object((const T*)0, p)))
+        : m_p(static_cast<T*>(detail::as_base_object((const T*)0, p)))
         {}
     
     downcast(PyTypeObject* p)
-        : m_p(detail::downcast_traits<T>::cast(p))
+        : m_p(static_cast<T*>(p))
         {}
     
     downcast(const PyTypeObject* p)
-        : m_p(detail::downcast_traits<T>::cast(p))
+        : m_p(static_cast<T*>(p))
         {}
     
     operator T*() const { return m_p; }
+
+    // MSVC doesn't like boost::dereferencable unless T has a default
+    // constructor, so operator-> must be defined by hand :(
+    T* operator->() const { return &**this; }
+    
     T* get() const { return m_p; }
     T& operator*() const { return *m_p; }
  private:

include/boost/python/detail/extension_class.hpp

@@ -616,6 +616,12 @@ class extension_class
         choose_op<(which & op_and)>::template args<Operand>::add(this);
         choose_op<(which & op_xor)>::template args<Operand>::add(this);
         choose_op<(which & op_or)>::template args<Operand>::add(this);
+        choose_op<(which & op_gt)>::template args<Operand>::add(this);
+        choose_op<(which & op_ge)>::template args<Operand>::add(this);
+        choose_op<(which & op_lt)>::template args<Operand>::add(this);
+        choose_op<(which & op_le)>::template args<Operand>::add(this);
+        choose_op<(which & op_eq)>::template args<Operand>::add(this);
+        choose_op<(which & op_ne)>::template args<Operand>::add(this);
         choose_unary_op<(which & op_neg)>::template args<Operand>::add(this);
         choose_unary_op<(which & op_pos)>::template args<Operand>::add(this);
         choose_unary_op<(which & op_abs)>::template args<Operand>::add(this);
@@ -645,6 +651,12 @@ class extension_class
         choose_op<(which & op_xor)>::template args<Left,Right>::add(this);
         choose_op<(which & op_or)>::template args<Left,Right>::add(this);
         choose_op<(which & op_cmp)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_gt)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_ge)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_lt)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_le)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_eq)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_ne)>::template args<Left,Right>::add(this);
     }
     
     template <long which, class Left, class Right>

include/boost/python/detail/functions.hpp

@@ -46,7 +46,7 @@ class function : public python_object
  private:
     struct type_object;
  private:
-    reference<function> m_overloads;
+    reference<function> m_overloads; // A linked list of the function overloads
 };
 
 // wrapped_function_pointer<> --
@@ -66,7 +66,12 @@ struct wrapped_function_pointer : function
 
  private:
 	PyObject* do_call(PyObject* args, PyObject* keywords) const
-        { return caller<R>::call(m_pf, args, keywords); }
+        {
+            // This is where the boundary between the uniform Python function
+            // interface and the statically-checked C++ function interface is
+            // crossed.
+            return caller<R>::call(m_pf, args, keywords);
+        }
     
     const char* description() const
         { return typeid(F).name(); }

include/boost/python/detail/types.hpp

@@ -45,7 +45,7 @@ class type_object_base : public python_type
 
  public:
     enum capability {
-        hash, call, str, getattr, setattr, compare, repr,
+        hash, call, str, getattr, setattr, compare, repr, richcompare,
 
         mapping_length, mapping_subscript, mapping_ass_subscript,
         
@@ -115,6 +115,14 @@ class type_object_base : public python_type
     virtual PyObject* instance_number_float(PyObject*) const;
     virtual PyObject* instance_number_oct(PyObject*) const;
     virtual PyObject* instance_number_hex(PyObject*) const;
+
+ public: // Callbacks for rich comparisons
+    virtual PyObject* instance_lt(PyObject*, PyObject*) const;
+    virtual PyObject* instance_le(PyObject*, PyObject*) const;
+    virtual PyObject* instance_eq(PyObject*, PyObject*) const;
+    virtual PyObject* instance_ne(PyObject*, PyObject*) const;
+    virtual PyObject* instance_gt(PyObject*, PyObject*) const;
+    virtual PyObject* instance_ge(PyObject*, PyObject*) const;
 };
 
 template <class T>

include/boost/python/objects.hpp

@@ -101,7 +101,7 @@ class list : public object
     explicit list(std::size_t sz = 0);
     static PyTypeObject* type_obj();
     static bool accepts(ref p);
-    std::size_t size();
+    std::size_t size() const;
     ref operator[](std::size_t pos) const;
     proxy operator[](std::size_t pos);
     ref get_item(std::size_t pos) const;
@@ -283,7 +283,7 @@ struct list::slice_proxy
     const list& operator=(const list& rhs);
     operator ref() const;
     operator list() const;
-    std::size_t size();
+    std::size_t size() const;
     ref operator[](std::size_t pos) const;
  private:
     friend class list;

include/boost/python/operators.hpp

@@ -65,7 +65,13 @@ enum operator_id
     op_long = 0x20000, 
     op_float = 0x40000, 
     op_str = 0x80000,
-    op_cmp = 0x100000 
+    op_cmp = 0x100000,
+    op_gt = 0x200000,
+    op_ge = 0x400000,
+    op_lt = 0x800000,
+    op_le = 0x1000000,
+    op_eq = 0x2000000,
+    op_ne = 0x4000000
 };
 
 // Wrap the operators given by "which". Usage:
@@ -301,6 +307,12 @@ namespace detail
   PY_DEFINE_BINARY_OPERATORS(and, &);
   PY_DEFINE_BINARY_OPERATORS(xor, ^);
   PY_DEFINE_BINARY_OPERATORS(or, |);
+  PY_DEFINE_BINARY_OPERATORS(gt, >);
+  PY_DEFINE_BINARY_OPERATORS(ge, >=);
+  PY_DEFINE_BINARY_OPERATORS(lt, <);
+  PY_DEFINE_BINARY_OPERATORS(le, <=);
+  PY_DEFINE_BINARY_OPERATORS(eq, ==);
+  PY_DEFINE_BINARY_OPERATORS(ne, !=);
 
   PY_DEFINE_UNARY_OPERATORS(neg, -);
   PY_DEFINE_UNARY_OPERATORS(pos, +);

include/boost/python/reference.hpp

@@ -20,7 +20,7 @@
 
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
-template <class T, class Value, class Base>
+template <class T, class Value, class Base = boost::detail::empty_base>
 struct py_ptr_conversions : Base
 {
     inline friend T from_python(PyObject* x, boost::python::type<const T&>)
@@ -42,8 +42,7 @@ BOOST_PYTHON_IMPORT_CONVERSION(py_ptr_conversions);
 
 template <class T>
 class reference
-	: public py_ptr_conversions<reference<T>, T,
-       boost::dereferenceable<reference<T>, T*> > // supplies op->
+	: public py_ptr_conversions<reference<T>, T>
 {
 public:
     typedef T value_type;
@@ -117,6 +116,10 @@ public:
 	
 	T& operator*() const { return *m_p; }
     
+    // MSVC doesn't like boost::dereferencable unless T has a default
+    // constructor, so operator-> must be defined by hand :(
+    T* operator->() const { return &**this; } 
+    
 	T* get() const { return m_p; }
 
 	T* release()

src/classes.cpp

@@ -736,6 +736,36 @@ PyObject* instance::hex()
     return callback<PyObject*>::call_method(this, "__hex__");
 }
 
+PyObject* instance::lt(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__lt__", other);
+}
+
+PyObject* instance::le(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__le__", other);
+}
+
+PyObject* instance::eq(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__eq__", other);
+}
+
+PyObject* instance::ne(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__ne__", other);
+}
+
+PyObject* instance::gt(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__gt__", other);
+}
+
+PyObject* instance::ge(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__ge__", other);
+}
+
 namespace {
   struct named_capability
   {
@@ -747,6 +777,12 @@ namespace {
   {
       { "__hash__", detail::type_object_base::hash },
       { "__cmp__", detail::type_object_base::compare },
+      { "__gt__", detail::type_object_base::richcompare },
+      { "__ge__", detail::type_object_base::richcompare },
+      { "__lt__", detail::type_object_base::richcompare },
+      { "__le__", detail::type_object_base::richcompare },
+      { "__eq__", detail::type_object_base::richcompare },
+      { "__ne__", detail::type_object_base::richcompare },
       { "__repr__", detail::type_object_base::repr },
       { "__str__", detail::type_object_base::str },
       { "__call__", detail::type_object_base::call },

src/functions.cpp

@@ -61,6 +61,8 @@ function::function()
 
 PyObject* function::call(PyObject* args, PyObject* keywords) const
 {
+    // Traverse the linked list of function overloads until we find one that
+    // matches.
     for (const function* f = this; f != 0; f = f->m_overloads.get())
     {
         PyErr_Clear();
@@ -75,9 +77,14 @@ PyObject* function::call(PyObject* args, PyObject* keywords) const
         }
     }
 
+    // If we get here, no overloads matched the arguments
+
+    // Allow the single-function error-reporting to take effect unless there was
+    // an overload
     if (m_overloads.get() == 0)
         return 0;
 
+    // Synthesize a more-explicit error message
     PyErr_Clear();
     string message("No overloaded functions match (");
     tuple arguments(ref(args, ref::increment_count));

src/gen_extclass.py

@@ -15,6 +15,7 @@ def gen_extclass(args):
 //  gen_extclass.python
 
 //  Revision History:
+//  17 Apr 01  Comment added with reference to cross_module.hpp (R.W. Grosse-Kunstleve)
 //  05 Mar 01  Fixed a bug which prevented auto_ptr values from being converted
 //             to_python (Dave Abrahams)
 
@@ -171,6 +172,14 @@ BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 // and U. T is the class the user really intends to wrap. U is a class derived
 // from T with some virtual function overriding boilerplate, or if there are no
 // virtual functions, U = held_instance<T>.
+//
+// A look-alike of this class in root/boost/python/cross_module.hpp
+// is used for the implementation of the cross-module support
+// (export_converters and import_converters). If from_python
+// and to_python converters are added or removed from the class
+// below, the class python_import_extension_class_converters has
+// to be modified accordingly.
+//
 template <class T, class U = boost::python::detail::held_instance<T> >
 class python_extension_class_converters
 {
@@ -607,6 +616,12 @@ class extension_class
         choose_op<(which & op_and)>::template args<Operand>::add(this);
         choose_op<(which & op_xor)>::template args<Operand>::add(this);
         choose_op<(which & op_or)>::template args<Operand>::add(this);
+        choose_op<(which & op_gt)>::template args<Operand>::add(this);
+        choose_op<(which & op_ge)>::template args<Operand>::add(this);
+        choose_op<(which & op_lt)>::template args<Operand>::add(this);
+        choose_op<(which & op_le)>::template args<Operand>::add(this);
+        choose_op<(which & op_eq)>::template args<Operand>::add(this);
+        choose_op<(which & op_ne)>::template args<Operand>::add(this);
         choose_unary_op<(which & op_neg)>::template args<Operand>::add(this);
         choose_unary_op<(which & op_pos)>::template args<Operand>::add(this);
         choose_unary_op<(which & op_abs)>::template args<Operand>::add(this);
@@ -636,6 +651,12 @@ class extension_class
         choose_op<(which & op_xor)>::template args<Left,Right>::add(this);
         choose_op<(which & op_or)>::template args<Left,Right>::add(this);
         choose_op<(which & op_cmp)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_gt)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_ge)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_lt)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_le)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_eq)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_ne)>::template args<Left,Right>::add(this);
     }
     
     template <long which, class Left, class Right>

src/gen_init_function.py

@@ -79,7 +79,8 @@ namespace detail {
   struct parameter_traits
   {
    private:
-      typedef const_ref_selector<boost::is_reference<T>::value> selector;
+      enum { is_ref = boost::is_reference<T>::value };
+      typedef const_ref_selector<is_ref> selector;
    public:
       typedef typename selector::template const_ref<T>::type const_reference;
   };

src/objects.cpp

@@ -362,7 +362,7 @@ bool list::accepts(ref p)
     return PyList_Check(p.get());
 }
 
-std::size_t list::size()
+std::size_t list::size() const
 {
     return PyList_Size(get());
 }
@@ -467,7 +467,7 @@ list::slice_proxy::operator list() const
     return list(this->operator ref());
 }
 
-std::size_t list::slice_proxy::size()
+std::size_t list::slice_proxy::size() const
 {
     return this->operator list().size();
 }

src/types.cpp

@@ -24,6 +24,11 @@ namespace {
 
   using detail::type_object_base;
 
+  // Define a family of forwarding functions that can be calle from a
+  // PyTypeObject's slots. These functions dispatch through a (virtual) member
+  // function pointer in the type_object_base, and handle exceptions in a
+  // uniform way, preventing us from having to rewrite the dispatching code over
+  // and over.
   PyObject* call(PyObject* obj, PyObject* (type_object_base::*f)(PyObject*) const)
   {
       try
@@ -154,11 +159,37 @@ namespace {
 
 extern "C" {
 
+//
+// These functions actually go into the type object's slots, and dispatch to the
+// "call" wrappers defined above.
+//
 static PyObject* do_instance_repr(PyObject* obj)
 {
     return call(obj, &type_object_base::instance_repr);
 }
 
+static PyObject* do_instance_richcompare(PyObject* obj, PyObject* other, int d)
+{
+#if PYTHON_API_VERSION >= 1010
+    switch(d)
+    {
+        case Py_LT: 
+          return call(obj, &type_object_base::instance_lt, other);
+        case Py_LE: 
+          return call(obj, &type_object_base::instance_le, other);
+        case Py_EQ: 
+          return call(obj, &type_object_base::instance_eq, other);
+        case Py_NE: 
+          return call(obj, &type_object_base::instance_ne, other);
+        case Py_GT: 
+          return call(obj, &type_object_base::instance_gt, other);
+        case Py_GE: 
+          return call(obj, &type_object_base::instance_ge, other);
+    }
+#endif
+    return 0;
+}
+
 static int do_instance_compare(PyObject* obj, PyObject* other)
 {
     return call(obj, &type_object_base::instance_compare, other);
@@ -406,7 +437,7 @@ namespace
 bool add_capability_general(type_object_base::capability capability, PyTypeObject* dest)
 {
     assert(dest != 0);
-    
+
     switch(capability)
     {
         ENABLE_GENERAL_CAPABILITY(hash);
@@ -435,6 +466,20 @@ void create_method_table_if_null(T*& table)
     }
 }
 
+bool add_capability_richcompare(type_object_base::capability capability, PyTypeObject* dest)
+{
+    assert(dest != 0);
+    if (capability == type_object_base::richcompare) {
+#if PYTHON_API_VERSION >= 1010
+      dest->tp_richcompare = &do_instance_richcompare;
+      dest->tp_flags |= Py_TPFLAGS_HAVE_RICHCOMPARE;
+#endif
+      return true;
+    }
+    
+    return false;
+}
+
 #define ENABLE_MAPPING_CAPABILITY(field) \
     case type_object_base::mapping_##field: \
         create_method_table_if_null(dest); \
@@ -548,6 +593,8 @@ namespace detail  {
   {
     if(add_capability_general(capability, dest_))
         return;
+    if(add_capability_richcompare(capability, dest_))
+        return;
     if(add_capability_mapping(capability, dest_->tp_as_mapping))
         return;
     if(add_capability_sequence(capability, dest_->tp_as_sequence))
@@ -975,6 +1022,36 @@ PyObject* type_object_base::instance_number_hex(PyObject*) const
     return unimplemented("instance_number_hex");
 }
 
+PyObject* type_object_base::instance_lt(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_lt");
+}
+
+PyObject* type_object_base::instance_le(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_le");
+}
+
+PyObject* type_object_base::instance_eq(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_eq");
+}
+
+PyObject* type_object_base::instance_ne(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_ne");
+}
+
+PyObject* type_object_base::instance_gt(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_gt");
+}
+
+PyObject* type_object_base::instance_ge(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_ge");
+}
+
 }} // namespace boost::python
 
 #ifdef TYPE_OBJECT_BASE_STANDALONE_TEST

test/comprehensive.py

@@ -8,14 +8,11 @@ r'''
 //  producing this work.
 
 //  Revision History:
+//  2001 Nov 01 Python 2.2 pickle problems fixed (rwgk)
 //  04 Mar 01 Changed name of extension module so it would work with DebugPython,
 //            fixed exception message checking to work with Python 2.0
 //            (Dave Abrahams)
 
-Load up the extension module
-
-    >>> from boost_python_test import *
-
 Automatic checking of the number and type of arguments. Foo's constructor takes
 a single long parameter. 
 
@@ -274,19 +271,12 @@ Pickle safety measures:
     ... except RuntimeError, err: print err[0]
     ... 
     Incomplete pickle support (__dict_defines_state__ not set)
-    >>> class myrational(Rational):
-    ...   __dict_defines_state__ = 1 # this is a lie but good enough for testing.
-    ...             
     >>> r=myrational(3, 4)
     >>> r
     Rational(3, 4)
     >>> s=pickle.dumps(r)
+    >>> u=pickle.loads(s)
 
-    >>> class myworld(world):
-    ...   def __init__(self):
-    ...     world.__init__(self, 'anywhere')
-    ...     self.x = 1
-    ... 
     >>> w = myworld()
     >>> w.greet()
     'Hello from anywhere!'
@@ -297,9 +287,6 @@ Pickle safety measures:
     ... 
     Incomplete pickle support (__getstate_manages_dict__ not set)
 
-    >>> class myunsafeworld(myworld):
-    ...   __getstate_manages_dict__ = 1 # this is a lie but good enough for testing.
-    ... 
     >>> w = myunsafeworld()
     >>> w.greet()
     'Hello from anywhere!'
@@ -422,7 +409,7 @@ Some simple overloading tests:
     >>> try: r = Range('yikes')
     ... except TypeError, e:
     ...     assert re.match(
-    ... 'No overloaded functions match [(]Range, string[)]\. Candidates are:\n.*\n.*',
+    ... 'No overloaded functions match [(]Range, str[a-z]*[)]\. Candidates are:\n.*\n.*',
     ...  str(e))
     ... else: print 'no exception'
     
@@ -632,7 +619,7 @@ Testing overloaded free functions
     15
     >>> try: overloaded(1, 'foo')
     ... except TypeError, err:
-    ...     assert re.match("No overloaded functions match \(int, string\)\. Candidates are:",
+    ...     assert re.match("No overloaded functions match \(int, str[a-z]*\)\. Candidates are:",
     ...                     str(err))
     ... else:
     ...     print 'no exception'
@@ -662,7 +649,7 @@ Testing overloaded constructors
     5
     >>> try: over = OverloadTest(1, 'foo')
     ... except TypeError, err:
-    ...     assert re.match("No overloaded functions match \(OverloadTest, int, string\)\. Candidates are:",
+    ...     assert re.match("No overloaded functions match \(OverloadTest, int, str[a-z]*\)\. Candidates are:",
     ...                     str(err))
     ... else:
     ...     print 'no exception'
@@ -684,7 +671,7 @@ Testing overloaded methods
     5
     >>> try: over.overloaded(1,'foo')
     ... except TypeError, err:
-    ...     assert re.match("No overloaded functions match \(OverloadTest, int, string\)\. Candidates are:",
+    ...     assert re.match("No overloaded functions match \(OverloadTest, int, str[a-z]*\)\. Candidates are:",
     ...                     str(err))
     ... else:
     ...     print 'no exception'
@@ -1175,10 +1162,39 @@ test methodologies for wrapping functions that return a pointer
     '2.94'
     >>> '%.3g' % (dreal(c))
     '6.35'
+    >>> '%.3g' % (dreal(3))
+    '3'
+    >>> '%.3g' % (dreal(3L))
+    '3'
+    >>> '%.3g' % (dreal(3.))
+    '3'
+    >>> '%.3g' % (freal(3))
+    '3'
+    >>> '%.3g' % (freal(3L))
+    '3'
+    >>> '%.3g' % (freal(3.))
+    '3'
 
 '''
 #'
 
+from boost_python_test import *
+
+# pickle requires these derived classes to be
+# at the global scope of the module
+
+class myrational(Rational):
+  __dict_defines_state__ = 1 # this is a lie but good enough for testing.
+
+class myworld(world):
+  def __init__(self):
+    world.__init__(self, 'anywhere')
+    self.x = 1
+
+class myunsafeworld(myworld):
+  __getstate_manages_dict__ = 1 # this is a lie but good enough for testing.
+
+
 def assert_integer_expected(err):
   """Handle a common error report which appears differently in Python 1.5.x and 2.0"""
   assert isinstance(err, TypeError)