Windows2000 mods.

[SVN r10727]

build/como.mak

@@ -1,10 +1,12 @@
 # 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 \
     extension_class.cpp \
     functions.cpp \
     init_function.cpp \
@@ -34,11 +36,12 @@ endif
             | sed 's/\($*\)\.o[ :]*/\1.o $@ : /g' > $@; \
                 [ -s $@ ] || rm -f $@
 
-example1: example1.o libboost_python.a
-	como-dyn-link -o ../example/hellomodule.$(MODULE_EXTENSION) $(PYTHON_LIB) example1.o -L. -lboost_python
-	python ../example/test_example1.py
+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
 
-example1.o: ../example/example1.cpp
+getting_started1.o: ../example/getting_started1.cpp
 	como --pic $(INC) -o $*.o -c $<
 
 clean:

build/filemgr.py

@@ -0,0 +1,142 @@
+# 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 + "/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_converters.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_converters.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_converters",
+"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

@@ -1,5 +1,7 @@
 #  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)
@@ -8,6 +10,7 @@
 LIBSRC = \
     classes.cpp \
     conversions.cpp \
+    cross_module.cpp \
     extension_class.cpp \
     functions.cpp \
     init_function.cpp \
@@ -18,7 +21,7 @@ LIBSRC = \
 LIBOBJ = $(LIBSRC:.cpp=.o)
 OBJ = $(LIBOBJ)
 
-PYTHON_INC=$(ROOT)/usr/local/include/python2.0
+LIBNAME = libboost_python
 # libpython2.0.dll
 
 ifeq "$(OS)" "Windows_NT"
@@ -26,13 +29,18 @@ 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
-INC = -I$(PYTHON_INC)
+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) -o $*.o -c $<
+	g++ -fPIC -Wall -W $(INC) $(CXXFLAGS) -o $*.o -c $<
 
 %.d: ../src/%.cpp
 	@echo creating $@
@@ -43,7 +51,9 @@ endif
 
 PYTHON = python
 
-test: comprehensive.o libboost_python.a
+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
 
@@ -51,20 +61,24 @@ comprehensive.o: ../test/comprehensive.cpp
 	g++ $(CXXFLAGS) --template-depth-32 -fPIC -Wall -W $(INC) -o $*.o -c $<
 
 
-example1: example1.o libboost_python.a
-	g++ $(CXXFLAGS) -shared -o ../example/hellomodule.$(MODULE_EXTENSION) example1.o -L. -lboost_python  $(PYTHON_LIB)
-	$(PYTHON) ../example/test_example1.py
+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
 
-example1.o: ../example/example1.cpp
+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
 
-libboost_python.a: $(LIBOBJ)
-	rm -f libboost_python.a
-	ar cq libboost_python.a $(LIBOBJ)
+$(LIBNAME).a: $(LIBOBJ)
+	rm -f $@
+	ar cqs $@ $(LIBOBJ)
+
+$(SHARED_LIB): $(LIBOBJ)
+	g++ $(CXXFLAGS) -shared -o $@ -Wl,--soname=$(LIBNAME).$(MODULE_EXTENSION)
 
 DEP = $(OBJ:.o=.d)
 

build/irix_CC.mak

@@ -0,0 +1,177 @@
+# 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=/usr/local/Python-1.5.2/bin/python
+PYINC=-I/usr/local/Python-1.5.2/include/python1.5
+#PYEXE=/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=
+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 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_converters.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_converters.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_converters.so: $(OBJ) do_it_yourself_converters.o
+	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_converters.o -o do_it_yourself_converters.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_converters.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_converters.o do_it_yourself_converters.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

@@ -2,110 +2,66 @@
 #
 #   Create a new empty directory anywhere (preferably not in the boost tree).
 #   Copy this Makefile to that new directory and rename it to "Makefile"
-#   Set the BOOST pathname below.
+#   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
 
-BOOST= /net/cci/rwgk/boost
+ROOT=$(HOME)
+BOOST=$(ROOT)/boost
 
-PYEXE= /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
-#STLPORTINC= -I/usr/local/STLport-4.1b3/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/usr/local/STLport-4.1b4/stlport
-#STLPORTOPTS= -D__NO_USE_STD_IOSTREAM -D__STL_NO_SGI_IOSTREAMS
-#STLPORTINC= -I/net/cci/xp/C++_C_headers
+PYEXE=PYTHONPATH=. /usr/bin/python
+PYINC=-I/usr/include/python1.5
+#PYEXE=/usr/local/Python-1.5.2/bin/python
+#PYINC=-I/usr/local/Python-1.5.2/include/python1.5
+#PYEXE=/usr/local/Python-2.1/bin/python
+#PYINC=-I/usr/local/Python-2.1/include/python2.1
 
-STDOPTS= -ftemplate-depth-21
+STDOPTS=-fPIC -ftemplate-depth-21
 WARNOPTS=
-# use -msg_display_number to obtain integer tags for -msg_disable
+OPTOPTS=-g
 
-CPP= g++
-CPPOPTS= $(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
-         $(STDOPTS) $(WARNOPTS) -g
-MAKEDEP= -M
+CPP=g++
+CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
+        $(STDOPTS) $(WARNOPTS) $(OPTOPTS)
+MAKEDEP=-M
 
-LD= g++
-LDOPTS= -shared
+LD=$(CPP)
+LDOPTS=-shared
 
-#HIDDEN= -hidden
-
-BPL_SRC = $(BOOST)/libs/python/src
-BPL_TST = $(BOOST)/libs/python/test
-BPL_EXA = $(BOOST)/libs/python/example
-SOFTLINKS = \
-$(BPL_SRC)/classes.cpp \
-$(BPL_SRC)/conversions.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_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)/getting_started3.cpp \
-$(BPL_EXA)/getting_started4.cpp \
-$(BPL_EXA)/getting_started5.cpp \
-$(BPL_EXA)/test_abstract.py \
-$(BPL_EXA)/test_getting_started1.py \
-$(BPL_EXA)/test_getting_started2.py \
-$(BPL_EXA)/test_getting_started3.py \
-$(BPL_EXA)/test_getting_started4.py \
-$(BPL_EXA)/test_getting_started5.py
-
-OBJ = classes.o conversions.o extension_class.o functions.o \
-      init_function.o module_builder.o \
-      objects.o types.o
-DEPOBJ= $(OBJ) comprehensive.o abstract.o \
-        getting_started1.o getting_started2.o getting_started3.o \
-        getting_started4.o getting_started5.o
+OBJ=classes.o conversions.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_converters.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 getting_started3.so \
-     getting_started4.so getting_started5.so
-
-softlinks:
-	@ for pn in $(SOFTLINKS); \
-	  do \
-            bn=`basename "$$pn"`; \
-	    if [ ! -e "$$bn" ]; then \
-              echo "ln -s $$pn ."; \
-	      ln -s "$$pn" .; \
-            else \
-              echo "info: no softlink created (file exists): $$bn"; \
-	    fi; \
-	  done
-
-unlink:
-	@ for pn in $(SOFTLINKS); \
-	  do \
-            bn=`basename "$$pn"`; \
-	    if [ -L "$$bn" ]; then \
-              echo "rm $$bn"; \
-              rm "$$bn"; \
-            elif [ -e "$$bn" ]; then \
-              echo "info: not a softlink: $$bn"; \
-	    fi; \
-	  done
+all: libboost_python.a \
+     boost_python_test.so \
+     abstract.so \
+     getting_started1.so getting_started2.so \
+     simple_vector.so \
+     do_it_yourself_converters.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
@@ -123,14 +79,43 @@ getting_started1.so: $(OBJ) getting_started1.o
 getting_started2.so: $(OBJ) getting_started2.o
 	$(LD) $(LDOPTS) $(OBJ) getting_started2.o -o getting_started2.so
 
-getting_started3.so: $(OBJ) getting_started3.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started3.o -o getting_started3.so
+simple_vector.so: $(OBJ) simple_vector.o
+	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
 
-getting_started4.so: $(OBJ) getting_started4.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started4.o -o getting_started4.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
 
-getting_started5.so: $(OBJ) getting_started5.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started5.o -o getting_started5.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
@@ -140,9 +125,15 @@ test:
 	$(PYEXE) test_abstract.py
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
-	$(PYEXE) test_getting_started3.py
-	$(PYEXE) test_getting_started4.py
-	$(PYEXE) test_getting_started5.py
+	$(PYEXE) test_simple_vector.py
+	$(PYEXE) test_do_it_yourself_converters.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
@@ -150,11 +141,31 @@ clean:
 	rm -f abstract.o abstract.so
 	rm -f getting_started1.o getting_started1.so
 	rm -f getting_started2.o getting_started2.so
-	rm -f getting_started3.o getting_started3.so
-	rm -f getting_started4.o getting_started4.so
-	rm -f getting_started5.o getting_started5.so
+	rm -f simple_vector.o simple_vector.so
+	rm -f do_it_yourself_converters.o do_it_yourself_converters.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; \

build/mingw32.mak

@@ -1,18 +1,14 @@
 # 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"
-#   Set the BOOST_* 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
 #
-#   The idea is that the build directory is on a Unix filesystem that
-#   is mounted on a PC using SAMBA. Use this makefile under both Unix
-#   and Windows:
-#
-#   Unix: make softlinks     Create softlinks to source code and tests
-#   Win:  make               Compile all sources
-#   Win:  make test          Run doctest tests
-#   Unix: make clean         Remove all object files
-#   Unix: 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
 
 # To install mingw32, follow instructions at:
 #   http://starship.python.net/crew/kernr/mingw32/Notes.html
@@ -31,117 +27,50 @@
 # 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.
+# -fvtable-thunks eliminates the compiler warning, but
+#                 "import boost_python_test" still causes a crash.
 
-BOOST_UNIX= /net/cci/rwgk/boost
-BOOST_WIN= "L:\boost"
+ROOT=L:
+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:\Program files\Python\python.exe"
+PYINC=-I"C:\usr\include\python1.5"
+PYLIB="C:\usr\lib\libpython15.a"
 
-STDOPTS= -ftemplate-depth-21
+STDOPTS=-ftemplate-depth-21
 WARNOPTS=
+OPTOPTS=-g
 
-CPP= g++
-CPPOPTS= $(STLPORTINC) $(STLPORTOPTS) -I$(BOOST_WIN) $(PYINC) \
-         $(STDOPTS) $(WARNOPTS) -g
+CPP=g++
+CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) -I$(BOOST_WIN) $(PYINC) \
+        $(STDOPTS) $(WARNOPTS) $(OPTOPTS)
 
-LD= g++
-LDOPTS= -shared
+LD=g++
+LDOPTS=-shared
 
-BPL_SRC = $(BOOST_UNIX)/libs/python/src
-BPL_TST = $(BOOST_UNIX)/libs/python/test
-BPL_EXA = $(BOOST_UNIX)/libs/python/example
-SOFTLINKS = \
-$(BPL_SRC)/classes.cpp \
-$(BPL_SRC)/conversions.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_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)/getting_started3.cpp \
-$(BPL_EXA)/getting_started4.cpp \
-$(BPL_EXA)/getting_started5.cpp \
-$(BPL_EXA)/passing_char.cpp \
-$(BPL_EXA)/test_abstract.py \
-$(BPL_EXA)/test_getting_started1.py \
-$(BPL_EXA)/test_getting_started2.py \
-$(BPL_EXA)/test_getting_started3.py \
-$(BPL_EXA)/test_getting_started4.py \
-$(BPL_EXA)/test_getting_started5.py
-
-DEFS= \
-boost_python_test \
-abstract \
-getting_started1 \
-getting_started2 \
-getting_started3 \
-getting_started4 \
-getting_started5
-
-OBJ = classes.o conversions.o extension_class.o functions.o \
-      init_function.o module_builder.o \
-      objects.o types.o
+OBJ=classes.o conversions.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 boost_python_test.pyd abstract.pyd \
-     getting_started1.pyd getting_started2.pyd getting_started3.pyd \
-     getting_started4.pyd getting_started5.pyd
-
-softlinks: defs
-	@ for pn in $(SOFTLINKS); \
-	  do \
-            bn=`basename "$$pn"`; \
-	    if [ ! -e "$$bn" ]; then \
-              echo "ln -s $$pn ."; \
-	      ln -s "$$pn" .; \
-            else \
-              echo "info: no softlink created (file exists): $$bn"; \
-	    fi; \
-	  done
-
-unlink: rmdefs
-	@ for pn in $(SOFTLINKS); \
-	  do \
-            bn=`basename "$$pn"`; \
-	    if [ -L "$$bn" ]; then \
-              echo "rm $$bn"; \
-              rm "$$bn"; \
-            elif [ -e "$$bn" ]; then \
-              echo "info: not a softlink: $$bn"; \
-	    fi; \
-	  done
-
-defs:
-	@ for def in $(DEFS); \
-	  do \
-            echo "EXPORTS\n\tinit$$def" > $$def.def; \
-	  done
-
-rmdefs:
-	@ for def in $(DEFS); \
-	  do \
-            rm $$def.def; \
-	  done
+all: libboost_python.a \
+     abstract.pyd \
+     getting_started1.pyd getting_started2.pyd \
+     simple_vector.pyd \
+     do_it_yourself_converters.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
+	-del libboost_python.a
 	ar r libboost_python.a $(OBJ)
 
-DLLWRAPOPTS= -s --driver-name g++ -s
-             --entry _DllMainCRTStartup@12 --target=i386-mingw32
+DLLWRAPOPTS=-s --driver-name g++ -s \
+            --entry _DllMainCRTStartup@12 --target=i386-mingw32
 
 boost_python_test.pyd: $(OBJ) comprehensive.o
 	dllwrap $(DLLWRAPOPTS) \
@@ -167,44 +96,116 @@ getting_started2.pyd: $(OBJ) getting_started2.o
           --def getting_started2.def \
           $(OBJ) getting_started2.o $(PYLIB)
 
-getting_started3.pyd: $(OBJ) getting_started3.o
+simple_vector.pyd: $(OBJ) simple_vector.o
 	dllwrap $(DLLWRAPOPTS) \
-          --dllname getting_started3.pyd \
-          --def getting_started3.def \
-          $(OBJ) getting_started3.o $(PYLIB)
+          --dllname simple_vector.pyd \
+          --def simple_vector.def \
+          $(OBJ) simple_vector.o $(PYLIB)
 
-getting_started4.pyd: $(OBJ) getting_started4.o
+do_it_yourself_converters.pyd: $(OBJ) do_it_yourself_converters.o
 	dllwrap $(DLLWRAPOPTS) \
-          --dllname getting_started4.pyd \
-          --def getting_started4.def \
-          $(OBJ) getting_started4.o $(PYLIB)
+          --dllname do_it_yourself_converters.pyd \
+          --def do_it_yourself_converters.def \
+          $(OBJ) do_it_yourself_converters.o $(PYLIB)
 
-getting_started5.pyd: $(OBJ) getting_started5.o
+pickle1.pyd: $(OBJ) pickle1.o
 	dllwrap $(DLLWRAPOPTS) \
-          --dllname getting_started5.pyd \
-          --def getting_started5.def \
-          $(OBJ) getting_started5.o $(PYLIB)
+          --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) comprehensive.py
 	$(PYEXE) test_abstract.py
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
-	$(PYEXE) test_getting_started3.py
-	$(PYEXE) test_getting_started4.py
-	$(PYEXE) test_getting_started5.py
+	$(PYEXE) test_simple_vector.py
+	$(PYEXE) test_do_it_yourself_converters.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.pyd
-	rm -f abstract.o abstract.pyd
-	rm -f getting_started1.o getting_started1.pyd
-	rm -f getting_started2.o getting_started2.pyd
-	rm -f getting_started3.o getting_started3.pyd
-	rm -f getting_started4.o getting_started4.pyd
-	rm -f getting_started5.o getting_started5.pyd
-	rm -f so_locations *.pyc
-	rm -rf cxx_repository
+	-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

@@ -2,110 +2,76 @@
 #
 #   Create a new empty directory anywhere (preferably not in the boost tree).
 #   Copy this Makefile to that new directory and rename it to "Makefile"
-#   Set the BOOST pathname below.
+#   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
 
-BOOST= /net/cci/rwgk/boost
+ROOT=$(HOME)
+BOOST=$(ROOT)/boost
 
-PYEXE= /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
-#STLPORTINC= -I/usr/local/STLport-4.1b3/stlport
+PYEXE=/usr/local/Python-1.5.2/bin/python
+PYINC=-I/usr/local/Python-1.5.2/include/python1.5
+#PYEXE=/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= \
 # -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/usr/local/STLport-4.1b4/stlport
-#STLPORTOPTS= -D__NO_USE_STD_IOSTREAM -D__STL_NO_SGI_IOSTREAMS
-STLPORTINC= -I/net/cci/xp/C++_C_headers
+STLPORTINC=-I$(BOOST)/boost/compatibility/cpp_c_headers
 
-STDOPTS= -std strict_ansi
-WARNOPTS= -msg_disable 186,450,1115
+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) -g
-MAKEDEP= -Em
+CPP=cxx
+CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
+        $(STDOPTS) $(WARNOPTS) $(OPTOPTS)
+MAKEDEP=-Em
 
-LD= cxx
-LDOPTS= -shared -expect_unresolved 'Py*' -expect_unresolved '_Py*'
+LD=cxx
+LDOPTS=-shared -expect_unresolved 'Py*' -expect_unresolved '_Py*'
 
-#HIDDEN= -hidden
+#HIDDEN=-hidden
 
-BPL_SRC = $(BOOST)/libs/python/src
-BPL_TST = $(BOOST)/libs/python/test
-BPL_EXA = $(BOOST)/libs/python/example
-SOFTLINKS = \
-$(BPL_SRC)/classes.cpp \
-$(BPL_SRC)/conversions.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_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)/getting_started3.cpp \
-$(BPL_EXA)/getting_started4.cpp \
-$(BPL_EXA)/getting_started5.cpp \
-$(BPL_EXA)/test_abstract.py \
-$(BPL_EXA)/test_getting_started1.py \
-$(BPL_EXA)/test_getting_started2.py \
-$(BPL_EXA)/test_getting_started3.py \
-$(BPL_EXA)/test_getting_started4.py \
-$(BPL_EXA)/test_getting_started5.py
-
-OBJ = classes.o conversions.o extension_class.o functions.o \
-      init_function.o module_builder.o \
-      objects.o types.o
-DEPOBJ= $(OBJ) comprehensive.o abstract.o \
-        getting_started1.o getting_started2.o getting_started3.o \
-        getting_started4.o getting_started5.o
+OBJ=classes.o conversions.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_converters.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 getting_started3.so \
-     getting_started4.so getting_started5.so
-
-softlinks:
-	@ for pn in $(SOFTLINKS); \
-	  do \
-            bn=`basename "$$pn"`; \
-	    if [ ! -e "$$bn" ]; then \
-              echo "ln -s $$pn ."; \
-	      ln -s "$$pn" .; \
-            else \
-              echo "info: no softlink created (file exists): $$bn"; \
-	    fi; \
-	  done
-
-unlink:
-	@ for pn in $(SOFTLINKS); \
-	  do \
-            bn=`basename "$$pn"`; \
-	    if [ -L "$$bn" ]; then \
-              echo "rm $$bn"; \
-              rm "$$bn"; \
-            elif [ -e "$$bn" ]; then \
-              echo "info: not a softlink: $$bn"; \
-	    fi; \
-	  done
+all: libboost_python.a \
+     boost_python_test.so \
+     abstract.so \
+     getting_started1.so getting_started2.so \
+     simple_vector.so \
+     do_it_yourself_converters.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
@@ -127,14 +93,43 @@ getting_started1.so: $(OBJ) getting_started1.o
 getting_started2.so: $(OBJ) getting_started2.o
 	$(LD) $(LDOPTS) $(OBJ) getting_started2.o -o getting_started2.so
 
-getting_started3.so: $(OBJ) getting_started3.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started3.o -o getting_started3.so
+simple_vector.so: $(OBJ) simple_vector.o
+	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
 
-getting_started4.so: $(OBJ) getting_started4.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started4.o -o getting_started4.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
 
-getting_started5.so: $(OBJ) getting_started5.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started5.o -o getting_started5.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
@@ -144,9 +139,15 @@ test:
 	$(PYEXE) test_abstract.py
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
-	$(PYEXE) test_getting_started3.py
-	$(PYEXE) test_getting_started4.py
-	$(PYEXE) test_getting_started5.py
+	$(PYEXE) test_simple_vector.py
+	$(PYEXE) test_do_it_yourself_converters.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
@@ -154,12 +155,33 @@ clean:
 	rm -f abstract.o abstract.so
 	rm -f getting_started1.o getting_started1.so
 	rm -f getting_started2.o getting_started2.so
-	rm -f getting_started3.o getting_started3.so
-	rm -f getting_started4.o getting_started4.so
-	rm -f getting_started5.o getting_started5.so
+	rm -f simple_vector.o simple_vector.so
+	rm -f do_it_yourself_converters.o do_it_yourself_converters.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); \

build/vc60.mak

@@ -0,0 +1,145 @@
+# 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
+
+ROOT=L:
+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=
+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 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_converters.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_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"
+
+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_converters.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

doc/building.html

@@ -5,153 +5,176 @@
     <title>Building an Extension Module</title>
 
     <div>
-      <h1><img width="277" height="86" id="_x0000_i1025" align="center" src=
+      <h1><img width="277" height="86" align="center" src=
       "../../../c++boost.gif" alt="c++boost.gif (8819 bytes)">Building an
       Extension Module</h1>
 
       <p>The build process for Boost is currently undergoing some evolution,
       and, it is to be hoped, improvement. The following facts may help:
 
+      <hr>
+      Makefiles for various platforms and a Visual Studio project
+      reside in the Boost subdirectory <tt>libs/python/build</tt>.
+      Build targets include:
+
       <ul>
-        <li>
-          Makefiles for various platforms reside in the Boost subdirectory
-          <tt>libs/python/build</tt>: 
+        <li>The <tt>boost_python</tt> library for static linking with your
+        extension module. On the various Unices, this library will be
+        called <tt>libboost_python.a</tt>. When using Visual C++, the
+        library will be called <tt>boost_python.lib</tt>.
 
-          <ul>
-            <li><a href="../build/como.mak">como.mak</a> (Comeau C++ on Linux)
+        <p>
+        <li>A comprehensive test of Boost.Python features. This test builds
+        a Boost.Python extension module, then runs Python to import the
+        module, and runs a series of tests on it using <tt><a href=
+        "../test/doctest.py">doctest</a></tt>. Source code for the module
+        and tests is available in the Boost subdirectory
+        <tt>libs/python/test</tt>.
 
-            <li><a href="../build/linux_gcc.mak">linux_gcc.mak</a> (GCC on
-            Linux/Unix)
+        <p>
+        <li>Various examples from the Boost subdirectory
+        <tt>libs/python/example</tt>.
+        All these examples include a doctest modeled
+        on the comprehensive test above.
 
-            <li><a href="../build/gcc.mak">gcc.mak</a> (older makefile for GCC
-            on Linux/Unix. Deprecated.)
-
-            <li><a href="../build/mingw32.mak">mingw32.mak</a>
-            (highly-specialized makefile for mingw32 (Win32-targeted) GCC. Read
-            the header comment).
-
-            <li><a href="../build/tru64_cxx.mak">tru64_cxx.mak</a> (Compaq
-            Alpha).
-          </ul>
-          <br>
-
-        <li>
-          A project workspace for Microsoft Visual Studio is provided at <tt><a
-          href="../build/build.dsw">libs/python/build/build.dsw</a></tt>. The
-          include paths for this project may need to be changed for your
-          installation. They currently assume that python has been installed at
-          <tt>c:\tools\python</tt>. Three configurations of all targets are
-          supported: 
-
-          <ul>
-            <li>Release (optimization, <tt>-DNDEBUG</tt>)
-
-            <li>Debug (no optimization <tt>-D_DEBUG</tt>)
-
-            <li>DebugPython (no optimization, <tt>-D_DEBUG
-            -DBOOST_DEBUG_PYTHON</tt>)
-          </ul>
-
-          <p>When extension modules are built with Visual C++ using
-          <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.
-
-          <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 library forcing, and link with the DebugPython version of
-          <tt>boost_python.lib</tt>. You'll need to get the debugging version
-          of the Python executable (<tt>python_d.exe</tt>) and DLL
-          (<tt>python20_d.dll</tt> or <tt>python15_d.dll</tt>). The Python
-          sources include project files for building these. If you <a href=
-          "http://www.python.org">download</a> them, change the name of the
-          top-level directory to <tt>src</tt>, and install it under
-          <tt>c:\tools\python</tt>, the workspace supplied by Boost.Python will
-          be able to use it without modification. Just open
-          <tt>c:\tools\python\src\pcbuild\pcbuild.dsw</tt> and invoke "build
-          all" to generate all the debugging targets.
-
-          <p>If you do not <tt>#define BOOST_DEBUG_PYTHON</tt>, be sure that
-          any source files <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>
-          <br>
-
-
-        <li>
-          The makefiles and Visual Studio project can all build at least the
-          following: 
-
-          <ul>
-            <li>The <tt>boost_python</tt> library for static linking with your
-            extension module. On the various Unices, this library will be
-            called <tt>libboost_python.a</tt>. On Win32 platforms, the library
-            will be called <tt>boost_python.lib</tt>.
-
-            <li>A comprehensive test of Boost.Python features. This test builds
-            a Boost.Python extension module, then runs Python to import the
-            module, and runs a series of tests on it using <tt><a href=
-            "../test/doctest.py">doctest</a></tt>. Source code for the module
-            and tests is available in the Boost subdirectory
-            <tt>libs/python/test</tt>.<br>
-
-
-            <li>Various examples from the Boost subdirectory
-            <tt>libs/python/example</tt>. Which examples are built currently
-            depends on the platform. The most up-to-date examples are
-            <tt>getting_started</tt><i>n</i><tt>.cpp</tt> from <a href=
-            "http://cci.lbl.gov/staff/ralf_grosse-kunstleve.html">Ralf W.
-            Grosse-Kunstleve</a>. All these examples include a doctest modeled
-            on the comprehensive test above.<br>
-            <br>
-
-          </ul>
-
-        <li>
-          If your platform isn't directly supported, you can build a static
-          library from the following source files (in the Boost subdirectory
-          <tt>libs/python/src</tt>), or compile them directly and link the
-          resulting objects into your extension module: 
-
-          <ul>
-            <li><a href=
-            "../../../libs/python/src/extension_class.cpp">extension_class.cpp</a>
-
-            <li><a href=
-            "../../../libs/python/src/functions.cpp">functions.cpp</a>
-
-            <li><a href=
-            "../../../libs/python/src/init_function.cpp">init_function.cpp</a>
-
-            <li><a href=
-            "../../../libs/python/src/module_builder.cpp">module_builder.cpp</a>
-
-            <li><a href="../../../libs/python/src/types.cpp">types.cpp</a>
-
-            <li><a href="../../../libs/python/src/objects.cpp">objects.cpp</a>
-
-            <li><a href=
-            "../../../libs/python/src/conversions.cpp">conversions.cpp</a>
-
-            <li><a href="../../../libs/python/src/classes.cpp">classes.cpp</a>
-          </ul>
       </ul>
 
-      <p>Next: <a href="enums.html">Wrapping Enums</a> Previous: <a href=
+      <hr>
+      There is a group of makefiles with support for simultaneous
+      compilation on multiple platforms and a consistent set of
+      features that build the <tt>boost_python</tt> library for static
+      linking, the comprehensive test, and all examples in
+      <tt>libs/python/example</tt>:
+
+      <ul>
+        <li><a href="../build/vc60.mak">vc60.mak</a>:
+        Visual C++ 6.0 Service Pack 4
+
+        <li><a href="../build/mingw32.mak">mingw32.mak</a>:
+        mingw32 (Win32-targeted) gcc 2.95.2
+
+        <li><a href="../build/linux_gcc.mak">linux_gcc.mak</a>:
+        gcc 2.95.2 on Linux/Unix
+
+        <li><a href="../build/tru64_cxx.mak">tru64_cxx.mak</a>:
+        Compaq Alpha using the Compaq cxx compiler
+
+        <li><a href="../build/irix_CC.mak">irix_CC.mak</a>:
+        Silicon Graphics IRIX 6.5 CC compiler
+
+      </ul>
+      <a href="http://cctbx.sourceforge.net/page_installation_adv.html#installation_boost_python"
+      >Usage of these makefiles is described here.</a>
+
+      <hr>
+      There is another group of makefiles for GNU make.
+      These makefiles are less redundant than the makefiles
+      in the group above,
+      but the list of compilation targets is not as complete
+      and there is no support for simultaneous compilation
+      on multiple platforms.
+
+      <ul>
+        <li><a href="../build/como.mak">como.mak</a>:
+        Comeau C++ on Linux
+
+        <li><a href="../build/gcc.mak">gcc.mak</a>:
+        GCC on Linux/Unix.
+
+      </ul>
+
+      <hr>
+      A project workspace for Microsoft Visual Studio is provided at <tt><a
+      href="../build/build.dsw">libs/python/build/build.dsw</a></tt>. The
+      include paths for this project may need to be changed for your
+      installation. They currently assume that python has been installed at
+      <tt>c:\tools\python</tt>. Three configurations of all targets are
+      supported:
+
+      <ul>
+        <li>Release (optimization, <tt>-DNDEBUG</tt>)
+
+        <li>Debug (no optimization <tt>-D_DEBUG</tt>)
+
+        <li>DebugPython (no optimization, <tt>-D_DEBUG
+        -DBOOST_DEBUG_PYTHON</tt>)
+      </ul>
+
+      <p>When extension modules are built with Visual C++ using
+      <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.
+
+      <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 library forcing, and link with the DebugPython version of
+      <tt>boost_python.lib</tt>. You'll need to get the debugging version
+      of the Python executable (<tt>python_d.exe</tt>) and DLL
+      (<tt>python20_d.dll</tt> or <tt>python15_d.dll</tt>). The Python
+      sources include project files for building these. If you <a href=
+      "http://www.python.org">download</a> them, change the name of the
+      top-level directory to <tt>src</tt>, and install it under
+      <tt>c:\tools\python</tt>, the workspace supplied by Boost.Python will
+      be able to use it without modification. Just open
+      <tt>c:\tools\python\src\pcbuild\pcbuild.dsw</tt> and invoke "build
+      all" to generate all the debugging targets.
+
+      <p>If you do not <tt>#define BOOST_DEBUG_PYTHON</tt>, be sure that
+      any source files <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>
+      If your platform isn't directly supported, you can build a static
+      library from the following source files (in the Boost subdirectory
+      <tt>libs/python/src</tt>), or compile them directly and link the
+      resulting objects into your extension module:
+
+      <ul>
+        <li><a href=
+        "../../../libs/python/src/classes.cpp">classes.cpp</a>
+
+        <li><a href=
+        "../../../libs/python/src/conversions.cpp">conversions.cpp</a>
+
+        <li><a href=
+        "../../../libs/python/src/cross_module.cpp">cross_module.cpp</a>
+
+        <li><a href=
+        "../../../libs/python/src/extension_class.cpp">extension_class.cpp</a>
+
+        <li><a href=
+        "../../../libs/python/src/functions.cpp">functions.cpp</a>
+
+        <li><a href=
+        "../../../libs/python/src/init_function.cpp">init_function.cpp</a>
+
+        <li><a href=
+        "../../../libs/python/src/module_builder.cpp">module_builder.cpp</a>
+
+        <li><a href=
+        "../../../libs/python/src/objects.cpp">objects.cpp</a>
+
+        <li><a href=
+        "../../../libs/python/src/types.cpp">types.cpp</a>
+      </ul>
+
+      <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 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
+      <p>Updated: Apr 17, 2001 (R.W. Grosse-Kunstleve)
     </div>
-

doc/comparisons.html

@@ -112,10 +112,10 @@ that.''<br><i>-<a href="mailto:dubois1@llnl.gov">Paul Dubois</a></i>
       <h2>ILU</h2>
       <p>
         <a
-        href="http://www.cl.cam.ac.uk/Research/Rainbow/projects/origami/ilu-1.8-manual">ILU</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="http://www.cl.cam.ac.uk/Research/Rainbow/projects/origami/ilu-1.8-manual/manual_2.html">Interface
+        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

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/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/index.html

@@ -1,6 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
 "http://www.w3.org/TR/REC-html40/strict.dtd">
-    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
     <title>
       The Boost Python Library (Boost.Python)
     </title>
@@ -134,6 +133,8 @@ among others.
 
       <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>
@@ -152,7 +153,7 @@ among others.
 
     <p>
        Questions should be directed to <a href= 
-      "http://www.egroups.com/list/boost">the boost mailing list</a>.
+      "http://www.yahoogroups.com/list/boost">the boost mailing list</a>.
 
     <p>
        &copy; Copyright David Abrahams 2001. Permission to copy, use, modify,

doc/overriding.html

@@ -47,17 +47,17 @@ class hello
   <code>PyObject*</code> argument. The initial argument should be stored in the <tt>self</tt> data
   member described above. 
 
-  <li>If the class being wrapped is ever returned <i>by
+  <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_3">An</a> implementation of each virtual function you may
+  <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_4">For</a> each non-pure virtual function meant to be
+  <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>
@@ -211,5 +211,5 @@ href="http://cs.calvin.edu/c++/C++Standard-Nov97/basic.html#basic.def.odr">ODR</
       express or implied warranty, and with no claim as to its suitability for
       any purpose.
     <p>
-      Updated: Mar 6, 2001
+      Updated: Mar 21, 2001
 

doc/pickle.html

@@ -227,11 +227,38 @@ Both <tt>__getinitargs__</tt> and <tt>__getstate__</tt> are not defined.
 </ul>
 
 <hr>
-<h2>Example</h2>
+<h2>Examples</h2>
 
-An example that shows how to configure pickle support is available in the
-<tt>boost/lib/python/example</tt> directory
-(<tt>getting_started3.cpp</tt>).
+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,
@@ -241,5 +268,5 @@ is" without express or implied warranty, and with no claim as to its
 suitability for any purpose.
 
 <p>
-Updated: March 10, 2001
+Updated: March 21, 2001
 </div>

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&ltFoo&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

@@ -36,7 +36,7 @@
       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
+      "file:///c:/boost/site/libs/utility/operators.htm">the boost operators
       library</a>.
     <p>
       Because the <code>to_python</code> and <code>from_python</code> functions

example/README

@@ -1,6 +1,24 @@
 To get started with the Boost Python Library, use the examples
-getting_started?.cpp and abstract.cpp.
+getting_started1.cpp and getting_started2.cpp.
+
+Examples for providing pickle support can be found in:
+  pickle1.cpp
+  pickle2.cpp
+  pickle3.cpp
+See also: libs/python/doc/pickle.html
+
+Other advanced concepts are introduced by:
+  abstract.cpp
+  simple_vector.cpp
+  do_it_yourself_converters.cpp
+
+Examples for the cross-module support are provided by:
+  noncopyable_export.cpp
+  noncopyable_import.cpp
+  dvect.cpp
+  ivect.cpp
+See also: libs/python/doc/cross_module.html
 
 The files example1.cpp and rwgk1.cpp are obsolete. They are only
-included because the makefiles in the build directory still refer to
-them. This will be fixed later.
+included because the Visual Studio project in the build directory still
+refers to them.

example/abstract.cpp

@@ -21,9 +21,7 @@ struct Abstract_callback: Abstract
     PyObject * m_self;
 };
 
-extern "C"
-DL_EXPORT(void)
-initabstract()
+BOOST_PYTHON_MODULE_INIT(abstract)
 {
     boost::python::module_builder a("abstract");
 

example/do_it_yourself_converters.cpp

@@ -1,4 +1,6 @@
+// Example by Ralf W. Grosse-Kunstleve
 /*
+
    This example shows how to convert a class from and to native
    Python objects, such as tuples.
 
@@ -60,7 +62,7 @@ namespace { // Avoid cluttering the global namespace.
       std::vector<MillerIndex> VMIx;
     public:
       void add(const MillerIndex& MIx) { VMIx.push_back(MIx); }
-      MillerIndex get(const std::size_t i) const { return VMIx[i]; }
+      MillerIndex get(std::size_t i) const { return VMIx[i]; }
   };
 }
 
@@ -103,12 +105,12 @@ BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
 BOOST_PYTHON_END_CONVERSION_NAMESPACE
 
-BOOST_PYTHON_MODULE_INIT(getting_started5)
+BOOST_PYTHON_MODULE_INIT(do_it_yourself_converters)
 {
   try
   {
     // Create an object representing this extension module.
-    python::module_builder this_module("getting_started5");
+    python::module_builder this_module("do_it_yourself_converters");
 
     // Create the Python type object for our extension class.
     python::class_builder<IndexingSet> ixset_class(this_module, "IndexingSet");

example/dvect.cpp

@@ -0,0 +1,56 @@
+// Example by Ralf W. Grosse-Kunstleve
+// See root/libs/python/doc/cross_module.html for an introduction.
+
+#include "dvect.h"
+#include "ivect.h"
+#include <boost/python/cross_module.hpp>
+namespace python = boost::python;
+
+namespace {
+
+# include "dvect_conversions.cpp"
+# include "ivect_conversions.cpp"
+
+  vects::ivect dvect_as_ivect(const vects::dvect& dv)
+  {
+    vects::ivect iv(dv.size());
+    vects::ivect::iterator iviter = iv.begin();
+    for (int i = 0; i < dv.size(); i++) iviter[i] = static_cast<int>(dv[i]);
+    return iv;
+  }
+}
+
+# ifdef BOOST_MSVC // fixes for JIT debugging
+#  include <windows.h>
+extern "C" void structured_exception_translator(unsigned int, EXCEPTION_POINTERS*)
+{
+    throw;
+}
+extern "C" void (*old_translator)(unsigned int, EXCEPTION_POINTERS*)
+    = _set_se_translator(structured_exception_translator);
+# endif
+
+BOOST_PYTHON_MODULE_INIT(dvect)
+{
+  try
+  {
+    python::module_builder this_module("dvect");
+
+    python::class_builder<vects::dvect> dvect_class(this_module, "dvect");
+    python::export_converters(dvect_class);
+
+    python::import_converters<vects::ivect> ivect_converters("ivect", "ivect");
+
+    dvect_class.def(python::constructor<python::tuple>());
+    dvect_class.def(&vects::dvect::as_tuple, "as_tuple");
+    dvect_class.def(dvect_as_ivect, "as_ivect");
+
+# include "dvect_defs.cpp"
+# include "ivect_defs.cpp"
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
+

example/dvect.h

@@ -0,0 +1,32 @@
+#ifndef DVECT_H
+#define DVECT_H
+
+#include <vector>
+#include <boost/python/class_builder.hpp>
+
+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 (int 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 (int i = 0; i < size(); i++)
+        t.set_item(i,
+          boost::python::ref(BOOST_PYTHON_CONVERSION::to_python((*this)[i])));
+      return t;
+    }
+  };
+}
+
+#endif // DVECT_H

example/dvect_conversions.cpp

@@ -0,0 +1,51 @@
+  // basics first: const reference converters
+  boost::python::tuple const_dvect_reference_as_tuple(const vects::dvect& dv)
+  {
+    return dv.as_tuple();
+  }
+
+  // to_python smart pointer conversions
+  std::auto_ptr<vects::dvect> dvect_as_auto_ptr(const vects::dvect& dv)
+  {
+    return std::auto_ptr<vects::dvect>(new vects::dvect(dv));
+  }
+  boost::shared_ptr<vects::dvect> dvect_as_shared_ptr(const vects::dvect& dv)
+  {
+    return boost::shared_ptr<vects::dvect>(new vects::dvect(dv));
+  }
+
+  // smart pointers passed by value
+  boost::python::ref auto_ptr_value_dvect_as_tuple(std::auto_ptr<vects::dvect> dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_value_dvect_as_tuple(boost::shared_ptr<vects::dvect> dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }
+
+  // smart pointers passed by reference
+  boost::python::ref auto_ptr_reference_dvect_as_tuple(std::auto_ptr<vects::dvect>& dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_reference_dvect_as_tuple(boost::shared_ptr<vects::dvect>& dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }
+
+  // smart pointers passed by const reference
+  boost::python::ref auto_ptr_const_reference_dvect_as_tuple(const std::auto_ptr<vects::dvect>& dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_const_reference_dvect_as_tuple(const boost::shared_ptr<vects::dvect>& dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }

example/dvect_defs.cpp

@@ -0,0 +1,13 @@
+    this_module.def(dvect_as_auto_ptr, "dvect_as_auto_ptr");
+    this_module.def(dvect_as_shared_ptr, "dvect_as_shared_ptr");
+
+    this_module.def(const_dvect_reference_as_tuple, "const_dvect_reference_as_tuple");
+
+    this_module.def(auto_ptr_value_dvect_as_tuple, "auto_ptr_value_dvect_as_tuple");
+    this_module.def(shared_ptr_value_dvect_as_tuple, "shared_ptr_value_dvect_as_tuple");
+
+    this_module.def(auto_ptr_reference_dvect_as_tuple, "auto_ptr_reference_dvect_as_tuple");
+    this_module.def(shared_ptr_reference_dvect_as_tuple, "shared_ptr_reference_dvect_as_tuple");
+
+    this_module.def(auto_ptr_const_reference_dvect_as_tuple, "auto_ptr_const_reference_dvect_as_tuple");
+    this_module.def(shared_ptr_const_reference_dvect_as_tuple, "shared_ptr_const_reference_dvect_as_tuple");

example/getting_started1.cpp

@@ -1,3 +1,5 @@
+// Example by Ralf W. Grosse-Kunstleve
+
 #include <string>
 
 namespace { // Avoid cluttering the global namespace.

example/getting_started2.cpp

@@ -1,3 +1,5 @@
+// Example by Ralf W. Grosse-Kunstleve
+
 #include <iostream>
 #include <string>
 

example/getting_started3.cpp

@@ -1,120 +0,0 @@
-/*
-    This example shows how to make an Extension Class "pickleable".
-
-    Python's pickle module implements a basic but powerful algorithm
-    for "pickling" (a.k.a. serializing, marshalling or flattening)
-    nearly arbitrary Python objects.
-
-    The user can influence how an Extension Class instance is pickled
-    by defining three special methods: __getinitargs__(),
-    __getstate__(), and __setstate(). This interface is similar to
-    that for regular Python classes as described in detail in the
-    Python Library Reference for pickle:
-
-    http://www.python.org/doc/current/lib/module-pickle.html
-
-    When an Extension Class instance is pickled, __getinitargs__() is
-    called, if implemented. This method should return a tuple
-    containing the arguments to be passed to the class constructor when
-    the object is restored.
-
-    If there is no __getstate__() method, the instance's __dict__ is
-    pickled if it is not empty. If __getstate__() is defined, it should
-    return an object representing the state of the instance.
-
-    If there is no __setstate__() method, __getstate__() must return a
-    dictionary. When the instance is restored, the items in this dictionary
-    are added to the instance's __dict__.
-
-    If the Extension Class defines __setstate__(), the pickle loader
-    calls it with the result of __getstate__() as arguments. In this
-    case, the state object need not be a dictionary.  The
-    __getstate__() and __setstate__() methods can do what they want.
-
-    If both __getinitargs__() and __getstate__() are defined, the
-    instance is restored by first calling the constructor with
-    the result of __getinitargs__() as argument. After the instance
-    is reconstructed, the __dict__ is updated or __setstate__() is
-    called if implemented.
-
-    The mechanism described here is an exact replication of that one
-    implemented by Jim Fulton's ExtensionClass (included in Zope 2.2.2).
- */
-
-#include <iostream>
-#include <string>
-
-#include <boost/python/class_builder.hpp>
-namespace python = boost::python;
-
-namespace { // Avoid cluttering the global namespace.
-
-  // A friendly class.
-  class world
-  {
-    private:
-      std::string country;
-      int secret_number;
-    public:
-      world(const std::string& country) : secret_number(0) {
-        this->country = country;
-      }
-      std::string greet() const { return "Hello from " + country + "!"; }
-      std::string get_country() const { return country; }
-      void set_secret_number(int number) { secret_number = number; }
-      int get_secret_number() const { return secret_number; }
-  };
-
-  // Support for pickle.
-  python::tuple world_getinitargs(const world& w) {
-      python::tuple result(1);
-      result.set_item(0, w.get_country());
-      return result;
-  }
-
-  python::tuple world_getstate(const world& w) {
-      python::tuple result(1);
-      result.set_item(0, w.get_secret_number());
-      return result;
-  }
-
-  void world_setstate(world& w, python::tuple state) {
-    if (state.size() != 1) {
-      PyErr_SetString(PyExc_ValueError,
-        "Unexpected argument in call to __setstate__.");
-      throw python::error_already_set();
-    }
-    int number = BOOST_PYTHON_CONVERSION::from_python(state[0].get(),
-      python::type<int>());
-    if (number != 42)
-      w.set_secret_number(number);
-  }
-}
-
-BOOST_PYTHON_MODULE_INIT(getting_started3)
-{
-  try
-  {
-    // Create an object representing this extension module.
-    python::module_builder this_module("getting_started3");
-
-    // Create the Python type object for our extension class.
-    python::class_builder<world> world_class(this_module, "world");
-
-    // Add the __init__ function.
-    world_class.def(python::constructor<std::string>());
-    // Add a regular member function.
-    world_class.def(&world::greet, "greet");
-    world_class.def(&world::get_secret_number, "get_secret_number");
-    world_class.def(&world::set_secret_number, "set_secret_number");
-
-    // Support for pickle.
-    world_class.def(world_getinitargs, "__getinitargs__");
-    world_class.def(world_getstate, "__getstate__");
-    world_class.def(world_setstate, "__setstate__");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}

example/ivect.cpp

@@ -0,0 +1,56 @@
+// Example by Ralf W. Grosse-Kunstleve
+// See root/libs/python/doc/cross_module.html for an introduction.
+
+#include "dvect.h"
+#include "ivect.h"
+#include <boost/python/cross_module.hpp>
+namespace python = boost::python;
+
+namespace {
+
+# include "dvect_conversions.cpp"
+# include "ivect_conversions.cpp"
+
+  vects::dvect ivect_as_dvect(const vects::ivect& iv)
+  {
+    vects::dvect dv(iv.size());
+    vects::dvect::iterator dviter = dv.begin();
+    for (int i = 0; i < iv.size(); i++) dviter[i] = static_cast<double>(iv[i]);
+    return dv;
+  }
+}
+
+# ifdef BOOST_MSVC // fixes for JIT debugging
+#  include <windows.h>
+extern "C" void structured_exception_translator(unsigned int, EXCEPTION_POINTERS*)
+{
+    throw;
+}
+extern "C" void (*old_translator)(unsigned int, EXCEPTION_POINTERS*)
+    = _set_se_translator(structured_exception_translator);
+# endif
+
+BOOST_PYTHON_MODULE_INIT(ivect)
+{
+  try
+  {
+    python::module_builder this_module("ivect");
+
+    python::class_builder<vects::ivect> ivect_class(this_module, "ivect");
+    python::export_converters(ivect_class);
+
+    python::import_converters<vects::dvect> dvect_converters("dvect", "dvect");
+
+    ivect_class.def(python::constructor<python::tuple>());
+    ivect_class.def(&vects::ivect::as_tuple, "as_tuple");
+    ivect_class.def(ivect_as_dvect, "as_dvect");
+
+# include "dvect_defs.cpp"
+# include "ivect_defs.cpp"
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
+

example/ivect.h

@@ -0,0 +1,32 @@
+#ifndef IVECT_H
+#define IVECT_H
+
+#include <vector>
+#include <boost/python/class_builder.hpp>
+
+namespace vects {
+
+  struct ivect : public std::vector<int>
+  {
+    ivect() : std::vector<int>() {}
+    ivect(size_t n) : std::vector<int>(n) {}
+    ivect(boost::python::tuple tuple) : std::vector<int>(tuple.size())
+    {
+      std::vector<int>::iterator v_it = begin();
+      for (int i = 0; i < tuple.size(); i++)
+        v_it[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
+          boost::python::type<int>());
+    }
+
+    boost::python::tuple as_tuple() const
+    {
+      boost::python::tuple t(size());
+      for (int i = 0; i < size(); i++)
+        t.set_item(i,
+          boost::python::ref(BOOST_PYTHON_CONVERSION::to_python((*this)[i])));
+      return t;
+    }
+  };
+}
+
+#endif // IVECT_H

example/ivect_conversions.cpp

@@ -0,0 +1,51 @@
+  // basics first: const reference converters
+  boost::python::tuple const_ivect_reference_as_tuple(const vects::ivect& iv)
+  {
+    return iv.as_tuple();
+  }
+
+  // to_python smart pointer conversions
+  std::auto_ptr<vects::ivect> ivect_as_auto_ptr(const vects::ivect& iv)
+  {
+    return std::auto_ptr<vects::ivect>(new vects::ivect(iv));
+  }
+  boost::shared_ptr<vects::ivect> ivect_as_shared_ptr(const vects::ivect& iv)
+  {
+    return boost::shared_ptr<vects::ivect>(new vects::ivect(iv));
+  }
+
+  // smart pointers passed by value
+  boost::python::ref auto_ptr_value_ivect_as_tuple(std::auto_ptr<vects::ivect> iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_value_ivect_as_tuple(boost::shared_ptr<vects::ivect> iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }
+
+  // smart pointers passed by reference
+  boost::python::ref auto_ptr_reference_ivect_as_tuple(std::auto_ptr<vects::ivect>& iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_reference_ivect_as_tuple(boost::shared_ptr<vects::ivect>& iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }
+
+  // smart pointers passed by const reference
+  boost::python::ref auto_ptr_const_reference_ivect_as_tuple(const std::auto_ptr<vects::ivect>& iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_const_reference_ivect_as_tuple(const boost::shared_ptr<vects::ivect>& iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }

example/ivect_defs.cpp

@@ -0,0 +1,13 @@
+    this_module.def(ivect_as_auto_ptr, "ivect_as_auto_ptr");
+    this_module.def(ivect_as_shared_ptr, "ivect_as_shared_ptr");
+
+    this_module.def(const_ivect_reference_as_tuple, "const_ivect_reference_as_tuple");
+
+    this_module.def(auto_ptr_value_ivect_as_tuple, "auto_ptr_value_ivect_as_tuple");
+    this_module.def(shared_ptr_value_ivect_as_tuple, "shared_ptr_value_ivect_as_tuple");
+
+    this_module.def(auto_ptr_reference_ivect_as_tuple, "auto_ptr_reference_ivect_as_tuple");
+    this_module.def(shared_ptr_reference_ivect_as_tuple, "shared_ptr_reference_ivect_as_tuple");
+
+    this_module.def(auto_ptr_const_reference_ivect_as_tuple, "auto_ptr_const_reference_ivect_as_tuple");
+    this_module.def(shared_ptr_const_reference_ivect_as_tuple, "shared_ptr_const_reference_ivect_as_tuple");

example/noncopyable.h

@@ -0,0 +1,14 @@
+#ifndef NONCOPYABLE_H
+#define NONCOPYABLE_H
+
+class store
+{
+  private:
+    store(const store&) { } // Disable the copy constructor.
+    int number;
+  public:
+    store(const int i) : number(i) { }
+    int recall() const { return number; }
+};
+
+#endif // NONCOPYABLE_H

example/noncopyable_export.cpp

@@ -0,0 +1,35 @@
+// Example by Ralf W. Grosse-Kunstleve
+// See root/libs/python/doc/cross_module.html for an introduction.
+
+#include <boost/python/cross_module.hpp>
+namespace python = boost::python;
+
+#include "noncopyable.h"
+
+# ifdef BOOST_MSVC // fixes for JIT debugging
+#  include <windows.h>
+extern "C" void structured_exception_translator(unsigned int, EXCEPTION_POINTERS*)
+{
+    throw;
+}
+extern "C" void (*old_translator)(unsigned int, EXCEPTION_POINTERS*)
+    = _set_se_translator(structured_exception_translator);
+# endif
+
+BOOST_PYTHON_MODULE_INIT(noncopyable_export)
+{
+  try
+  {
+    python::module_builder this_module("noncopyable_export");
+
+    python::class_builder<store> store_class(this_module, "store");
+    python::export_converters_noncopyable(store_class);
+
+    store_class.def(python::constructor<int>());
+    store_class.def(&store::recall, "recall");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}

example/noncopyable_import.cpp

@@ -0,0 +1,52 @@
+// Example by Ralf W. Grosse-Kunstleve
+// See root/libs/python/doc/cross_module.html for an introduction.
+
+#include <boost/python/cross_module.hpp>
+namespace python = boost::python;
+
+#include "noncopyable.h"
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A function with store objects as both input and output parameters.
+  // Because the copy constructor is disabled, we cannot pass a store
+  // object by value. Instead, we pass a smart pointer.
+  std::auto_ptr<store> add_stores(const store& s1, const store& s2)
+  {
+    int sum = s1.recall() + s2.recall();
+    std::auto_ptr<store> ss = std::auto_ptr<store>(new store(sum));
+    return ss;
+  }
+}
+
+# ifdef BOOST_MSVC // fixes for JIT debugging
+#  include <windows.h>
+extern "C" void structured_exception_translator(unsigned int, EXCEPTION_POINTERS*)
+{
+    throw;
+}
+extern "C" void (*old_translator)(unsigned int, EXCEPTION_POINTERS*)
+    = _set_se_translator(structured_exception_translator);
+# endif
+
+BOOST_PYTHON_MODULE_INIT(noncopyable_import)
+{
+  try
+  {
+    python::module_builder this_module("noncopyable_import");
+
+    python::import_converters<store>
+      dvect_converters("noncopyable_export", "store");
+
+    // Imagine all the additional classes with member functions
+    // that have store objects as input and output parameters.
+    // Lots and lots of them.
+    // However, to keep this example simple, we only define a
+    // module-level function.
+    this_module.def(add_stores, "add_stores");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}

example/pickle1.cpp

@@ -0,0 +1,64 @@
+// Example by Ralf W. Grosse-Kunstleve
+
+/*
+    This example shows how to make an Extension Class "pickleable".
+
+    The world class below can be fully restored by passing the
+    appropriate argument to the constructor. Therefore it is sufficient
+    to define the pickle interface method __getinitargs__.
+
+    For more information refer to boost/libs/python/doc/pickle.html.
+ */
+
+#include <string>
+
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A friendly class.
+  class world
+  {
+    private:
+      std::string country;
+      int secret_number;
+    public:
+      world(const std::string& country) : secret_number(0) {
+        this->country = country;
+      }
+      std::string greet() const { return "Hello from " + country + "!"; }
+      std::string get_country() const { return country; }
+  };
+
+  // Support for pickle.
+  python::ref world_getinitargs(const world& w) {
+      python::tuple result(1);
+      result.set_item(0, w.get_country());
+      return result.reference();
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(pickle1)
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("pickle1");
+
+    // Create the Python type object for our extension class.
+    python::class_builder<world> world_class(this_module, "world");
+
+    // Add the __init__ function.
+    world_class.def(python::constructor<std::string>());
+    // Add a regular member function.
+    world_class.def(&world::greet, "greet");
+
+    // Support for pickle.
+    world_class.def(world_getinitargs, "__getinitargs__");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}

example/pickle2.cpp

@@ -0,0 +1,100 @@
+// Example by Ralf W. Grosse-Kunstleve
+
+/*
+    This example shows how to make an Extension Class "pickleable".
+
+    The world class below contains member data (secret_number) that
+    cannot be restored by any of the constructors. Therefore it is
+    necessary to provide the __getstate__/__setstate__ pair of pickle
+    interface methods.
+
+    For simplicity, the __dict__ is not included in the result of
+    __getstate__. This is not generally recommended, but a valid
+    approach if it is anticipated that the object's __dict__ will
+    always be empty. Note that safety guard are provided to catch the
+    cases where this assumption is not true.
+
+    pickle3.cpp shows how to include the object's __dict__ in the
+    result of __getstate__.
+
+    For more information refer to boost/libs/python/doc/pickle.html.
+ */
+
+#include <string>
+
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A friendly class.
+  class world
+  {
+    public:
+      world(const std::string& country) : secret_number(0) {
+        this->country = country;
+      }
+      std::string greet() const { return "Hello from " + country + "!"; }
+      std::string get_country() const { return country; }
+      void set_secret_number(int number) { secret_number = number; }
+      int get_secret_number() const { return secret_number; }
+    private:
+      std::string country;
+      int secret_number;
+  };
+
+  // Support for pickle.
+
+  using BOOST_PYTHON_CONVERSION::from_python;
+
+  python::ref world_getinitargs(const world& w) {
+      python::tuple result(1);
+      result.set_item(0, w.get_country());
+      return result.reference(); // returning the reference avoids the copying.
+  }
+
+  python::ref world_getstate(const world& w) {
+      python::tuple result(1);
+      result.set_item(0, w.get_secret_number());
+      return result.reference(); // returning the reference avoids the copying.
+  }
+
+  void world_setstate(world& w, python::tuple state) {
+    if (state.size() != 1) {
+      PyErr_SetString(PyExc_ValueError,
+        "Unexpected argument in call to __setstate__.");
+      throw python::error_already_set();
+    }
+    int number = from_python(state[0].get(), python::type<int>());
+    if (number != 42)
+      w.set_secret_number(number);
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(pickle2)
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("pickle2");
+
+    // Create the Python type object for our extension class.
+    python::class_builder<world> world_class(this_module, "world");
+
+    // Add the __init__ function.
+    world_class.def(python::constructor<std::string>());
+    // Add a regular member function.
+    world_class.def(&world::greet, "greet");
+    world_class.def(&world::get_secret_number, "get_secret_number");
+    world_class.def(&world::set_secret_number, "set_secret_number");
+
+    // Support for pickle.
+    world_class.def(world_getinitargs, "__getinitargs__");
+    world_class.def(world_getstate, "__getstate__");
+    world_class.def(world_setstate, "__setstate__");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}

example/pickle3.cpp

@@ -0,0 +1,150 @@
+// Example by Ralf W. Grosse-Kunstleve
+
+/*
+    This example shows how to make an Extension Class "pickleable".
+
+    The world class below contains member data (secret_number) that
+    cannot be restored by any of the constructors. Therefore it is
+    necessary to provide the __getstate__/__setstate__ pair of pickle
+    interface methods.
+
+    The object's __dict__ is included in the result of __getstate__.
+    This requires more code (compare with pickle2.cpp), but is
+    unavoidable if the object's __dict__ is not always empty.
+
+    For more information refer to boost/libs/python/doc/pickle.html.
+ */
+
+#include <string>
+
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace boost { namespace python {
+
+  ref getattr(PyObject* o, const std::string& attr_name) {
+    return ref(PyObject_GetAttrString(o, const_cast<char*>(attr_name.c_str())));
+  }
+  ref getattr(const ref& r, const std::string& attr_name) {
+    return getattr(r.get(), attr_name);
+  }
+
+}}
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A friendly class.
+  class world
+  {
+    public:
+      world(const std::string& country) : secret_number(0) {
+        this->country = country;
+      }
+      std::string greet() const { return "Hello from " + country + "!"; }
+      std::string get_country() const { return country; }
+      void set_secret_number(int number) { secret_number = number; }
+      int get_secret_number() const { return secret_number; }
+    private:
+      std::string country;
+      int secret_number;
+  };
+
+  // Support for pickle.
+  python::ref world_getinitargs(const world& w) {
+      python::tuple result(1);
+      result.set_item(0, w.get_country());
+      return result.reference(); // returning the reference avoids the copying.
+  }
+
+  python::ref world_getstate(python::tuple const & args,
+                             python::dictionary const & keywords);
+
+  PyObject* world_setstate(python::tuple const & args,
+                           python::dictionary const & keywords);
+}
+
+BOOST_PYTHON_MODULE_INIT(pickle3)
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("pickle3");
+
+    // Create the Python type object for our extension class.
+    python::class_builder<world> world_class(this_module, "world");
+
+    // Add the __init__ function.
+    world_class.def(python::constructor<std::string>());
+    // Add a regular member function.
+    world_class.def(&world::greet, "greet");
+    world_class.def(&world::get_secret_number, "get_secret_number");
+    world_class.def(&world::set_secret_number, "set_secret_number");
+
+    // Support for pickle.
+    world_class.def(world_getinitargs, "__getinitargs__");
+    world_class.def_raw(world_getstate, "__getstate__");
+    world_class.def_raw(world_setstate, "__setstate__");
+    world_class.getstate_manages_dict();
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
+
+namespace {
+
+  using BOOST_PYTHON_CONVERSION::from_python;
+  using boost::python::type;
+  using boost::python::ref;
+  using boost::python::tuple;
+  using boost::python::list;
+  using boost::python::dictionary;
+  using boost::python::getattr;
+
+  ref world_getstate(tuple const & args, dictionary const & keywords)
+  {
+      if(args.size() != 1 || keywords.size() != 0) {
+          PyErr_SetString(PyExc_TypeError, "wrong number of arguments");
+          throw boost::python::error_already_set();
+      }
+      const world& w = from_python(args[0].get(), type<const world&>());
+      ref mydict = getattr(args[0], "__dict__");
+      tuple result(2);
+      // store the object's __dict__
+      result.set_item(0, mydict);
+      // store the internal state of the C++ object
+      result.set_item(1, w.get_secret_number());
+      return result.reference(); // returning the reference avoids the copying.
+  }
+
+  PyObject* world_setstate(tuple const & args, dictionary const & keywords)
+  {
+      if(args.size() != 2 || keywords.size() != 0) {
+          PyErr_SetString(PyExc_TypeError, "wrong number of arguments");
+          throw boost::python::error_already_set();
+      }
+      world& w = from_python(args[0].get(), type<world&>());
+      ref mydict = getattr(args[0], "__dict__");
+      tuple state = from_python(args[1].get(), type<tuple>());
+      if (state.size() != 2) {
+        PyErr_SetString(PyExc_ValueError,
+          "Unexpected argument in call to __setstate__.");
+        throw python::error_already_set();
+      }
+      // restore the object's __dict__
+      dictionary odict = from_python(mydict.get(), type<dictionary>());
+      const dictionary& pdict = from_python(state[0].get(), type<const dictionary&>());
+      list pkeys(pdict.keys());
+      for (int i = 0; i < pkeys.size(); i++) {
+        ref k(pkeys[i]);
+        //odict[k] = pdict[k]; // XXX memory leak!
+        odict[k] = pdict.get_item(k); // this does not leak.
+      }
+      // restore the internal state of the C++ object
+      int number = from_python(state[1].get(), type<int>());
+      if (number != 42)
+        w.set_secret_number(number);
+      return python::detail::none();
+  }
+}

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/simple_vector.cpp

@@ -1,3 +1,5 @@
+// Example by Ralf W. Grosse-Kunstleve
+
 #include <boost/python/class_builder.hpp>
 namespace python = boost::python;
 
@@ -15,7 +17,7 @@ namespace { // Avoid cluttering the global namespace.
     vector_double_wrapper(PyObject* self)
       : std::vector<double>() {}
 
-    vector_double_wrapper(PyObject* self, const int n)
+    vector_double_wrapper(PyObject* self, int n)
       : std::vector<double>(n) {}
 
     vector_double_wrapper(PyObject* self, python::tuple tuple)
@@ -28,19 +30,26 @@ namespace { // Avoid cluttering the global namespace.
     }
   };
 
-  double getitem(const std::vector<double>& vd, const std::size_t key) {
+  void raise_vector_IndexError() {
+    PyErr_SetString(PyExc_IndexError, "vector index out of range");
+    throw python::error_already_set();
+  }
+
+  double getitem(const std::vector<double>& vd, std::size_t key) {
+    if (key >= vd.size()) raise_vector_IndexError();
     return vd[key];
   }
 
-  void setitem(std::vector<double>& vd, const std::size_t key,
-               const double &d) {
+  void setitem(std::vector<double>& vd, std::size_t key, double d) {
+    if (key >= vd.size()) raise_vector_IndexError();
     std::vector<double>::iterator vditer = vd.begin();
     vditer[key] = d;
   }
 
-  void delitem(std::vector<double>& vd, const std::size_t key) {
+  void delitem(std::vector<double>& vd, std::size_t key) {
+    if (key >= vd.size()) raise_vector_IndexError();
     std::vector<double>::iterator vditer = vd.begin();
-    vd.erase(&vditer[key]);
+    vd.erase(vditer + key);
   }
 
   // Convert vector_double to a regular Python tuple.
@@ -74,11 +83,11 @@ namespace { // Avoid cluttering the global namespace.
   }
 }
 
-BOOST_PYTHON_MODULE_INIT(getting_started4)
+BOOST_PYTHON_MODULE_INIT(simple_vector)
 {
   try
   {
-    python::module_builder this_module("getting_started4");
+    python::module_builder this_module("simple_vector");
 
     python::class_builder<std::vector<double>, vector_double_wrapper>
       vector_double(this_module, "vector_double");

example/test_abstract.py

@@ -17,7 +17,8 @@ def run(args = None):
         import sys
         sys.argv = args
     import doctest, test_abstract
-    doctest.testmod(test_abstract)
+    return doctest.testmod(test_abstract)
 
 if __name__ == '__main__':
-    run()
+    import sys
+    sys.exit(run()[0])

example/test_cross_module.py

@@ -0,0 +1,140 @@
+r'''>>> import tst_noncopyable
+    >>> tst_noncopyable.f()
+    1
+    2
+    3
+    >>> import tst_dvect1
+    >>> tst_dvect1.f()
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    (1, 2, 3, 4, 5)
+    (1, 2, 3, 4, 5)
+    (1, 2, 3, 4, 5)
+    (1, 2, 3, 4, 5)
+    (1, 2, 3, 4, 5)
+    (1, 2, 3, 4, 5)
+    >>> import tst_ivect1
+    >>> tst_ivect1.f()
+    (1, 2, 3, 4, 5)
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    >>> import sys
+    >>> if ("--broken-auto-ptr" in sys.argv):
+    ...   broken_auto_ptr = 1
+    ... else:
+    ...   broken_auto_ptr = 0
+    >>> import tst_dvect2
+    >>> tst_dvect2.f(broken_auto_ptr)
+    1. auto_ptr_value_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. auto_ptr_value_ivect_as_tuple
+    None
+    1. auto_ptr_value_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. auto_ptr_value_dvect_as_tuple
+    None
+    1. shared_ptr_value_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. shared_ptr_value_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. shared_ptr_value_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. shared_ptr_value_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. auto_ptr_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. auto_ptr_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. auto_ptr_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. auto_ptr_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. shared_ptr_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. shared_ptr_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. shared_ptr_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. shared_ptr_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. auto_ptr_const_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. auto_ptr_const_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. auto_ptr_const_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. auto_ptr_const_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. shared_ptr_const_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. shared_ptr_const_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. shared_ptr_const_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. shared_ptr_const_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    >>> import tst_ivect2
+    >>> tst_ivect2.f(broken_auto_ptr)
+    1. auto_ptr_value_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. auto_ptr_value_dvect_as_tuple
+    None
+    1. auto_ptr_value_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. auto_ptr_value_ivect_as_tuple
+    None
+    1. shared_ptr_value_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. shared_ptr_value_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. shared_ptr_value_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. shared_ptr_value_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. auto_ptr_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. auto_ptr_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. auto_ptr_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. auto_ptr_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. shared_ptr_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. shared_ptr_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. shared_ptr_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. shared_ptr_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. auto_ptr_const_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. auto_ptr_const_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. auto_ptr_const_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. auto_ptr_const_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. shared_ptr_const_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. shared_ptr_const_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. shared_ptr_const_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. shared_ptr_const_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_cross_module
+    return doctest.testmod(test_cross_module)
+
+if __name__ == '__main__':
+    import sys
+    sys.exit(run()[0])

example/test_do_it_yourself_converters.py

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

example/test_example1.py

@@ -44,7 +44,8 @@ def run(args = None):
         import sys
         sys.argv = args
     import doctest, test_example1
-    doctest.testmod(test_example1)
+    return doctest.testmod(test_example1)
     
 if __name__ == '__main__':
-    run()
+    import sys
+    sys.exit(run()[0])

example/test_getting_started1.py

@@ -11,7 +11,8 @@ def run(args = None):
         import sys
         sys.argv = args
     import doctest, test_getting_started1
-    doctest.testmod(test_getting_started1)
+    return doctest.testmod(test_getting_started1)
 
 if __name__ == '__main__':
-    run()
+    import sys
+    sys.exit(run()[0])

example/test_getting_started2.py

@@ -23,7 +23,9 @@ def run(args = None):
         import sys
         sys.argv = args
     import doctest, test_getting_started2
-    doctest.testmod(test_getting_started2)
+    return doctest.testmod(test_getting_started2)
 
 if __name__ == '__main__':
-    run()
+    import sys
+    sys.exit(run()[0])
+

example/test_getting_started3.py

@@ -1,56 +0,0 @@
-r'''>>> import getting_started3
-    >>> import re
-    >>> import pickle
-    >>> getting_started3.world.__module__
-    'getting_started3'
-    >>> getting_started3.world.__safe_for_unpickling__
-    1
-    >>> getting_started3.world.__reduce__()
-    'world'
-    >>> assert re.match(
-    ... "\(<extension class getting_started3.world at [0-9a-fA-FxX]+>, \('Hello',\), \(0,\)\)",
-    ... repr(getting_started3.world('Hello').__reduce__()))
-    >>>
-    >>> for number in (24, 42):
-    ...   wd = getting_started3.world('California')
-    ...   wd.set_secret_number(number)
-    ...   pstr = pickle.dumps(wd)
-    ...   print pstr
-    ...   wl = pickle.loads(pstr)
-    ...   print wd.greet(), wd.get_secret_number()
-    ...   print wl.greet(), wl.get_secret_number()
-    cgetting_started3
-    world
-    p0
-    (S'California'
-    p1
-    tp2
-    R(I24
-    tp3
-    bp4
-    .
-    Hello from California! 24
-    Hello from California! 24
-    cgetting_started3
-    world
-    p0
-    (S'California'
-    p1
-    tp2
-    R(I42
-    tp3
-    bp4
-    .
-    Hello from California! 42
-    Hello from California! 0
-'''
-
-def run(args = None):
-    if args is not None:
-        import sys
-        sys.argv = args
-    import doctest, test_getting_started3
-    doctest.testmod(test_getting_started3)
-
-if __name__ == '__main__':
-    run()

example/test_pickle1.py

@@ -0,0 +1,33 @@
+r'''>>> import pickle1
+    >>> import re
+    >>> import pickle
+    >>> pickle1.world.__module__
+    'pickle1'
+    >>> pickle1.world.__safe_for_unpickling__
+    1
+    >>> pickle1.world.__reduce__()
+    'world'
+    >>> assert re.match(
+    ... "\(<extension class pickle1.world at [0-9a-fA-FxX]+>, \('Hello',\)\)",
+    ... repr(pickle1.world('Hello').__reduce__()))
+    >>>
+    >>> wd = pickle1.world('California')
+    >>> pstr = pickle.dumps(wd)
+    >>> wl = pickle.loads(pstr)
+    >>> print wd.greet()
+    Hello from California!
+    >>> print wl.greet()
+    Hello from California!
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_pickle1
+    return doctest.testmod(test_pickle1)
+
+if __name__ == '__main__':
+    import sys
+    sys.exit(run()[0])
+

example/test_pickle2.py

@@ -0,0 +1,47 @@
+r'''>>> import pickle2
+    >>> import re
+    >>> import pickle
+    >>> pickle2.world.__module__
+    'pickle2'
+    >>> pickle2.world.__safe_for_unpickling__
+    1
+    >>> pickle2.world.__reduce__()
+    'world'
+    >>> assert re.match(
+    ... "\(<extension class pickle2.world at [0-9a-fA-FxX]+>, \('Hello',\), \(0,\)\)",
+    ... repr(pickle2.world('Hello').__reduce__()))
+    >>>
+    >>> for number in (24, 42):
+    ...   wd = pickle2.world('California')
+    ...   wd.set_secret_number(number)
+    ...   pstr = pickle.dumps(wd)
+    ...   wl = pickle.loads(pstr)
+    ...   print wd.greet(), wd.get_secret_number()
+    ...   print wl.greet(), wl.get_secret_number()
+    Hello from California! 24
+    Hello from California! 24
+    Hello from California! 42
+    Hello from California! 0
+
+# Now show that the __dict__ is not taken care of.
+    >>> wd = pickle2.world('California')
+    >>> wd.x = 1
+    >>> wd.__dict__
+    {'x': 1}
+    >>> try: pstr = pickle.dumps(wd)
+    ... except RuntimeError, err: print err[0]
+    ...
+    Incomplete pickle support (__getstate_manages_dict__ not set)
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_pickle2
+    return doctest.testmod(test_pickle2)
+
+if __name__ == '__main__':
+    import sys
+    sys.exit(run()[0])
+

example/test_pickle3.py

@@ -0,0 +1,39 @@
+r'''>>> import pickle3
+    >>> import re
+    >>> import pickle
+    >>> pickle3.world.__module__
+    'pickle3'
+    >>> pickle3.world.__safe_for_unpickling__
+    1
+    >>> pickle3.world.__reduce__()
+    'world'
+    >>> assert re.match(
+    ... "\(<extension class pickle3.world at [0-9a-fA-FxX]+>, \('Hello',\), \(\{\}, 0\)\)",
+    ... repr(pickle3.world('Hello').__reduce__()))
+    >>>
+    >>> for number in (24, 42):
+    ...   wd = pickle3.world('California')
+    ...   wd.set_secret_number(number)
+    ...   wd.x = 2 * number
+    ...   wd.y = 'y' * number
+    ...   wd.z = 3. * number
+    ...   pstr = pickle.dumps(wd)
+    ...   wl = pickle.loads(pstr)
+    ...   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):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_pickle3
+    return doctest.testmod(test_pickle3)
+
+if __name__ == '__main__':
+    import sys
+    sys.exit(run()[0])

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/test_rwgk1.py

@@ -11,7 +11,9 @@ def run(args = None):
         import sys
         sys.argv = args
     import doctest, test_rwgk1
-    doctest.testmod(test_rwgk1)
+    return doctest.testmod(test_rwgk1)
 
 if __name__ == '__main__':
-    run()
+    import sys
+    sys.exit(run()[0])
+

example/test_simple_vector.py

@@ -1,13 +1,13 @@
-r'''>>> import getting_started4
-    >>> v=getting_started4.vector_double()
+r'''>>> import simple_vector
+    >>> v=simple_vector.vector_double()
     >>> print v.as_tuple()
     ()
-    >>> v=getting_started4.vector_double(5)
+    >>> v=simple_vector.vector_double(5)
     >>> print v.as_tuple()
     (0.0, 0.0, 0.0, 0.0, 0.0)
     >>> print len(v)
     5
-    >>> v=getting_started4.vector_double((3,4,5))
+    >>> v=simple_vector.vector_double((3,4,5))
     >>> print v.as_tuple()
     (3.0, 4.0, 5.0)
     >>> print v[1]
@@ -15,12 +15,17 @@ r'''>>> import getting_started4
     >>> v[1] = 40
     >>> print v.as_tuple()
     (3.0, 40.0, 5.0)
+    >>> for e in v:
+    ...   print e
+    3.0
+    40.0
+    5.0
     >>> del v[1]
     >>> print v.as_tuple()
     (3.0, 5.0)
-    >>> print getting_started4.foo(11).as_tuple()
+    >>> print simple_vector.foo(11).as_tuple()
     (0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0)
-    >>> print getting_started4.bar(12).as_tuple()
+    >>> print simple_vector.bar(12).as_tuple()
     (0.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0, 110.0)
 '''
 
@@ -28,8 +33,10 @@ def run(args = None):
     if args is not None:
         import sys
         sys.argv = args
-    import doctest, test_getting_started4
-    doctest.testmod(test_getting_started4)
+    import doctest, test_simple_vector
+    return doctest.testmod(test_simple_vector)
 
 if __name__ == '__main__':
-    run()
+    import sys
+    sys.exit(run()[0])
+

example/tst_dvect1.py

@@ -0,0 +1,20 @@
+def f():
+  import dvect
+  dv = dvect.dvect((1,2,3,4,5))
+  print dv.as_tuple()
+  iv = dv.as_ivect()
+  print iv.as_tuple()
+  print dvect.const_ivect_reference_as_tuple(iv)
+  aiv = dvect.ivect_as_auto_ptr(iv)
+  print dvect.const_ivect_reference_as_tuple(aiv)
+  siv = dvect.ivect_as_shared_ptr(iv)
+  print dvect.const_ivect_reference_as_tuple(siv)
+  print aiv.as_tuple()
+  print siv.as_tuple()
+
+if (__name__ == "__main__"):
+  import sys, string
+  n = 1
+  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
+  for i in xrange(n):
+    f()

example/tst_dvect2.py

@@ -0,0 +1,104 @@
+def f(broken_auto_ptr):
+  import dvect
+  import ivect
+  #
+  dv = dvect.dvect((1,2,3,4,5))
+  iv = dv.as_ivect()
+  #
+  aiv = dvect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_value_ivect_as_tuple'
+  print ivect.auto_ptr_value_ivect_as_tuple(aiv)
+  print '2. auto_ptr_value_ivect_as_tuple'
+  if (not broken_auto_ptr):
+    print ivect.auto_ptr_value_ivect_as_tuple(aiv)
+  else:
+    print None
+  #
+  adv = dvect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_value_dvect_as_tuple'
+  print ivect.auto_ptr_value_dvect_as_tuple(adv)
+  print '2. auto_ptr_value_dvect_as_tuple'
+  if (not broken_auto_ptr):
+    print ivect.auto_ptr_value_dvect_as_tuple(adv)
+  else:
+    print None
+  #
+  siv = dvect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_value_ivect_as_tuple'
+  print ivect.shared_ptr_value_ivect_as_tuple(siv)
+  print '2. shared_ptr_value_ivect_as_tuple'
+  print ivect.shared_ptr_value_ivect_as_tuple(siv)
+  #
+  sdv = dvect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_value_dvect_as_tuple'
+  print ivect.shared_ptr_value_dvect_as_tuple(sdv)
+  print '2. shared_ptr_value_dvect_as_tuple'
+  print ivect.shared_ptr_value_dvect_as_tuple(sdv)
+  #
+  aiv = dvect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_reference_ivect_as_tuple'
+  print ivect.auto_ptr_reference_ivect_as_tuple(aiv)
+  print '2. auto_ptr_reference_ivect_as_tuple'
+  print ivect.auto_ptr_reference_ivect_as_tuple(aiv)
+  #
+  adv = dvect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_reference_dvect_as_tuple'
+  print ivect.auto_ptr_reference_dvect_as_tuple(adv)
+  print '2. auto_ptr_reference_dvect_as_tuple'
+  print ivect.auto_ptr_reference_dvect_as_tuple(adv)
+  #
+  siv = dvect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_reference_ivect_as_tuple'
+  print ivect.shared_ptr_reference_ivect_as_tuple(siv)
+  print '2. shared_ptr_reference_ivect_as_tuple'
+  print ivect.shared_ptr_reference_ivect_as_tuple(siv)
+  #
+  sdv = dvect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_reference_dvect_as_tuple'
+  print ivect.shared_ptr_reference_dvect_as_tuple(sdv)
+  print '2. shared_ptr_reference_dvect_as_tuple'
+  print ivect.shared_ptr_reference_dvect_as_tuple(sdv)
+  #
+  aiv = dvect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_const_reference_ivect_as_tuple'
+  print ivect.auto_ptr_const_reference_ivect_as_tuple(aiv)
+  print '2. auto_ptr_const_reference_ivect_as_tuple'
+  print ivect.auto_ptr_const_reference_ivect_as_tuple(aiv)
+  #
+  adv = dvect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_const_reference_dvect_as_tuple'
+  print ivect.auto_ptr_const_reference_dvect_as_tuple(adv)
+  print '2. auto_ptr_const_reference_dvect_as_tuple'
+  print ivect.auto_ptr_const_reference_dvect_as_tuple(adv)
+  #
+  siv = dvect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_const_reference_ivect_as_tuple'
+  print ivect.shared_ptr_const_reference_ivect_as_tuple(siv)
+  print '2. shared_ptr_const_reference_ivect_as_tuple'
+  print ivect.shared_ptr_const_reference_ivect_as_tuple(siv)
+  #
+  sdv = dvect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_const_reference_dvect_as_tuple'
+  print ivect.shared_ptr_const_reference_dvect_as_tuple(sdv)
+  print '2. shared_ptr_const_reference_dvect_as_tuple'
+  print ivect.shared_ptr_const_reference_dvect_as_tuple(sdv)
+
+if (__name__ == "__main__"):
+  import sys, string
+  broken_auto_ptr = 0
+  n = 1
+  
+  if len(sys.argv) > 1:
+      argv = []
+      
+      for x in sys.argv:
+        if x != '--broken-auto-ptr':
+          argv.append(x)
+      broken_auto_ptr = argv != sys.argv
+      sys.argv = argv
+
+      if len(sys.argv) > 1:
+        n = string.atoi(sys.argv[1])
+        
+  for i in xrange(n):
+    f(broken_auto_ptr)

example/tst_ivect1.py

@@ -0,0 +1,20 @@
+def f():
+  import ivect
+  iv = ivect.ivect((1,2,3,4,5))
+  print iv.as_tuple()
+  dv = iv.as_dvect()
+  print dv.as_tuple()
+  print ivect.const_dvect_reference_as_tuple(dv)
+  adv = ivect.dvect_as_auto_ptr(dv)
+  print ivect.const_dvect_reference_as_tuple(adv)
+  sdv = ivect.dvect_as_shared_ptr(dv)
+  print ivect.const_dvect_reference_as_tuple(sdv)
+  print adv.as_tuple()
+  print sdv.as_tuple()
+
+if (__name__ == "__main__"):
+  import sys, string
+  n = 1
+  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
+  for i in xrange(n):
+    f()

example/tst_ivect2.py

@@ -0,0 +1,104 @@
+def f(broken_auto_ptr):
+  import ivect
+  import dvect
+  #
+  iv = ivect.ivect((1,2,3,4,5))
+  dv = iv.as_dvect()
+  #
+  adv = ivect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_value_dvect_as_tuple'
+  print dvect.auto_ptr_value_dvect_as_tuple(adv)
+  print '2. auto_ptr_value_dvect_as_tuple'
+  if (not broken_auto_ptr):
+    print dvect.auto_ptr_value_dvect_as_tuple(adv)
+  else:
+    print None
+  #
+  aiv = ivect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_value_ivect_as_tuple'
+  print dvect.auto_ptr_value_ivect_as_tuple(aiv)
+  print '2. auto_ptr_value_ivect_as_tuple'
+  if (not broken_auto_ptr):
+    print dvect.auto_ptr_value_ivect_as_tuple(aiv)
+  else:
+    print None
+  #
+  sdv = ivect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_value_dvect_as_tuple'
+  print dvect.shared_ptr_value_dvect_as_tuple(sdv)
+  print '2. shared_ptr_value_dvect_as_tuple'
+  print dvect.shared_ptr_value_dvect_as_tuple(sdv)
+  #
+  siv = ivect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_value_ivect_as_tuple'
+  print dvect.shared_ptr_value_ivect_as_tuple(siv)
+  print '2. shared_ptr_value_ivect_as_tuple'
+  print dvect.shared_ptr_value_ivect_as_tuple(siv)
+  #
+  adv = ivect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_reference_dvect_as_tuple'
+  print dvect.auto_ptr_reference_dvect_as_tuple(adv)
+  print '2. auto_ptr_reference_dvect_as_tuple'
+  print dvect.auto_ptr_reference_dvect_as_tuple(adv)
+  #
+  aiv = ivect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_reference_ivect_as_tuple'
+  print dvect.auto_ptr_reference_ivect_as_tuple(aiv)
+  print '2. auto_ptr_reference_ivect_as_tuple'
+  print dvect.auto_ptr_reference_ivect_as_tuple(aiv)
+  #
+  sdv = ivect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_reference_dvect_as_tuple'
+  print dvect.shared_ptr_reference_dvect_as_tuple(sdv)
+  print '2. shared_ptr_reference_dvect_as_tuple'
+  print dvect.shared_ptr_reference_dvect_as_tuple(sdv)
+  #
+  siv = ivect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_reference_ivect_as_tuple'
+  print dvect.shared_ptr_reference_ivect_as_tuple(siv)
+  print '2. shared_ptr_reference_ivect_as_tuple'
+  print dvect.shared_ptr_reference_ivect_as_tuple(siv)
+  #
+  adv = ivect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_const_reference_dvect_as_tuple'
+  print dvect.auto_ptr_const_reference_dvect_as_tuple(adv)
+  print '2. auto_ptr_const_reference_dvect_as_tuple'
+  print dvect.auto_ptr_const_reference_dvect_as_tuple(adv)
+  #
+  aiv = ivect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_const_reference_ivect_as_tuple'
+  print dvect.auto_ptr_const_reference_ivect_as_tuple(aiv)
+  print '2. auto_ptr_const_reference_ivect_as_tuple'
+  print dvect.auto_ptr_const_reference_ivect_as_tuple(aiv)
+  #
+  sdv = ivect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_const_reference_dvect_as_tuple'
+  print dvect.shared_ptr_const_reference_dvect_as_tuple(sdv)
+  print '2. shared_ptr_const_reference_dvect_as_tuple'
+  print dvect.shared_ptr_const_reference_dvect_as_tuple(sdv)
+  #
+  siv = ivect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_const_reference_ivect_as_tuple'
+  print dvect.shared_ptr_const_reference_ivect_as_tuple(siv)
+  print '2. shared_ptr_const_reference_ivect_as_tuple'
+  print dvect.shared_ptr_const_reference_ivect_as_tuple(siv)
+
+if (__name__ == "__main__"):
+  import sys, string
+  broken_auto_ptr = 0
+  n = 1
+
+  if len(sys.argv) > 1:
+      argv = []
+      
+      for x in sys.argv:
+        if x != '--broken-auto-ptr':
+          argv.append(x)
+      broken_auto_ptr = argv != sys.argv
+      sys.argv = argv
+
+      if len(sys.argv) > 1:
+        n = string.atoi(sys.argv[1])
+        
+  for i in xrange(n):
+    f(broken_auto_ptr)

example/tst_noncopyable.py

@@ -0,0 +1,16 @@
+def f():
+  import noncopyable_export
+  import noncopyable_import
+  s1 = noncopyable_export.store(1)
+  print s1.recall()
+  s2 = noncopyable_export.store(2)
+  print s2.recall()
+  s3 = noncopyable_import.add_stores(s1, s2)
+  print s3.recall()
+
+if (__name__ == "__main__"):
+  import sys, string
+  n = 1
+  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
+  for i in xrange(n):
+    f()

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/cross_module.hpp

@@ -1,3 +1,17 @@
+/* (C) Copyright Ralf W. Grosse-Kunstleve 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.
+
+   Revision History:
+     17 Apr 01 merged into boost CVS trunk (Ralf W. Grosse-Kunstleve)
+*/
+
+/* Implementation of Boost.Python cross-module support.
+   See root/libs/python/doc/cross_module.html for details.
+*/
+
 #ifndef CROSS_MODULE_HPP
 # define CROSS_MODULE_HPP
 
@@ -12,7 +26,7 @@ namespace boost { namespace python { namespace detail {
 
 // Concept: throw exception if api_major is changed
 //          show warning on stderr if api_minor is changed
-const int export_converters_api_major = 2;
+const int export_converters_api_major = 4;
 const int export_converters_api_minor = 1;
 extern const char* converters_attribute_name;
 void* import_converter_object(const std::string& module_name,
@@ -32,83 +46,75 @@ template <class T> class import_extension_class;
 
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
-//QUESTIONMARK
-//  This class is a look-alike of class python_extension_class_converters.
-//  Is there a formal way to ensure that the siblings stay in sync?
+/* This class template is instantiated by import_converters<T>.
+   This class is a look-alike of class python_extension_class_converters.
+   The converters in this class are wrappers that call converters
+   imported from another module.
+   To ensure that the dynamic loader resolves all symbols in the
+   intended way, the signature of all friend functions is changed with
+   respect to the original functions in class
+   python_extension_class_converters by adding an arbitrary additional
+   parameter with a default value, in this case "bool sig = false".
+   See also: comments for class export_converter_object_base below.
+ */
 template <class T>
 class python_import_extension_class_converters
 {
  public:
 
-    friend python_import_extension_class_converters py_extension_class_converters(boost::python::type<T>)
-    {
+    friend python_import_extension_class_converters py_extension_class_converters(boost::python::type<T>, bool sig = false) {
         return python_import_extension_class_converters();
     }
 
-    PyObject* to_python(const T& x) const
-    {
+    PyObject* to_python(const T& x) const {
         return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
     }
 
-    friend T* from_python(PyObject* p, boost::python::type<T*>)
-    {
-        return boost::python::detail::import_extension_class<T>::get_converters()->T_pointer_from_python(p);
+    friend T* from_python(PyObject* p, boost::python::type<T*> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_Ts(p, t);
+    }
+    friend const T* from_python(PyObject* p, boost::python::type<const T*> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_cTs(p, t);
+    }
+    friend const T* from_python(PyObject* p, boost::python::type<const T*const&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_cTscr(p, t);
+    }
+    friend T* from_python(PyObject* p, boost::python::type<T* const&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_Tscr(p, t);
+    }
+    friend T& from_python(PyObject* p, boost::python::type<T&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_Tr(p, t);
+    }
+    friend const T& from_python(PyObject* p, boost::python::type<const T&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_cTr(p, t);
+    }
+    friend const T& from_python(PyObject* p, boost::python::type<T> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_T(p, t);
     }
 
-    // Convert to const T*
-    friend const T* from_python(PyObject* p, boost::python::type<const T*>)
-        { return from_python(p, boost::python::type<T*>()); }
-
-    // Convert to const T* const&
-    friend const T* from_python(PyObject* p, boost::python::type<const T*const&>)
-         { return from_python(p, boost::python::type<const T*>()); }
-
-    // Convert to T* const&
-    friend T* from_python(PyObject* p, boost::python::type<T* const&>)
-         { return from_python(p, boost::python::type<T*>()); }
-
-    // Convert to T&
-    friend T& from_python(PyObject* p, boost::python::type<T&>) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->T_reference_from_python(p);
+    friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T>&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_aTr(p, t);
     }
-
-    // Convert to const T&
-    friend const T& from_python(PyObject* p, boost::python::type<const T&>)
-        { return from_python(p, boost::python::type<T&>()); }
-
-    // Convert to T
-    friend const T& from_python(PyObject* p, boost::python::type<T>)
-        { return from_python(p, boost::python::type<T&>()); }
-
-    friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T>&>) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->auto_ptr_reference_from_python(p);
+    friend std::auto_ptr<T> from_python(PyObject* p, boost::python::type<std::auto_ptr<T> > t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_aT(p, t);
     }
-
-    friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T> >) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->auto_ptr_value_from_python(p);
+    friend const std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<const std::auto_ptr<T>&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_caTr(p, t);
     }
-
-    friend const std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<const std::auto_ptr<T>&>) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->auto_ptr_value_from_python(p);
-    }
-
-    friend PyObject* to_python(std::auto_ptr<T> x) {
+    friend PyObject* to_python(std::auto_ptr<T> x, bool sig = false) {
         return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
     }
 
-    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T>&>) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->shared_ptr_reference_from_python(p);
+    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T>&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_sTr(p, t);
     }
-
-    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T> >) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->shared_ptr_value_from_python(p);
+    friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T> > t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_sT(p, t);
     }
-
-    friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<const boost::shared_ptr<T>&>) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->shared_ptr_value_from_python(p);
+    friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<const boost::shared_ptr<T>&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_csTr(p, t);
     }
-
-    friend PyObject* to_python(boost::shared_ptr<T> x) {
+    friend PyObject* to_python(boost::shared_ptr<T> x, bool sig = false) {
         return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
     }
 };
@@ -119,78 +125,118 @@ namespace boost { namespace python {
 
 BOOST_PYTHON_IMPORT_CONVERSION(python_import_extension_class_converters);
 
-// A pointer to this class is exported/imported via the Python API.
-// All functions are virtual. This is, what we really export/import
-// is essentially just a pointer to a vtbl.
+/* This class template is instantiated by export_converters().
+   A pointer to this class is exported/imported via the Python API.
+   Using the Python API ensures maximum portability.
+   All member functions are virtual. This is, what we export/import
+   is essentially just a pointer to a vtbl.
+   To work around a deficiency of Visual C++ 6.0, the name of each
+   from_python() member functions is made unique by appending a few
+   characters (derived in a ad-hoc manner from the corresponding type).
+ */
 template <class T>
 struct export_converter_object_base
 {
-  virtual const int get_api_major() const {
-    return detail::export_converters_api_major; }
-  virtual const int get_api_minor() const {
-    return detail::export_converters_api_minor; }
-  virtual PyObject* to_python(const T& x) = 0;
-  virtual PyObject* to_python(std::auto_ptr<T> x) = 0;
-  virtual PyObject* to_python(boost::shared_ptr<T> x) = 0;
-  virtual T* T_pointer_from_python(PyObject* obj) = 0;
-  virtual T& T_reference_from_python(PyObject* obj) = 0;
-  virtual std::auto_ptr<T>& auto_ptr_reference_from_python(PyObject* obj) = 0;
-  virtual std::auto_ptr<T> auto_ptr_value_from_python(PyObject* obj) = 0;
-  virtual boost::shared_ptr<T>& shared_ptr_reference_from_python(PyObject* obj) = 0;
-  virtual boost::shared_ptr<T> shared_ptr_value_from_python(PyObject* obj) = 0;
+    virtual int get_api_major() const { return detail::export_converters_api_major; }
+    virtual int get_api_minor() const { return detail::export_converters_api_minor; }
+
+    virtual PyObject* to_python(const T& x) = 0;
+
+    virtual T* from_python_Ts(PyObject* p, boost::python::type<T*> t) = 0;
+    virtual const T* from_python_cTs(PyObject* p, boost::python::type<const T*> t) = 0;
+    virtual const T* from_python_cTscr(PyObject* p, boost::python::type<const T*const&> t) = 0;
+    virtual T* from_python_Tscr(PyObject* p, boost::python::type<T* const&> t) = 0;
+    virtual T& from_python_Tr(PyObject* p, boost::python::type<T&> t) = 0;
+    virtual const T& from_python_cTr(PyObject* p, boost::python::type<const T&> t) = 0;
+    virtual const T& from_python_T(PyObject* p, boost::python::type<T> t) = 0;
+
+    virtual std::auto_ptr<T>& from_python_aTr(PyObject* p, boost::python::type<std::auto_ptr<T>&> t) = 0;
+    virtual std::auto_ptr<T> from_python_aT(PyObject* p, boost::python::type<std::auto_ptr<T> > t) = 0;
+    virtual const std::auto_ptr<T>& from_python_caTr(PyObject* p, boost::python::type<const std::auto_ptr<T>&> t) = 0;
+    virtual PyObject* to_python(std::auto_ptr<T> x) = 0;
+
+    virtual boost::shared_ptr<T>& from_python_sTr(PyObject* p, boost::python::type<boost::shared_ptr<T>&> t) = 0;
+    virtual const boost::shared_ptr<T>& from_python_sT(PyObject* p, boost::python::type<boost::shared_ptr<T> > t) = 0;
+    virtual const boost::shared_ptr<T>& from_python_csTr(PyObject* p, boost::python::type<const boost::shared_ptr<T>&> t) = 0;
+    virtual PyObject* to_python(boost::shared_ptr<T> x) = 0;
 };
 
 // Converters to be used if T is not copyable.
 template <class T>
 struct export_converter_object_noncopyable : export_converter_object_base<T>
 {
-  virtual PyObject* to_python(const T& x) {
-    PyErr_SetString(PyExc_RuntimeError,
-      "to_python(const T&) converter not exported");
-    throw import_error();
-  }
-  virtual PyObject* to_python(std::auto_ptr<T> x) {
-    return BOOST_PYTHON_CONVERSION::to_python(x);
-  }
-  virtual PyObject* to_python(boost::shared_ptr<T> x) {
-    return BOOST_PYTHON_CONVERSION::to_python(x);
-  }
-  virtual T* T_pointer_from_python(PyObject* obj) {
-    return BOOST_PYTHON_CONVERSION::from_python(obj, boost::python::type<T*>());
-  }
-  virtual T& T_reference_from_python(PyObject* obj) {
-    return BOOST_PYTHON_CONVERSION::from_python(obj, boost::python::type<T&>());
-  }
-  virtual std::auto_ptr<T>& auto_ptr_reference_from_python(PyObject* obj) {
-    return BOOST_PYTHON_CONVERSION::python_extension_class_converters<T>::smart_ptr_reference(obj, boost::python::type<std::auto_ptr<T> >());
-  }
-  virtual std::auto_ptr<T> auto_ptr_value_from_python(PyObject* obj) {
-    return BOOST_PYTHON_CONVERSION::python_extension_class_converters<T>::smart_ptr_value(obj, boost::python::type<std::auto_ptr<T> >());
-  }
-  virtual boost::shared_ptr<T>& shared_ptr_reference_from_python(PyObject* obj) {
-    return BOOST_PYTHON_CONVERSION::python_extension_class_converters<T>::smart_ptr_reference(obj, boost::python::type<boost::shared_ptr<T> >());
-  }
-  virtual boost::shared_ptr<T> shared_ptr_value_from_python(PyObject* obj) {
-    return BOOST_PYTHON_CONVERSION::python_extension_class_converters<T>::smart_ptr_value(obj, boost::python::type<boost::shared_ptr<T> >());
-  }
+    virtual PyObject* to_python(const T& x) {
+        PyErr_SetString(PyExc_RuntimeError,
+          "to_python(const T&) converter not exported");
+        throw import_error();
+    }
+
+    virtual T* from_python_Ts(PyObject* p, boost::python::type<T*> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const T* from_python_cTs(PyObject* p, boost::python::type<const T*> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const T* from_python_cTscr(PyObject* p, boost::python::type<const T*const&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual T* from_python_Tscr(PyObject* p, boost::python::type<T* const&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual T& from_python_Tr(PyObject* p, boost::python::type<T&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const T& from_python_cTr(PyObject* p, boost::python::type<const T&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const T& from_python_T(PyObject* p, boost::python::type<T> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+
+    virtual std::auto_ptr<T>& from_python_aTr(PyObject* p, boost::python::type<std::auto_ptr<T>&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual std::auto_ptr<T> from_python_aT(PyObject* p, boost::python::type<std::auto_ptr<T> > t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const std::auto_ptr<T>& from_python_caTr(PyObject* p, boost::python::type<const std::auto_ptr<T>&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual PyObject* to_python(std::auto_ptr<T> x) {
+        return BOOST_PYTHON_CONVERSION::to_python(x);
+    }
+
+    virtual boost::shared_ptr<T>& from_python_sTr(PyObject* p, boost::python::type<boost::shared_ptr<T>&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const boost::shared_ptr<T>& from_python_sT(PyObject* p, boost::python::type<boost::shared_ptr<T> > t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const boost::shared_ptr<T>& from_python_csTr(PyObject* p, boost::python::type<const boost::shared_ptr<T>&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual PyObject* to_python(boost::shared_ptr<T> x) {
+        return BOOST_PYTHON_CONVERSION::to_python(x);
+    }
 };
 
 // The addditional to_python() converter that can be used if T is copyable.
 template <class T>
 struct export_converter_object : export_converter_object_noncopyable<T>
 {
-  virtual PyObject* to_python(const T& x) {
-    BOOST_PYTHON_CONVERSION::python_extension_class_converters<T> cv;
-    return cv.to_python(x);
-  }
+    virtual PyObject* to_python(const T& x) {
+        return BOOST_PYTHON_CONVERSION::py_extension_class_converters(boost::python::type<T>()).to_python(x);
+    }
 };
 
 namespace detail {
 
-//QUESTIONMARK
-//  A stripped-down, modified version of class extension_class.
-//  Would it make sense to establish a formal relationship
-//  between the two classes?
+/* This class template is instantiated by import_converters<T>.
+   Its purpose is to import the converter_object via the Python API.
+   The actual import is only done once. The pointer to the
+   imported converter object is kept in the static data member
+   imported_converters.
+ */
 template <class T>
 class import_extension_class
     : public python_import_extension_class_converters<T>
@@ -237,6 +283,7 @@ import_extension_class<T>::get_converters() {
 
 namespace boost { namespace python {
 
+// Implementation of export_converters().
 template <class T, class U>
 void export_converters(class_builder<T, U>& cb)
 {
@@ -246,6 +293,7 @@ void export_converters(class_builder<T, U>& cb)
       detail::converters_attribute_name);
 }
 
+// Implementation of export_converters_noncopyable().
 template <class T, class U>
 void export_converters_noncopyable(class_builder<T, U>& cb)
 {
@@ -255,17 +303,17 @@ void export_converters_noncopyable(class_builder<T, U>& cb)
       detail::converters_attribute_name);
 }
 
+// Implementation of import_converters<T>.
 template <class T>
 class import_converters
-    : python_import_extension_class_converters<T>
+    : python_import_extension_class_converters<T> // Works around MSVC6.x/GCC2.95.2 bug described
+                                                  // at the bottom of class_builder.hpp.
 {
  public:
     import_converters(const char* module, const char* py_class)
         : m_class(new detail::import_extension_class<T>(module, py_class))
     { }
  private:
-    //QUESTIONMARK
-    //reference<detail::import_extension_class<T> > m_class;
     boost::shared_ptr<detail::import_extension_class<T> > m_class;
 };
 

include/boost/python/detail/base_object.hpp

@@ -39,7 +39,7 @@ 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)

include/boost/python/detail/config.hpp

@@ -57,7 +57,7 @@
 #  define BOOST_CSTD_ std
 # endif
 
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__CYGWIN__)
 # define BOOST_PYTHON_MODULE_INIT(name) extern "C" __declspec(dllexport) void init##name()
 #else
 # define BOOST_PYTHON_MODULE_INIT(name) extern "C" void init##name()

include/boost/python/detail/extension_class.hpp

@@ -10,6 +10,7 @@
 //  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)
 
@@ -166,6 +167,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>

include/boost/python/detail/init_function.hpp

@@ -73,7 +73,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;
   };

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>
@@ -375,8 +383,12 @@ PyObject* reprable<Base>::instance_repr(PyObject* obj) const
 
 // This macro gets the length of an array as a compile-time constant, and will
 // fail to compile if the parameter is a pointer.
+#ifdef __BORLANDC__ // smart implementation doesn't work for borland; maybe someone knows a workaround?
+# define PY_ARRAY_LENGTH(a) (sizeof(a) / sizeof((a)[0]))
+#else
 # define PY_ARRAY_LENGTH(a) \
         (sizeof(::boost::python::detail::countof_validate(a, &(a))) ? sizeof(a) / sizeof((a)[0]) : 0)
+#endif
 
   template<typename T>
   inline void countof_validate(T* const, T* const*);

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, +);

src/classes.cpp

@@ -203,7 +203,8 @@ namespace detail {
       }
       if (!BOOST_CSTD_::strcmp(name, "__reduce__"))
       {
-          ref target(as_object(this), ref::increment_count);
+          PyObject* self = as_object(this);
+          ref target(self, ref::increment_count);
           return bound_function::create(target, global_class_reduce());
       }
       
@@ -735,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
   {
@@ -746,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 },
@@ -808,7 +845,7 @@ namespace detail {
   // Enable the special handler for methods of the given name, if any.
   void enable_named_method(boost::python::detail::class_base* type_obj, const char* name)
   {
-      const std::size_t num_enablers = sizeof(enablers) / sizeof(enablers[0]);
+      const std::size_t num_enablers = PY_ARRAY_LENGTH(enablers);
 
       // Make sure this ends with "__" since we'll only compare the head of the
       // string.  This is done to make the __getattr__<name>__/__setattr__<name>__

src/conversions.cpp

@@ -7,6 +7,7 @@
 //  producing this work.
 //
 // Revision History:
+// 05 Apr 01  added: from_python std::string type checking (rwgk)
 // 12 Mar 01  Python 1.5.2 fixes (Ralf W. Grosse-Kunstleve)
 // 11 Mar 01  std::string *MAY* include nulls (Alex Martelli)
 // 04 Mar 01  std::complex<> fixes for MSVC (Dave Abrahams)
@@ -250,6 +251,10 @@ PyObject* to_python(const std::string& s)
 
 std::string from_python(PyObject* p, boost::python::type<std::string>)
 {
+    if (! PyString_Check(p)) {
+        PyErr_SetString(PyExc_TypeError, "expected a string");
+        throw boost::python::argument_error();
+    }
     return std::string(PyString_AsString(p), PyString_Size(p));
 }
 

src/cross_module.cpp

@@ -1,3 +1,13 @@
+/* (C) Copyright Ralf W. Grosse-Kunstleve 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.
+
+   Revision History:
+     17 Apr 01 merged into boost CVS trunk (Ralf W. Grosse-Kunstleve)
+*/
+
 # include <boost/python/cross_module.hpp>
 namespace python = boost::python;
 # include <stdio.h> // MSVC6.0SP4 does not know std::fprintf

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/types.cpp

@@ -159,6 +159,28 @@ 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 +428,7 @@ namespace
 bool add_capability_general(type_object_base::capability capability, PyTypeObject* dest)
 {
     assert(dest != 0);
-    
+
     switch(capability)
     {
         ENABLE_GENERAL_CAPABILITY(hash);
@@ -435,6 +457,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 +584,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 +1013,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.cpp

@@ -15,6 +15,12 @@
 #include <math.h>  // for pow()
 #include <boost/rational.hpp>
 
+#if defined(__sgi) \
+    && (   (defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730) \
+        && !defined(__GNUC__))
+inline double pow(int x, int y) { return pow(static_cast<double>(x), y); }
+#endif
+
 namespace bpl_test {
 
 FooCallback::FooCallback(PyObject* self, int x)

test/comprehensive.py

@@ -19,10 +19,13 @@ Load up the extension module
 Automatic checking of the number and type of arguments. Foo's constructor takes
 a single long parameter. 
 
-    >>> ext = Foo()
-    Traceback (innermost last):
-      File "<stdin>", line 1, in ?
-    TypeError: function requires exactly 1 argument; 0 given
+    >>> try:
+    ...     ext = Foo()
+    ... except TypeError, err:
+    ...     assert re.match(r'function .* exactly 1 argument;? \(?0 given\)?',
+    ...                     str(err))
+    ... else:
+    ...     print 'no exception'
 
     >>> try: ext = Foo('foo')
     ... except TypeError, err:
@@ -419,7 +422,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'
     
@@ -629,7 +632,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'
@@ -659,7 +662,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'
@@ -681,7 +684,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'
@@ -1014,9 +1017,12 @@ test inheritB2
     -2
     >>> str(i)
     '2'
-    >>> j = i/i
-    Traceback (innermost last):
-    TypeError: bad operand type(s) for /
+    >>> try: j = i/i
+    ... except TypeError, err:
+    ...     assert re.match(r'(bad|unsupported) operand type\(s\) for /',
+    ...                     str(err))
+    ... else: print 'no exception'
+    
     >>> j = abs(i)
     Traceback (innermost last):
     TypeError: bad operand type for abs()
@@ -1188,7 +1194,7 @@ def run(args = None):
     if args is not None:
         sys.argv = args
     import doctest, comprehensive
-    doctest.testmod(comprehensive)
+    return doctest.testmod(comprehensive)
     
 if __name__ == '__main__':
-    run()
+    sys.exit(run()[0])