Moved to python_v2_API_restructure branch

[SVN r15354]

build/filemgr.py

@@ -1,135 +0,0 @@
-# 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 + "/getting_started3.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_getting_started3.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",
-)
-
-defs = (
-"boost_python_test",
-"abstract",
-"getting_started1",
-"getting_started2",
-"getting_started3",
-"simple_vector",
-"do_it_yourself_converters",
-"pickle1",
-"pickle2",
-"pickle3",
-"noncopyable_export",
-"noncopyable_import",
-"ivect",
-"dvect",
-)
-
-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/irix_CC.mak

@@ -1,165 +0,0 @@
-# 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.0/bin/python
-#PYINC=-I/usr/local/Python-2.0/include/python2.0
-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 getting_started3.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
-
-.SUFFIXES: .o .cpp
-
-all: libboost_python.a \
-     boost_python_test.so \
-     abstract.so \
-     getting_started1.so getting_started2.so getting_started3.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
-
-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
-
-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
-
-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
-
-.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_getting_started3.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
-
-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 getting_started3.o getting_started3.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 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

@@ -1,165 +0,0 @@
-# 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/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.0/bin/python
-#PYINC=-I/usr/local/Python-2.0/include/python2.0
-
-STDOPTS=-ftemplate-depth-21
-WARNOPTS=
-OPTOPTS=-g
-
-CPP=g++
-CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
-        $(STDOPTS) $(WARNOPTS) $(OPTOPTS)
-MAKEDEP=-M
-
-LD=g++
-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 getting_started3.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
-
-.SUFFIXES: .o .cpp
-
-all: libboost_python.a \
-     boost_python_test.so \
-     abstract.so \
-     getting_started1.so getting_started2.so getting_started3.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
-
-libboost_python.a: $(OBJ)
-	rm -f libboost_python.a
-	ar r libboost_python.a $(OBJ)
-
-boost_python_test.so: $(OBJ) comprehensive.o
-	$(LD) $(LDOPTS) $(OBJ) comprehensive.o -o boost_python_test.so -lm
-
-abstract.so: $(OBJ) abstract.o
-	$(LD) $(LDOPTS) $(OBJ) abstract.o -o abstract.so
-
-getting_started1.so: $(OBJ) getting_started1.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started1.o -o getting_started1.so
-
-getting_started2.so: $(OBJ) getting_started2.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started2.o -o getting_started2.so
-
-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
-
-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
-
-.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_getting_started3.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
-
-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 getting_started3.o getting_started3.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 so_locations *.pyc
-
-softlinks:
-	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) softlinks
-
-unlink:
-	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) unlink
-
-cp:
-	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) cp
-
-rm:
-	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) rm
-
-depend:
-	@ cat Makefile.nodepend; \
-          for obj in $(DEPOBJ); \
-          do \
-            bn=`echo "$$obj" | cut -d. -f1`; \
-            $(CPP) $(CPPOPTS) $(MAKEDEP) "$$bn".cpp; \
-          done
-

build/mingw32.mak

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

build/tru64_cxx.mak

@@ -1,180 +0,0 @@
-# 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.0/bin/python
-#PYINC=-I/usr/local/Python-2.0/include/python2.0
-#STLPORTINC=-I/usr/local/STLport-4.1b3/stlport
-#STLPORTINC=-I/usr/local/STLport-4.1b4/stlport
-#STLPORTOPTS= \
-# -D__USE_STD_IOSTREAM \
-# -D__STL_NO_SGI_IOSTREAMS \
-# -D__STL_USE_NATIVE_STRING \
-# -D__STL_NO_NEW_C_HEADERS \
-# -D_RWSTD_COMPILE_INSTANTIATE=1
-STLPORTINC=-I$(BOOST)/boost/compatibility/cpp_c_headers
-
-STDOPTS=-std strict_ansi
-# use -msg_display_number to obtain integer tags for -msg_disable
-WARNOPTS=-msg_disable 186,450,1115
-OPTOPTS=-g
-
-CPP=cxx
-CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
-        $(STDOPTS) $(WARNOPTS) $(OPTOPTS)
-MAKEDEP=-Em
-
-LD=cxx
-LDOPTS=-shared -expect_unresolved 'Py*' -expect_unresolved '_Py*'
-
-#HIDDEN=-hidden
-
-OBJ=classes.o conversions.o 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 getting_started3.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
-
-.SUFFIXES: .o .cpp
-
-all: libboost_python.a \
-     boost_python_test.so \
-     abstract.so \
-     getting_started1.so getting_started2.so getting_started3.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
-
-libboost_python.a: $(OBJ)
-	rm -f libboost_python.a
-	cd cxx_repository; \
-          ls -1 > ../libboost_python.a.input; \
-          ar r ../libboost_python.a -input ../libboost_python.a.input
-	rm -f libboost_python.a.input
-	ar r libboost_python.a $(OBJ)
-
-boost_python_test.so: $(OBJ) comprehensive.o
-	$(LD) $(LDOPTS) $(OBJ) comprehensive.o -o boost_python_test.so -lm
-
-abstract.so: $(OBJ) abstract.o
-	$(LD) $(LDOPTS) $(OBJ) abstract.o -o abstract.so
-
-getting_started1.so: $(OBJ) getting_started1.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started1.o -o getting_started1.so
-
-getting_started2.so: $(OBJ) getting_started2.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started2.o -o getting_started2.so
-
-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
-
-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
-
-.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_getting_started3.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
-
-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 getting_started3.o getting_started3.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 so_locations *.pyc
-	rm -rf cxx_repository
-
-softlinks:
-	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) softlinks
-
-unlink:
-	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) unlink
-
-cp:
-	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) cp
-
-rm:
-	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) rm
-
-depend:
-	@ cat Makefile.nodepend; \
-          for obj in $(DEPOBJ); \
-          do \
-            bn=`echo "$$obj" | cut -d. -f1`; \
-            $(CPP) $(CPPOPTS) $(MAKEDEP) "$$bn".cpp; \
-          done
-

build/vc60.mak

@@ -1,133 +0,0 @@
-# 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"
-
-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 getting_started3.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
-
-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"
-
-getting_started3.pyd: $(OBJ) getting_started3.obj
-	$(LD) $(LDOPTS) $(OBJ) getting_started3.obj $(PYLIB) /export:initgetting_started3 /out:"getting_started3.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"
-
-.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_getting_started3.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
-
-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/cross_module_dependencies.html

@@ -1,336 +0,0 @@
-<!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/pickle.html

@@ -1,272 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
-"http://www.w3.org/TR/REC-html40/strict.dtd">
-
-<title>Boost.Python Pickle Support</title>
-
-<div>
-
-<img src="../../../c++boost.gif"
-     alt="c++boost.gif (8819 bytes)"
-     align="center"
-     width="277" height="86">
-
-<hr>
-<h1>Boost.Python Pickle Support</h1>
-
-Pickle is a Python module for object serialization, also known
-as persistence, marshalling, or flattening.
-
-<p>
-It is often necessary to save and restore the contents of an object to
-a file. One approach to this problem is to write a pair of functions
-that read and write data from a file in a special format. A powerful
-alternative approach is to use Python's pickle module. Exploiting
-Python's ability for introspection, the pickle module recursively
-converts nearly arbitrary Python objects into a stream of bytes that
-can be written to a file.
-
-<p>
-The Boost Python Library supports the pickle module by emulating the
-interface implemented by Jim Fulton's ExtensionClass module that is
-included in the
-<a href="http://www.zope.org/"
->ZOPE</a>
-distribution.
-This interface is similar to that for regular Python classes as
-described in detail in the
-<a href="http://www.python.org/doc/current/lib/module-pickle.html"
->Python Library Reference for pickle.</a>
-
-<hr>
-<h2>The Boost.Python Pickle Interface</h2>
-
-At the user level, the Boost.Python pickle interface involves three special
-methods:
-
-<dl>
-<dt>
-<strong><tt>__getinitargs__</tt></strong>
-<dd>
-  When an instance of a Boost.Python extension class is pickled, the
-  pickler tests if the instance has a <tt>__getinitargs__</tt> method.
-  This method must return a Python tuple (it is most convenient to use
-  a boost::python::tuple). When the instance is restored by the
-  unpickler, the contents of this tuple are used as the arguments for
-  the class constructor.
-
-  <p>
-  If <tt>__getinitargs__</tt> is not defined, the class constructor
-  will be called without arguments.
-
-<p>
-<dt>
-<strong><tt>__getstate__</tt></strong>
-
-<dd>
-  When an instance of a Boost.Python extension class is pickled, the
-  pickler tests if the instance has a <tt>__getstate__</tt> method.
-  This method should return a Python object representing the state of
-  the instance.
-
-  <p>
-  If <tt>__getstate__</tt> is not defined, the instance's
-  <tt>__dict__</tt> is pickled (if it is not empty).
-
-<p>
-<dt>
-<strong><tt>__setstate__</tt></strong>
-
-<dd>
-  When an instance of a Boost.Python extension class is restored by the
-  unpickler, it is first constructed using the result of
-  <tt>__getinitargs__</tt> as arguments (see above). Subsequently the
-  unpickler tests if the new instance has a <tt>__setstate__</tt>
-  method. If so, this method is called with the result of
-  <tt>__getstate__</tt> (a Python object) as the argument.
-
-  <p>
-  If <tt>__setstate__</tt> is not defined, the result of
-  <tt>__getstate__</tt> must be a Python dictionary. The items of this
-  dictionary are added to the instance's <tt>__dict__</tt>.
-
-</dl>
-
-If both <tt>__getstate__</tt> and <tt>__setstate__</tt> are defined,
-the Python object returned by <tt>__getstate__</tt> need not be a
-dictionary. The <tt>__getstate__</tt> and <tt>__setstate__</tt> methods
-can do what they want.
-
-<hr>
-<h2>Pitfalls and Safety Guards</h2>
-
-In Boost.Python extension modules with many extension classes,
-providing complete pickle support for all classes would be a
-significant overhead. In general complete pickle support should only be
-implemented for extension classes that will eventually be pickled.
-However, the author of a Boost.Python extension module might not
-anticipate correctly which classes need support for pickle.
-Unfortunately, the pickle protocol described above has two important
-pitfalls that the end user of a Boost.Python extension module might not
-be aware of:
-
-<dl>
-<dt>
-<strong>Pitfall 1:</strong>
-Both <tt>__getinitargs__</tt> and <tt>__getstate__</tt> are not defined.
-
-<dd>
-  In this situation the unpickler calls the class constructor without
-  arguments and then adds the <tt>__dict__</tt> that was pickled by
-  default to that of the new instance.
-
-  <p>
-  However, most C++ classes wrapped with Boost.Python will have member
-  data that are not restored correctly by this procedure. To alert the
-  user to this problem, a safety guard is provided. If both
-  <tt>__getinitargs__</tt> and <tt>__getstate__</tt> are not defined,
-  Boost.Python tests if the class has an attribute
-  <tt>__dict_defines_state__</tt>. An exception is raised if this
-  attribute is not defined:
-
-<pre>
-    RuntimeError: Incomplete pickle support (__dict_defines_state__ not set)
-</pre>
-
-  In the rare cases where this is not the desired behavior, the safety
-  guard can deliberately be disabled. The corresponding C++ code for
-  this is, e.g.:
-
-<pre>
-    class_builder&lt;your_class&gt; py_your_class(your_module, "your_class");
-    py_your_class.dict_defines_state();
-</pre>
-
-  It is also possible to override the safety guard at the Python level.
-  E.g.:
-
-<pre>
-    import your_bpl_module
-    class your_class(your_bpl_module.your_class):
-      __dict_defines_state__ = 1
-</pre>
-
-<p>
-<dt>
-<strong>Pitfall 2:</strong>
-<tt>__getstate__</tt> is defined and the instance's <tt>__dict__</tt> is not empty.
-
-<dd>
-  The author of a Boost.Python extension class might provide a
-  <tt>__getstate__</tt> method without considering the possibilities
-  that:
-
-  <p>
-  <ul>
-  <li>
-    his class is used in Python as a base class. Most likely the
-    <tt>__dict__</tt> of instances of the derived class needs to be
-    pickled in order to restore the instances correctly.
-
-  <p>
-  <li>
-    the user adds items to the instance's <tt>__dict__</tt> directly.
-    Again, the <tt>__dict__</tt> of the instance then needs to be
-    pickled.
-
-  </ul>
-  <p>
-
-  To alert the user to this highly unobvious problem, a safety guard is
-  provided. If <tt>__getstate__</tt> is defined and the instance's
-  <tt>__dict__</tt> is not empty, Boost.Python tests if the class has
-  an attribute <tt>__getstate_manages_dict__</tt>. An exception is
-  raised if this attribute is not defined:
-
-<pre>
-    RuntimeError: Incomplete pickle support (__getstate_manages_dict__ not set)
-</pre>
-
-  To resolve this problem, it should first be established that the
-  <tt>__getstate__</tt> and <tt>__setstate__</tt> methods manage the
-  instances's <tt>__dict__</tt> correctly. Note that this can be done
-  both at the C++ and the Python level. Finally, the safety guard
-  should intentionally be overridden.  E.g. in C++:
-
-<pre>
-    class_builder&lt;your_class&gt; py_your_class(your_module, "your_class");
-    py_your_class.getstate_manages_dict();
-</pre>
-
-  In Python:
-
-<pre>
-    import your_bpl_module
-    class your_class(your_bpl_module.your_class):
-      __getstate_manages_dict__ = 1
-      def __getstate__(self):
-        # your code here
-      def __setstate__(self, state):
-        # your code here
-</pre>
-</dl>
-
-<hr>
-<h2>Practical Advice</h2>
-
-<ul>
-<li>
-  Avoid using <tt>__getstate__</tt> if the instance can also be
-  reconstructed by way of <tt>__getinitargs__</tt>. This automatically
-  avoids Pitfall 2.
-
-<p>
-<li>
-  If <tt>__getstate__</tt> is required, include the instance's
-  <tt>__dict__</tt> in the Python object that is returned.
-
-</ul>
-
-<hr>
-<h2>Examples</h2>
-
-There are three files in <tt>boost/libs/python/example</tt> that
-show how so provide pickle support.
-
-<h3><a href="../example/pickle1.cpp"><tt>pickle1.cpp</tt></a></h3>
-
-    The C++ class in this example can be fully restored by passing the
-    appropriate argument to the constructor. Therefore it is sufficient
-    to define the pickle interface method <tt>__getinitargs__</tt>.
-
-<h3><a href="../example/pickle2.cpp"><tt>pickle2.cpp</tt></a></h3>
-
-    The C++ class in this example contains member data that cannot be
-    restored by any of the constructors. Therefore it is necessary to
-    provide the <tt>__getstate__</tt>/<tt>__setstate__</tt> pair of
-    pickle interface methods.
-
-    <p>
-    For simplicity, the <tt>__dict__</tt> is not included in the result
-    of <tt>__getstate__</tt>. This is not generally recommended, but a
-    valid approach if it is anticipated that the object's
-    <tt>__dict__</tt> will always be empty. Note that the safety guards
-    will catch the cases where this assumption is violated.
-
-<h3><a href="../example/pickle3.cpp"><tt>pickle3.cpp</tt></a></h3>
-
-    This example is similar to <a
-    href="../example/pickle2.cpp"><tt>pickle2.cpp</tt></a>. However, the
-    object's <tt>__dict__</tt> is included in the result of
-    <tt>__getstate__</tt>.  This requires more code but is unavoidable
-    if the object's <tt>__dict__</tt> is not always empty.
-
-<hr>
-&copy; Copyright Ralf W. Grosse-Kunstleve 2001. Permission to copy,
-use, modify, sell and distribute this document is granted provided this
-copyright notice appears in all copies. This document is provided "as
-is" without express or implied warranty, and with no claim as to its
-suitability for any purpose.
-
-<p>
-Updated: March 21, 2001
-</div>

example/do_it_yourself_converters.cpp

@@ -1,126 +0,0 @@
-/*
-   This example shows how to convert a class from and to native
-   Python objects, such as tuples.
-
-   We do not want to expose the helper class MillerIndex as an
-   Extension Class. However, in order to simplify the wrapper code,
-   we want to define from_python() and to_python() functions for
-   class MillerIndex.
-
-   Consider the alternatives:
-
-     - Expose MillerIndex as an Extension Class.
-         We need a constructor MillerIndex(python::tuple).
-         Python function calls become more complex:
-           foo(MillerIndex((1,2,3)) instead of foo((1,2,3))
-         We need a method such as MillerIndex().as_tuple().
-
-     - Define a wrapper function for each function that we
-       want to expose, e.g.:
-          void add(const IndexingSet& ixset, const python::tuple PyMIx)
-
-   The first alternative introduces a new type that the user has to
-   deal with. Other modules using Miller indices might organize them in
-   different ways, for example to increase runtime efficiency for
-   important procedures. This means, the user has to know how to
-   convert between the different kinds of Miller index representations.
-   This can quickly become a nuisance. Relying on native Python data
-   structures minimizes the number of special types the user has to
-   learn and convert. Of course, this argument is only valid for
-   small and relatively simply classes.
-
-   If there are many member functions with MillerIndex arguments, the
-   second alternative is impractical, and concentrating the conversion
-   mechanism in one central place is essential for code
-   maintainability.  An added benefit is that more convenient (smarter)
-   conversion functions can be provided without cluttering the rest of
-   the wrapper code.
-
- */
-
-#include <string>
-#include <vector>
-#include <boost/python/class_builder.hpp>
-namespace python = boost::python;
-
-namespace { // Avoid cluttering the global namespace.
-
-  // The helper class.
-  //
-  class MillerIndex {
-    public:
-      int v[3];
-  };
-
-  // The main class. Imagine that there are MANY member functions
-  // like add() and get().
-  //
-  class IndexingSet {
-    private:
-      std::vector<MillerIndex> VMIx;
-    public:
-      void add(const MillerIndex& MIx) { VMIx.push_back(MIx); }
-      MillerIndex get(std::size_t i) const { return VMIx[i]; }
-  };
-}
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-  // Convert a Python tuple to a MillerIndex object.
-  //
-  MillerIndex from_python(PyObject* p, python::type<const MillerIndex&>)
-  {
-    python::tuple tup
-      = python::tuple(python::ref(p, python::ref::increment_count));
-    if (tup.size() != 3) {
-      PyErr_SetString(PyExc_ValueError,
-        "expecting exactly 3 values in tuple.");
-      throw python::error_already_set();
-    }
-    MillerIndex result;
-    for (int i = 0; i < 3; i++)
-      result.v[i] = from_python(tup[i].get(), python::type<int>());
-    return result;
-  }
-
-  // Similar conversion for MillerIndex objects passed by value.
-  // Not actually used, but included to show the principle.
-  //
-  MillerIndex from_python(PyObject* p, python::type<MillerIndex>)
-  {
-    return from_python(p, python::type<const MillerIndex&>());
-  }
-
-  // Convert a MillerIndex object to a Python tuple.
-  //
-  PyObject* to_python(const MillerIndex& hkl)
-  {
-    python::tuple result(3);
-    for (int i = 0; i < 3; i++)
-      result.set_item(i, python::ref(to_python(hkl.v[i])));
-    return result.reference().release();
-  }
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-BOOST_PYTHON_MODULE_INIT(do_it_yourself_converters)
-{
-  try
-  {
-    // Create an object representing this extension module.
-    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");
-
-    // Add the __init__ function.
-    ixset_class.def(python::constructor<>());
-    // Add the member functions.
-    ixset_class.def(&IndexingSet::add, "add");
-    ixset_class.def(&IndexingSet::get, "get");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}

example/dvect.cpp

@@ -1,42 +0,0 @@
-#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;
-  }
-}
-
-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

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

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

@@ -1,13 +0,0 @@
-    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/ivect.cpp

@@ -1,42 +0,0 @@
-#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;
-  }
-}
-
-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

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

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

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

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

@@ -1,22 +0,0 @@
-#include <boost/python/cross_module.hpp>
-namespace python = boost::python;
-
-#include "noncopyable.h"
-
-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

@@ -1,39 +0,0 @@
-#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;
-  }
-}
-
-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

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

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

@@ -1,148 +0,0 @@
-/*
-    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::argument_error();
-      }
-      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::argument_error();
-      }
-      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/simple_vector.cpp

@@ -1,101 +0,0 @@
-#include <boost/python/class_builder.hpp>
-namespace python = boost::python;
-
-namespace { // Avoid cluttering the global namespace.
-
-  // A wrapper is used to define additional constructors.
-  //
-  struct vector_double_wrapper: std::vector<double>
-  {
-    // Tell the compiler how to convert a base class object to
-    // this wrapper object.
-    vector_double_wrapper(PyObject*, const std::vector<double>& vd)
-      : std::vector<double>(vd) {}
-
-    vector_double_wrapper(PyObject* self)
-      : std::vector<double>() {}
-
-    vector_double_wrapper(PyObject* self, int n)
-      : std::vector<double>(n) {}
-
-    vector_double_wrapper(PyObject* self, python::tuple tuple)
-      : std::vector<double>(tuple.size())
-    {
-      std::vector<double>::iterator vd = begin();
-      for (int i = 0; i < tuple.size(); i++)
-        vd[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
-          python::type<double>());
-    }
-  };
-
-  double getitem(const std::vector<double>& vd, std::size_t key) {
-    return vd[key];
-  }
-
-  void setitem(std::vector<double>& vd, std::size_t key, double d) {
-    std::vector<double>::iterator vditer = vd.begin();
-    vditer[key] = d;
-  }
-
-  void delitem(std::vector<double>& vd, std::size_t key) {
-    std::vector<double>::iterator vditer = vd.begin();
-    vd.erase(&vditer[key]);
-  }
-
-  // Convert vector_double to a regular Python tuple.
-  //
-  python::tuple as_tuple(const std::vector<double>& vd)
-  {
-    python::tuple t(vd.size());
-    for (int i = 0; i < vd.size(); i++) t.set_item(i,
-      python::ref(BOOST_PYTHON_CONVERSION::to_python(vd[i])));
-    return t;
-  }
-
-  // Function returning a vector_double object to Python.
-  //
-  std::vector<double> foo(int n)
-  {
-    std::vector<double> vd(n);
-    std::vector<double>::iterator vditer = vd.begin();
-    for (int i = 0; i < n; i++) vditer[i] = double(i);
-    return vd;
-  }
-
-  // Same as foo(), but avoid copying on return.
-  //
-  std::auto_ptr<std::vector<double> > bar(int n)
-  {
-    std::auto_ptr<std::vector<double> > vdptr(new std::vector<double>(n));
-    std::vector<double>::iterator vditer = vdptr->begin();
-    for (int i = 0; i < n; i++) vditer[i] = double(10 * i);
-    return vdptr;
-  }
-}
-
-BOOST_PYTHON_MODULE_INIT(simple_vector)
-{
-  try
-  {
-    python::module_builder this_module("simple_vector");
-
-    python::class_builder<std::vector<double>, vector_double_wrapper>
-      vector_double(this_module, "vector_double");
-
-    vector_double.def(python::constructor<>());
-    vector_double.def(python::constructor<const int>());
-    vector_double.def(python::constructor<python::tuple>());
-    vector_double.def(&std::vector<double>::size, "__len__");
-    vector_double.def(getitem, "__getitem__");
-    vector_double.def(setitem, "__setitem__");
-    vector_double.def(delitem, "__delitem__");
-    vector_double.def(as_tuple, "as_tuple");
-
-    this_module.def(foo, "foo");
-    this_module.def(bar, "bar");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}

example/swap_iv_dv.sh

@@ -1 +0,0 @@
-sed 's/iv/xv/g' $1 | sed 's/dv/iv/g' | sed 's/xv/dv/g'

example/test_do_it_yourself_converters.py

@@ -1,22 +0,0 @@
-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))
-    >>> print ixset.get(0)
-    (1, 2, 3)
-    >>> print ixset.get(1)
-    (4, 5, 6)
-    >>> print ixset.get(2)
-    (7, 8, 9)
-'''
-
-def run(args = None):
-    if args is not None:
-        import sys
-        sys.argv = args
-    import doctest, test_do_it_yourself_converters
-    doctest.testmod(test_do_it_yourself_converters)
-
-if __name__ == '__main__':
-    run()

example/test_pickle1.py

@@ -1,31 +0,0 @@
-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
-    doctest.testmod(test_pickle1)
-
-if __name__ == '__main__':
-    run()

example/test_pickle3.py

@@ -1,38 +0,0 @@
-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.__dict__
-    ...   print wl.greet(), wl.get_secret_number(), wl.__dict__
-    Hello from California! 24 {'z': 72.0, 'x': 48, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyy'}
-    Hello from California! 24 {'z': 72.0, 'x': 48, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyy'}
-    Hello from California! 42 {'z': 126.0, 'x': 84, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'}
-    Hello from California! 0 {'z': 126.0, 'x': 84, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'}
-'''
-
-def run(args = None):
-    if args is not None:
-        import sys
-        sys.argv = args
-    import doctest, test_pickle3
-    doctest.testmod(test_pickle3)
-
-if __name__ == '__main__':
-    run()

example/test_simple_vector.py

@@ -1,35 +0,0 @@
-r'''>>> import simple_vector
-    >>> v=simple_vector.vector_double()
-    >>> print v.as_tuple()
-    ()
-    >>> 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=simple_vector.vector_double((3,4,5))
-    >>> print v.as_tuple()
-    (3.0, 4.0, 5.0)
-    >>> print v[1]
-    4.0
-    >>> v[1] = 40
-    >>> print v.as_tuple()
-    (3.0, 40.0, 5.0)
-    >>> del v[1]
-    >>> print v.as_tuple()
-    (3.0, 5.0)
-    >>> 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 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)
-'''
-
-def run(args = None):
-    if args is not None:
-        import sys
-        sys.argv = args
-    import doctest, test_simple_vector
-    doctest.testmod(test_simple_vector)
-
-if __name__ == '__main__':
-    run()

example/tst_dvect1.py

@@ -1,23 +0,0 @@
-def f():
-  import dvect
-  print dvect.dvect.__converters__
-  dv = dvect.dvect((1,2,3,4,5))
-  print dv
-  print dv.as_tuple()
-  iv = dv.as_ivect()
-  print iv
-  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

@@ -1,98 +0,0 @@
-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):
-    if (sys.argv[1] == "--broken-auto-ptr"):
-      broken_auto_ptr = 1
-      if (len(sys.argv) > 2):
-        n = string.atoi(sys.argv[2])
-    else:
-      n = string.atoi(sys.argv[1])
-  for i in xrange(n):
-    f(broken_auto_ptr)

example/tst_ivect1.py

@@ -1,23 +0,0 @@
-def f():
-  import ivect
-  print ivect.ivect.__converters__
-  iv = ivect.ivect((1,2,3,4,5))
-  print iv
-  print iv.as_tuple()
-  dv = iv.as_dvect()
-  print dv
-  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

@@ -1,98 +0,0 @@
-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):
-    if (sys.argv[1] == "--broken-auto-ptr"):
-      broken_auto_ptr = 1
-      if (len(sys.argv) > 2):
-        n = string.atoi(sys.argv[2])
-    else:
-      n = string.atoi(sys.argv[1])
-  for i in xrange(n):
-    f(broken_auto_ptr)

example/tst_noncopyable.py

@@ -1,8 +0,0 @@
-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()

include/boost/python/arg_from_python.hpp

@@ -0,0 +1,52 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef ARG_FROM_PYTHON_DWA2002128_HPP
+# define ARG_FROM_PYTHON_DWA2002128_HPP
+
+# include <boost/python/converter/arg_from_python.hpp>
+
+namespace boost { namespace python { 
+
+template <class T>
+struct arg_from_python
+    : converter::select_arg_from_python<T>::type
+{
+    typedef typename converter::select_arg_from_python<T>::type base;
+    arg_from_python(PyObject*);
+};
+
+// specialization for PyObject*
+template <>
+struct arg_from_python<PyObject*>
+{
+    typedef PyObject* result_type;
+    
+    arg_from_python(PyObject*) {}
+    bool convertible() const { return true; }
+    PyObject* operator()(PyObject* source) const { return source; }
+};
+
+template <>
+struct arg_from_python<PyObject* const&>
+{
+    typedef PyObject* const& result_type;
+    arg_from_python(PyObject*) {}
+    bool convertible() const { return true; }
+    PyObject*const& operator()(PyObject*const& source) const { return source; }
+};
+
+//
+// implementations
+//
+template <class T>
+inline arg_from_python<T>::arg_from_python(PyObject* source)
+    : base(source)
+{
+}
+
+}} // namespace boost::python
+
+#endif // ARG_FROM_PYTHON_DWA2002128_HPP

include/boost/python/args.hpp

@@ -0,0 +1,34 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef ARGS_DWA2002323_HPP
+# define ARGS_DWA2002323_HPP
+#  include <boost/config.hpp>
+#  include <boost/python/detail/preprocessor.hpp>
+#  include <boost/python/detail/type_list.hpp>
+
+namespace boost { namespace python {
+
+enum no_init_t { no_init };
+
+namespace detail
+{
+  template <class Args>
+  struct args_base {};
+}
+}}
+
+namespace boost { namespace python {
+
+// A type list for specifying arguments
+template < BOOST_PYTHON_ENUM_WITH_DEFAULT(BOOST_PYTHON_MAX_ARITY, typename A, mpl::void_) >
+struct args : detail::args_base<args<BOOST_PYTHON_UNARY_ENUM(BOOST_PYTHON_MAX_ARITY, A)> >
+      , detail::type_list< BOOST_PYTHON_UNARY_ENUM(BOOST_PYTHON_MAX_ARITY, A) >::type
+{};
+
+}} // namespace boost::python
+
+
+# endif // ARGS_DWA2002323_HPP

include/boost/python/back_reference.hpp

@@ -0,0 +1,101 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef BACK_REFERENCE_DWA2002510_HPP
+# define BACK_REFERENCE_DWA2002510_HPP
+
+# include <boost/python/object_fwd.hpp>
+# include <boost/python/detail/dependent.hpp>
+# include <boost/python/detail/raw_pyobject.hpp>
+
+namespace boost { namespace python { 
+
+template <class T>
+struct back_reference
+{
+ private: // types
+    typedef typename detail::dependent<object,T>::type source_t;
+ public:
+    typedef T type;
+    
+    back_reference(PyObject*, T);
+    source_t const& source() const;
+    T get() const;
+ private:
+    source_t m_source;
+    T m_value;
+};
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template<typename T>
+class is_back_reference
+{
+ public:
+    BOOST_STATIC_CONSTANT(bool, value = false); 
+};
+
+template<typename T>
+class is_back_reference<back_reference<T> >
+{
+ public:
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+# else // no partial specialization
+
+}} // namespace boost::python
+
+#include <boost/type.hpp>
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  typedef char (&yes_back_reference_t)[1];
+  typedef char (&no_back_reference_t)[2];
+      
+  no_back_reference_t is_back_reference_test(...);
+
+  template<typename T>
+  yes_back_reference_t is_back_reference_test(boost::type< back_reference<T> >);
+}
+
+template<typename T>
+class is_back_reference
+{
+ public:
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            sizeof(detail::is_back_reference_test(boost::type<T>()))
+            == sizeof(detail::yes_back_reference_t)));
+};
+
+# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+//
+// implementations
+//
+template <class T>
+back_reference<T>::back_reference(PyObject* p, T x)
+    : m_source(detail::borrowed_reference(p))
+      , m_value(x)
+{
+}
+
+template <class T>
+typename back_reference<T>::source_t const& back_reference<T>::source() const
+{
+    return m_source;
+}
+
+template <class T>
+T back_reference<T>::get() const
+{
+    return m_value;
+}
+
+}} // namespace boost::python
+
+#endif // BACK_REFERENCE_DWA2002510_HPP

include/boost/python/base_type_traits.hpp

@@ -0,0 +1,36 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef BASE_TYPE_TRAITS_DWA2002614_HPP
+# define BASE_TYPE_TRAITS_DWA2002614_HPP
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  struct unspecialized {};
+}
+
+// Derive from unspecialized so we can detect whether traits are
+// specialized
+template <class T> struct base_type_traits
+  : detail::unspecialized
+{};
+
+template <>
+struct base_type_traits<PyObject>
+{
+    typedef PyObject type;
+};
+
+template <>
+struct base_type_traits<PyTypeObject>
+{
+    typedef PyObject type;
+};
+
+}} // namespace boost::python
+
+#endif // BASE_TYPE_TRAITS_DWA2002614_HPP

include/boost/python/bases.hpp

@@ -0,0 +1,60 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef BASES_DWA2002321_HPP
+# define BASES_DWA2002321_HPP
+# include <boost/type_traits/object_traits.hpp>
+# include <boost/python/detail/type_list.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/preprocessor/enum_params_with_a_default.hpp>
+# include <boost/preprocessor/enum_params.hpp>
+
+namespace boost { namespace python { 
+
+  // A type list for specifying bases
+  template < BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PYTHON_MAX_BASES, typename B, mpl::void_) >
+  struct bases : detail::type_list< BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, B) >::type
+  {};
+
+  namespace detail
+  {
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    template <class T> struct specifies_bases
+    {
+        BOOST_STATIC_CONSTANT(bool, value = false);
+    };
+    template < BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, class B) >
+    struct specifies_bases< bases< BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, B) > >
+    {
+        BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+# else
+    template < BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, class B) >
+    static char is_bases_helper(bases< BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, B) > const&);
+    
+    static char (& is_bases_helper(...) )[256];
+
+    template <class T> struct specifies_bases
+    {
+     private:
+        static typename add_reference<T>::type make();
+        BOOST_STATIC_CONSTANT(bool, non_ref = !is_reference<T>::value);
+     public:
+        BOOST_STATIC_CONSTANT(bool, value = non_ref & (sizeof(is_bases_helper(make())) == 1));
+    };
+# endif
+    template <class T, class Prev = bases<> >
+    struct select_bases
+        : mpl::if_c<
+                specifies_bases<T>::value
+                , T
+                , Prev
+          >
+    {
+    };
+  }
+}} // namespace boost::python
+
+#endif // BASES_DWA2002321_HPP

include/boost/python/borrowed.hpp

@@ -0,0 +1,20 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef BORROWED_DWA2002614_HPP
+# define BORROWED_DWA2002614_HPP
+# include <boost/python/detail/borrowed_ptr.hpp>
+
+namespace boost { namespace python { 
+
+template <class T>
+inline python::detail::borrowed<T>* borrowed(T* p)
+{
+    return (detail::borrowed<T>*)p;
+}
+    
+}} // namespace boost::python
+
+#endif // BORROWED_DWA2002614_HPP

include/boost/python/call.hpp

@@ -0,0 +1,64 @@
+#if !defined(BOOST_PP_IS_ITERATING)
+
+// Copyright David Abrahams 2002. 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.
+
+# ifndef CALL_DWA2002411_HPP
+#  define CALL_DWA2002411_HPP
+
+#  include <boost/type.hpp>
+
+#  include <boost/python/converter/arg_to_python.hpp>
+#  include <boost/python/converter/return_from_python.hpp>
+#  include <boost/python/detail/preprocessor.hpp>
+#  include <boost/python/detail/void_return.hpp>
+
+#  include <boost/preprocessor/comma_if.hpp>
+#  include <boost/preprocessor/iterate.hpp>
+#  include <boost/preprocessor/repeat.hpp>
+#  include <boost/preprocessor/debug/line.hpp>
+
+namespace boost { namespace python {
+
+# define BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET(z, n, _) \
+    , converter::arg_to_python<A##n>(a##n).get()
+
+#  define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/call.hpp>))
+#  include BOOST_PP_ITERATE()
+
+#  undef BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET
+
+}} // namespace boost::python
+
+# endif // CALL_DWA2002411_HPP
+
+#elif BOOST_PP_ITERATION_DEPTH() == 1
+# line BOOST_PP_LINE(__LINE__, call.hpp)
+
+# define N BOOST_PP_ITERATION()
+
+template <
+    class R
+    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_BINARY_ENUM(N, A, const& a)
+    , boost::type<R>* = 0
+    )
+{
+    converter::return_from_python<R> converter;
+    return converter(
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_FIXED, "O") ")")
+            BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET, nil)
+            ));
+}
+
+# undef N
+
+#endif

include/boost/python/call_method.hpp

@@ -0,0 +1,64 @@
+#if !defined(BOOST_PP_IS_ITERATING)
+
+// Copyright David Abrahams 2002. 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.
+# ifndef CALL_METHOD_DWA2002411_HPP
+#  define CALL_METHOD_DWA2002411_HPP
+
+#  include <boost/type.hpp>
+
+#  include <boost/python/converter/arg_to_python.hpp>
+#  include <boost/python/converter/return_from_python.hpp>
+#  include <boost/python/detail/preprocessor.hpp>
+#  include <boost/python/detail/void_return.hpp>
+
+#  include <boost/preprocessor/comma_if.hpp>
+#  include <boost/preprocessor/iterate.hpp>
+#  include <boost/preprocessor/repeat.hpp>
+#  include <boost/preprocessor/debug/line.hpp>
+
+namespace boost { namespace python {
+
+# define BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET(z, n, _) \
+    , converter::arg_to_python<A##n>(a##n).get()
+
+# define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/call_method.hpp>))
+# include BOOST_PP_ITERATE()
+
+# undef BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET
+
+}} // namespace boost::python
+
+# endif // CALL_METHOD_DWA2002411_HPP
+
+#elif BOOST_PP_ITERATION_DEPTH() == 1
+# line BOOST_PP_LINE(__LINE__, call_method.hpp)
+
+# define N BOOST_PP_ITERATION()
+
+template <
+    class R
+    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_BINARY_ENUM(N, A, const& a)
+    , boost::type<R>* = 0
+    )
+{
+    converter::return_from_python<R> converter;
+    return converter(
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_FIXED, "O") ")")
+            BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET, nil)
+            ));
+}
+
+# undef N
+
+#endif // BOOST_PP_IS_ITERATING

include/boost/python/callback.hpp

@@ -0,0 +1,829 @@
+//  (C) Copyright David Abrahams 2000. 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.
+//
+//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
+//  producing this work.
+//
+//  This file was generated for 10-argument python callbacks by gen_callback.python
+
+#ifndef CALLBACK_DWA_052100_H_
+# define CALLBACK_DWA_052100_H_
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/conversions.hpp>
+
+namespace boost { namespace python {
+
+namespace detail {
+  template <class T>
+  inline void callback_adjust_refcount(PyObject*, type<T>) {}
+  
+  inline void callback_adjust_refcount(PyObject* p, type<PyObject*>)
+      { Py_INCREF(p); }
+}
+
+// Calling Python from C++
+template <class R>
+struct callback
+{
+    static R call_method(PyObject* self, const char* name)
+    {
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("()")));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    static R call(PyObject* self)
+    {
+        ref result(PyEval_CallFunction(self, const_cast<char*>("()")));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1>
+    static R call_method(PyObject* self, const char* name, const A1& a1)
+    {
+        ref p1(to_python(a1));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(O)"),
+                                     p1.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1>
+    static R call(PyObject* self, const A1& a1)
+    {
+        ref p1(to_python(a1));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(O)"),
+                                       p1.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OO)"),
+                                     p1.get(),
+                                     p2.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2>
+    static R call(PyObject* self, const A1& a1, const A2& a2)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OO)"),
+                                       p1.get(),
+                                       p2.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3>
+    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4>
+    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5>
+    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6>
+    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get(),
+                                     p7.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get(),
+                                       p7.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get(),
+                                     p7.get(),
+                                     p8.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get(),
+                                       p7.get(),
+                                       p8.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get(),
+                                     p7.get(),
+                                     p8.get(),
+                                     p9.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get(),
+                                       p7.get(),
+                                       p8.get(),
+                                       p9.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
+    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref p10(to_python(a10));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get(),
+                                     p7.get(),
+                                     p8.get(),
+                                     p9.get(),
+                                     p10.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
+    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref p10(to_python(a10));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get(),
+                                       p7.get(),
+                                       p8.get(),
+                                       p9.get(),
+                                       p10.get()));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
+    }
+};
+
+// This specialization wouldn't be needed, but MSVC6 doesn't correctly allow the following:
+// void g();
+// void f() { return g(); }
+template <>
+struct callback<void>
+{
+
+    static void call_method(PyObject* self, const char* name)
+    {
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("()")));
+    }
+
+    static void call(PyObject* self)
+    {
+        ref result(PyEval_CallFunction(self, const_cast<char*>("()")));
+    }
+
+    template <class A1>
+    static void call_method(PyObject* self, const char* name, const A1& a1)
+    {
+        ref p1(to_python(a1));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(O)"),
+                                     p1.get()));
+    }
+
+    template <class A1>
+    static void call(PyObject* self, const A1& a1)
+    {
+        ref p1(to_python(a1));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(O)"),
+                                       p1.get()));
+    }
+
+    template <class A1, class A2>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OO)"),
+                                     p1.get(),
+                                     p2.get()));
+    }
+
+    template <class A1, class A2>
+    static void call(PyObject* self, const A1& a1, const A2& a2)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OO)"),
+                                       p1.get(),
+                                       p2.get()));
+    }
+
+    template <class A1, class A2, class A3>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get()));
+    }
+
+    template <class A1, class A2, class A3>
+    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4>
+    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5>
+    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6>
+    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get(),
+                                     p7.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get(),
+                                       p7.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get(),
+                                     p7.get(),
+                                     p8.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get(),
+                                       p7.get(),
+                                       p8.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get(),
+                                     p7.get(),
+                                     p8.get(),
+                                     p9.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get(),
+                                       p7.get(),
+                                       p8.get(),
+                                       p9.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
+    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref p10(to_python(a10));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
+                                     const_cast<char*>("(OOOOOOOOOO)"),
+                                     p1.get(),
+                                     p2.get(),
+                                     p3.get(),
+                                     p4.get(),
+                                     p5.get(),
+                                     p6.get(),
+                                     p7.get(),
+                                     p8.get(),
+                                     p9.get(),
+                                     p10.get()));
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
+    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
+    {
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref p10(to_python(a10));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOOO)"),
+                                       p1.get(),
+                                       p2.get(),
+                                       p3.get(),
+                                       p4.get(),
+                                       p5.get(),
+                                       p6.get(),
+                                       p7.get(),
+                                       p8.get(),
+                                       p9.get(),
+                                       p10.get()));
+    }
+};
+
+// Make it a compile-time error to try to return a const char* from a virtual
+// function. The standard conversion
+//
+//      from_python(PyObject* string, boost::python::type<const char*>)
+//
+// returns a pointer to the character array which is internal to string. The
+// problem with trying to do this in a standard callback function is that the
+// Python string would likely be destroyed upon return from the calling function
+// (boost::python::callback<const char*>::call[_method]) when its reference count is
+// decremented. If you absolutely need to do this and you're sure it's safe (it
+// usually isn't), you can use
+//
+//      boost::python::string result(boost::python::callback<boost::python::string>::call[_method](...args...));
+//      ...result.c_str()... // access the char* array
+template <>
+struct callback<const char*>
+{
+    // Try hard to generate a readable error message
+    typedef struct unsafe_since_python_string_may_be_destroyed {} call, call_method;
+};
+
+}} // namespace boost::python
+
+#endif // CALLBACK_DWA_052100_H_

include/boost/python/cast.hpp

@@ -0,0 +1,106 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef CAST_DWA200269_HPP
+# define CAST_DWA200269_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/type_traits/same_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/type.hpp>
+# include <boost/python/base_type_traits.hpp>
+# include <boost/python/detail/convertible.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  template <class Source, class Target> inline Target* upcast_impl(Source*, Target*);
+  
+  template <class Source, class Target>
+  inline Target* upcast(Source* p, yes_convertible, no_convertible, Target*)
+  {
+      return p;
+  }
+
+  template <class Source, class Target>
+  inline Target* upcast(Source* p, no_convertible, no_convertible, Target*)
+  {
+      typedef typename base_type_traits<Source>::type base;
+      
+      return detail::upcast_impl((base*)p, (Target*)0);
+  }
+
+  template <bool is_same = true>
+  struct upcaster
+  {
+      template <class T>
+      static inline T* execute(T* x, T*) { return x; }
+  };
+  
+  template <>
+  struct upcaster<false>
+  {
+      template <class Source, class Target>
+      static inline Target* execute(Source* x, Target*)
+      {
+          return detail::upcast(
+              x, detail::convertible<Target*>::check(x)
+              , detail::convertible<Source*>::check((Target*)0)
+              , (Target*)0);
+      }
+  };
+
+
+  template <class Target, class Source>
+  inline Target* downcast(Source* p, yes_convertible)
+  {
+      return static_cast<Target*>(p);
+  }
+
+  template <class Target, class Source>
+  inline Target* downcast(Source* p, no_convertible, boost::type<Target>* = 0)
+  {
+      typedef typename base_type_traits<Source>::type base;
+      return (Target*)detail::downcast<base>(p, convertible<Source*>::check((base*)0));
+  }
+
+  template <class T>
+  inline void assert_castable(boost::type<T>* = 0)
+  {
+      typedef char must_be_a_complete_type[sizeof(T)];
+  }
+
+  template <class Source, class Target>
+  inline Target* upcast_impl(Source* x, Target*)
+  {
+      typedef typename add_cv<Source>::type src_t;
+      typedef typename add_cv<Target>::type target_t;
+      static bool const same = is_same<src_t,target_t>::value;
+      
+      return detail::upcaster<same>::execute(x, (Target*)0);
+  }
+}
+
+template <class Target, class Source>
+inline Target* upcast(Source* x, Target* = 0)
+{
+    detail::assert_castable<Source>();
+    detail::assert_castable<Target>();
+    return detail::upcast_impl(x, (Target*)0);
+    
+}
+
+template <class Target, class Source>
+inline Target* downcast(Source* x, Target* = 0)
+{
+    detail::assert_castable<Source>();
+    detail::assert_castable<Target>();
+    return detail::downcast<Target>(x, detail::convertible<Source*>::check((Target*)0));
+}
+
+}} // namespace boost::python
+
+#endif // CAST_DWA200269_HPP

include/boost/python/class.hpp

@@ -0,0 +1,436 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef CLASS_DWA200216_HPP
+# define CLASS_DWA200216_HPP
+
+# include <boost/python/class_fwd.hpp>
+# include <boost/python/object/class.hpp>
+# include <boost/python/bases.hpp>
+# include <boost/python/args.hpp>
+
+# include <boost/python/object.hpp>
+
+# include <boost/python/type_id.hpp>
+# include <boost/python/detail/member_function_cast.hpp>
+# include <boost/python/object/class_converters.hpp>
+# include <boost/type_traits/ice.hpp>
+# include <boost/type_traits/same_traits.hpp>
+# include <boost/mpl/size.hpp>
+# include <boost/mpl/for_each.hpp>
+# include <boost/mpl/bool_c.hpp>
+# include <boost/python/object/select_holder.hpp>
+# include <boost/python/object/class_wrapper.hpp>
+# include <boost/python/object/make_instance.hpp>
+# include <boost/python/data_members.hpp>
+# include <boost/utility.hpp>
+# include <boost/python/detail/operator_id.hpp>
+# include <boost/python/object/pickle_support.hpp>
+# include <boost/python/make_function.hpp>
+# include <boost/python/object/add_to_namespace.hpp>
+# include <boost/python/detail/def_helper.hpp>
+# include <boost/python/detail/force_instantiate.hpp>
+# include <boost/python/detail/defaults_def.hpp>
+# include <boost/python/signature.hpp>
+# include <boost/python/init.hpp>
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  // This function object is used with mpl::for_each to write the id
+  // of the type a pointer to which is passed as its 2nd compile-time
+  // argument. into the iterator pointed to by its runtime argument
+  struct write_type_id
+  {
+      write_type_id(type_info**p) : p(p) {}
+
+      // Here's the runtime behavior
+      template <class T>
+      void operator()(T*) const
+      {
+          *(*p)++ = type_id<T>();
+      };
+
+      type_info** p;
+  };
+
+  template <class T, class Prev = detail::not_specified>
+  struct select_held_type;
+
+  template <class T1, class T2, class T3>
+  struct has_noncopyable;
+
+  template <detail::operator_id, class L, class R>
+  struct operator_;
+
+  // Register a to_python converter for a class T, depending on the
+  // type of the first (tag) argument. The 2nd argument is a pointer
+  // to the type of holder that must be created. The 3rd argument is a
+  // reference to the Python type object to be created.
+  template <class T, class SelectHolder>
+  static inline void register_copy_constructor(mpl::bool_c<true> const&, SelectHolder const& , T* = 0)
+  {
+      typedef typename SelectHolder::type holder;
+      force_instantiate(objects::class_wrapper<T,holder, objects::make_instance<T,holder> >());
+      SelectHolder::register_();
+  }
+
+  // Tag dispatched to have no effect.
+  template <class T, class SelectHolder>
+  static inline void register_copy_constructor(mpl::bool_c<false> const&, SelectHolder const&, T* = 0)
+  {
+      SelectHolder::register_();
+  }
+
+  template <class T> int assert_default_constructible(T const&);
+}
+
+//
+// class_<T,Bases,HolderGenerator>
+//
+//      This is the primary mechanism through which users will expose
+//      C++ classes to Python. The three template arguments are:
+//
+template <
+    class T // class being wrapped
+    , class X1 // = detail::not_specified
+    , class X2 // = detail::not_specified
+    , class X3 // = detail::not_specified
+    >
+class class_ : public objects::class_base
+{
+ private: // types
+   typedef objects::class_base base;
+
+    typedef class_<T,X1,X2,X3> self;
+    BOOST_STATIC_CONSTANT(bool, is_copyable = (!detail::has_noncopyable<X1,X2,X3>::value));
+
+    typedef typename detail::select_held_type<
+        X1, typename detail::select_held_type<
+        X2, typename detail::select_held_type<
+        X3
+    >::type>::type>::type held_type;
+
+    typedef objects::select_holder<T,held_type> holder_selector;
+
+    typedef typename detail::select_bases<X1
+            , typename detail::select_bases<X2
+              , typename boost::python::detail::select_bases<X3>::type
+              >::type
+            >::type bases;
+
+    // A helper class which will contain an array of id objects to be
+    // passed to the base class constructor
+    struct id_vector
+    {
+        id_vector()
+        {
+            // Stick the derived class id into the first element of the array
+            ids[0] = type_id<T>();
+
+            // Write the rest of the elements into succeeding positions.
+            type_info* p = ids + 1;
+            mpl::for_each(detail::write_type_id(&p), (bases*)0, (add_pointer<mpl::_>*)0);
+        }
+
+        BOOST_STATIC_CONSTANT(
+            std::size_t, size = mpl::size<bases>::value + 1);
+        type_info ids[size];
+    };
+    friend struct id_vector;
+
+ public:
+    // Automatically derive the class name - only works on some
+    // compilers because type_info::name is sometimes mangled (gcc)
+//    class_();           // With default-constructor init function
+//    class_(no_init_t);  // With no init function
+
+    // Construct with the class name, with or without docstring, and default init() function
+    class_(char const* name, char const* doc = 0);
+
+    // Construct with class name, no docstring, and no init() function
+    class_(char const* name, no_init_t);
+
+    // Construct with class name, docstring, and no init() function
+    class_(char const* name, char const* doc, no_init_t);
+
+    template <class DerivedT>
+    inline class_(char const* name, init_base<DerivedT> const& i)
+        : base(name, id_vector::size, id_vector().ids)
+    {
+        this->register_();
+        define_init(*this, i.derived());
+        this->set_instance_size(holder_selector::additional_size());
+    }
+
+    template <class DerivedT>
+    inline class_(char const* name, char const* doc, init_base<DerivedT> const& i)
+        : base(name, id_vector::size, id_vector().ids, doc)
+    {
+        this->register_();
+        define_init(*this, i.derived());
+        this->set_instance_size(holder_selector::additional_size());
+    }
+
+    // Wrap a member function or a non-member function which can take
+    // a T, T cv&, or T cv* as its first parameter, or a callable
+    // python object.
+    template <class F>
+    self& def(char const* name, F f)
+    {
+        this->def_impl(name, f, default_call_policies(), 0, &f);
+        return *this;
+    }
+
+    template <class DerivedT>
+    self& def(init_base<DerivedT> const& i)
+    {
+        define_init(*this, i.derived());
+        return *this;
+    }
+
+    template <class Arg1T, class Arg2T>
+    self& def(char const* name, Arg1T arg1, Arg2T const& arg2)
+    {
+        //  The arguments may be:
+        //      def(name, function)
+        //      def(name, function, policy)
+        //      def(name, function, doc_string)
+        //      def(name, signature, stubs)
+
+        dispatch_def(&arg2, name, arg1, arg2);
+        return *this;
+    }
+
+    template <class Arg1T, class Arg2T, class Arg3T>
+    self& def(char const* name, Arg1T arg1, Arg2T const& arg2, Arg3T const& arg3)
+    {
+        //  The arguments are definitely:
+        //      def(name, function, policy, doc_string) // TODO: exchange policy, doc_string position
+
+        dispatch_def(&arg2, name, arg1, arg2, arg3);
+        return *this;
+    }
+
+    template <detail::operator_id id, class L, class R>
+    self& def(detail::operator_<id,L,R> const& op)
+    {
+        typedef detail::operator_<id,L,R> op_t;
+        return this->def(op.name(), &op_t::template apply<T>::execute);
+    }
+
+    // Define the constructor with the given Args, which should be an
+    // MPL sequence of types.
+    template <class Args>
+    self& def_init(Args const&)
+    {
+        return this->def("__init__",
+            python::make_constructor<Args>(
+                // Using runtime type selection works around a CWPro7 bug.
+                holder_selector::execute((held_type*)0).get()
+                )
+            );
+    }
+
+    template <class Args, class CallPolicyOrDoc>
+    self& def_init(Args const&, CallPolicyOrDoc const& policy_or_doc, char const* doc = 0)
+    {
+        typedef detail::def_helper<CallPolicyOrDoc> helper;
+
+        return this->def(
+            "__init__",
+            python::make_constructor<Args>(
+                helper::get_policy(policy_or_doc)
+                // Using runtime type selection works around a CWPro7 bug.
+                , holder_selector::execute((held_type*)0).get()
+                )
+            , helper::get_doc(policy_or_doc, doc)
+            );
+    }
+
+    // Define the default constructor.
+    self& def_init()
+    {
+        this->def_init(mpl::list0<>::type());
+        return *this;
+    }
+
+    //
+    // Data member access
+    //
+    template <class D>
+    self& def_readonly(char const* name, D T::*pm)
+    {
+        this->add_property(name, make_getter(pm));
+        return *this;
+    }
+
+    template <class D>
+    self& def_readwrite(char const* name, D T::*pm)
+    {
+        return this->add_property(name, make_getter(pm), make_setter(pm));
+    }
+
+    // Property creation
+    template <class Get>
+    self& add_property(char const* name, Get const& fget)
+    {
+        base::add_property(name, object(fget));
+        return *this;
+    }
+
+    template <class Get, class Set>
+    self& add_property(char const* name, Get const& fget, Set const& fset)
+    {
+        base::add_property(name, object(fget), object(fset));
+        return *this;
+    }
+
+    template <class U>
+    self& setattr(char const* name, U const& x)
+    {
+        this->base::setattr(name, object(x));
+        return *this;
+    }
+
+    // Pickle support
+    template <typename PickleSuiteType>
+    self& def_pickle(PickleSuiteType const& x)
+    {
+      error_messages::must_be_derived_from_pickle_suite(x);
+      detail::pickle_suite_finalize<PickleSuiteType>::register_(
+        *this,
+        &PickleSuiteType::getinitargs,
+        &PickleSuiteType::getstate,
+        &PickleSuiteType::setstate,
+        PickleSuiteType::getstate_manages_dict());
+      return *this;
+    }
+
+ private: // helper functions
+
+    template <class Fn, class Policies>
+    inline void def_impl(char const* name, Fn fn, Policies const& policies
+                         , char const* doc, ...)
+    {
+        objects::add_to_namespace(
+            *this, name,
+            make_function(
+                    // This bit of nastiness casts F to a member function of T if possible.
+                detail::member_function_cast<T,Fn>::stage1(fn).stage2((T*)0).stage3(fn)
+                , policies)
+            , doc);
+    }
+
+    template <class F>
+    inline void def_impl(char const* name, F f, default_call_policies const&
+                         , char const* doc, object const*)
+    {
+        objects::add_to_namespace(*this, name, f, doc);
+    }
+
+    inline void register_() const;
+
+    template <class Fn, class CallPolicyOrDoc>
+    void dispatch_def(
+        void const*,
+        char const* name,
+        Fn fn,
+        CallPolicyOrDoc const& policy_or_doc,
+        char const* doc = 0)
+    {
+        typedef detail::def_helper<CallPolicyOrDoc> helper;
+
+        this->def_impl(
+            name, fn, helper::get_policy(policy_or_doc),
+            helper::get_doc(policy_or_doc, doc), &fn);
+
+    }
+
+    template <class StubsT, class SigT>
+    void dispatch_def(
+        detail::func_stubs_base const*,
+        char const* name,
+        SigT sig,
+        StubsT const& stubs)
+    {
+        //  convert sig to a type_list (see detail::get_signature in signature.hpp)
+        //  before calling detail::define_with_defaults.
+        detail::define_with_defaults(
+            name, stubs, *this, detail::get_signature(sig));
+    }
+};
+
+
+//
+// implementations
+//
+        // register converters
+template <class T, class X1, class X2, class X3>
+inline void class_<T,X1,X2,X3>::register_() const
+{
+    objects::register_class_from_python<T,bases>();
+
+    detail::register_copy_constructor<T>(
+        mpl::bool_c<is_copyable>()
+        , holder_selector::execute((held_type*)0)
+        );
+}
+
+template <class T, class X1, class X2, class X3>
+inline class_<T,X1,X2,X3>::class_(char const* name, char const* doc)
+    : base(name, id_vector::size, id_vector().ids, doc)
+{
+    this->register_();
+    detail::force_instantiate(sizeof(detail::assert_default_constructible(T())));
+    this->def_init();
+    this->set_instance_size(holder_selector::additional_size());
+}
+
+template <class T, class X1, class X2, class X3>
+inline class_<T,X1,X2,X3>::class_(char const* name, no_init_t)
+    : base(name, id_vector::size, id_vector().ids)
+{
+    this->register_();
+    this->def_no_init();
+}
+
+template <class T, class X1, class X2, class X3>
+inline class_<T,X1,X2,X3>::class_(char const* name, char const* doc, no_init_t)
+    : base(name, id_vector::size, id_vector().ids, doc)
+{
+    this->register_();
+    this->def_no_init();
+}
+
+namespace detail
+{
+  template <class T1, class T2, class T3>
+  struct has_noncopyable
+      : type_traits::ice_or<
+        is_same<T1,noncopyable>::value
+      , is_same<T2,noncopyable>::value
+      , is_same<T3,noncopyable>::value>
+  {};
+
+
+    template <class T, class Prev>
+    struct select_held_type
+        : mpl::if_c<
+            type_traits::ice_or<
+                 specifies_bases<T>::value
+               , is_same<T,noncopyable>::value
+            >::value
+            , Prev
+            , T
+          >
+    {
+    };
+}
+
+}} // namespace boost::python
+
+#endif // CLASS_DWA200216_HPP

include/boost/python/class_builder.hpp

@@ -0,0 +1,182 @@
+// Revision History:
+// Mar 03 01  added: pickle safety measures (Ralf W. Grosse-Kunstleve)
+
+#ifndef CLASS_WRAPPER_DWA101000_H_
+# define CLASS_WRAPPER_DWA101000_H_
+
+#include <boost/python/detail/extension_class.hpp>
+#include <boost/python/operators.hpp>
+#include <boost/python/module_builder.hpp>
+#include <boost/python/conversions.hpp>
+#include <boost/python/detail/cast.hpp>
+#include <boost/python/reference.hpp>
+
+namespace boost { namespace python {
+
+// Syntactic sugar to make wrapping classes more convenient
+template <class T, class U = detail::held_instance<T> >
+class class_builder
+    : python_extension_class_converters<T, U> // Works around MSVC6.x/GCC2.95.2 bug described below
+{
+ public:
+    class_builder(module_builder& module, const char* name)
+        : m_class(new detail::extension_class<T, U>(name))
+    {
+        module.add(ref(as_object(m_class.get()), ref::increment_count), name);
+    }
+    
+  template <class OtherT, class OtherU>
+    class_builder(class_builder<OtherT, OtherU>& cls, const char* name)
+        : m_class(new detail::extension_class<T, U>(name))
+    {
+        cls.add(ref(as_object(m_class.get()), ref::increment_count), name);
+    }
+    
+  template <class OtherT, class OtherU>
+    class_builder(detail::extension_class<OtherT, OtherU>* cls,
+                  const char* name)
+        : m_class(new detail::extension_class<T, U>(name))
+    {
+        cls->set_attribute(name,
+                           ref(as_object(m_class.get()), ref::increment_count));
+    }
+    
+    ~class_builder()
+    {}
+
+    inline void dict_defines_state() {
+      add(ref(BOOST_PYTHON_CONVERSION::to_python(1)), "__dict_defines_state__");
+    }
+    inline void getstate_manages_dict() {
+      add(ref(BOOST_PYTHON_CONVERSION::to_python(1)), "__getstate_manages_dict__");
+    }
+    
+    // define constructors
+    template <class signature>
+    void def(const signature& s)
+        { m_class->def(s); }
+
+    // export heterogeneous reverse-argument operators 
+    // (type of lhs: 'left', of rhs: 'right')
+    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub), Foo>(),
+    //                       boost::python::left_operand<int const &>());
+    template <long which, class left, class right>
+    void def(operators<which, right> o1, left_operand<left> o2)
+        { m_class->def(o1, o2); }
+
+    // export heterogeneous operators (type of lhs: 'left', of rhs: 'right')
+    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub), Foo>(),
+    //                       boost::python::right_operand<int const &>());
+    template <long which, class left, class right>
+    void def(operators<which, left> o1, right_operand<right> o2)
+        { m_class->def(o1, o2); }
+
+    // define a function that passes Python arguments and keywords
+    // to C++ verbatim (as a 'tuple const &' and 'dictionary const &' 
+    // respectively). This is useful for manual argument passing.
+    // It's also the only possibility to pass keyword arguments to C++.
+    // Fn must have a signatur that is compatible to 
+    //     PyObject * (*)(PyObject * aTuple, PyObject * aDictionary)
+    template <class Fn>
+    void def_raw(Fn fn, const char* name)
+        { m_class->def_raw(fn, name); }
+
+    // define member functions. In fact this works for free functions, too -
+    // they act like static member functions, or if they start with the
+    // appropriate self argument (as a pointer or reference), they can be used
+    // just like ordinary member functions -- just like Python!
+    template <class Fn>
+    void def(Fn fn, const char* name)
+        { m_class->def(fn, name); }
+
+    // Define a virtual member function with a default implementation.
+    // default_fn should be a function which provides the default implementation.
+    // Be careful that default_fn does not in fact call fn virtually!
+    template <class Fn, class DefaultFn>
+    void def(Fn fn, const char* name, DefaultFn default_fn)
+        { m_class->def(fn, name, default_fn); }
+
+    // Provide a function which implements x.<name>, reading from the given
+    // member (pm) of the T obj
+    template <class MemberType>
+    void def_getter(MemberType T::*pm, const char* name)
+        { m_class->def_getter(pm, name); }
+    
+    // Provide a function which implements assignment to x.<name>, writing to
+    // the given member (pm) of the T obj
+    template <class MemberType>
+    void def_setter(MemberType T::*pm, const char* name)
+        { m_class->def_getter(pm, name); }
+    
+    // Expose the given member (pm) of the T obj as a read-only attribute
+    template <class MemberType>
+    void def_readonly(MemberType T::*pm, const char* name)
+        { m_class->def_readonly(pm, name); }
+    
+    // Expose the given member (pm) of the T obj as a read/write attribute
+    template <class MemberType>
+    void def_read_write(MemberType T::*pm, const char* name)
+        { m_class->def_read_write(pm, name); }
+        
+    // define the standard coercion needed for operator overloading
+    void def_standard_coerce()
+        { m_class->def_standard_coerce(); }
+    
+    // declare the given class a base class of this one and register 
+    // conversion functions
+    template <class S, class V>
+    void declare_base(class_builder<S, V> const & base)
+    {
+        m_class->declare_base(base.get_extension_class());
+    }
+
+    // declare the given class a base class of this one and register 
+    // upcast conversion function
+    template <class S, class V>
+    void declare_base(class_builder<S, V> const & base, without_downcast_t)
+    {
+        m_class->declare_base(base.get_extension_class(), without_downcast);
+    }
+
+    // get the embedded ExtensioClass object
+    detail::extension_class<T, U> * get_extension_class() const 
+    {
+        return m_class.get();
+    }
+
+    // set an arbitrary attribute. Useful for non-function class data members,
+    // e.g. enums
+    void add(PyObject* x, const char* name)
+        { m_class->set_attribute(name, x); }
+    void add(ref x, const char* name)
+        { m_class->set_attribute(name, x); }
+ private:
+    // declare the given class a base class of this one and register 
+    // conversion functions
+    template <class S, class V>
+    void declare_base(detail::extension_class<S, V> * base)
+    {
+        m_class->declare_base(base);
+    }
+        
+    // declare the given class a base class of this one and register 
+    // upcast conversion function
+    template <class S, class V>
+    void declare_base(detail::extension_class<S, V> * base, without_downcast_t)
+    {
+        m_class->declare_base(base, without_downcast);
+    }
+    
+    reference<detail::extension_class<T, U> > m_class;
+};
+
+// The bug mentioned at the top of this file is that on certain compilers static
+// global functions declared within the body of a class template will only be
+// generated when the class template is constructed, and when (for some reason)
+// the construction does not occur via a new-expression. Otherwise, we could
+// rely on the initialization of the m_class data member to cause all of the
+// to_/from_python functions to come into being.
+
+}} // namespace boost::python
+
+#endif // CLASS_WRAPPER_DWA101000_H_

include/boost/python/class_fwd.hpp

@@ -0,0 +1,30 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef CLASS_FWD_DWA200222_HPP
+# define CLASS_FWD_DWA200222_HPP
+# include <boost/python/detail/not_specified.hpp>
+# include <boost/python/args.hpp>
+# include <boost/python/bases.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  struct empty_list;
+}
+
+template <
+    class T // class being wrapped
+    // arbitrarily-ordered optional arguments. Full qualification needed for MSVC6
+    , class X1 = ::boost::python::detail::not_specified
+    , class X2 = ::boost::python::detail::not_specified
+    , class X3 = ::boost::python::detail::not_specified
+    >
+class class_;
+
+}} // namespace boost::python
+
+#endif // CLASS_FWD_DWA200222_HPP

include/boost/python/classes.hpp

@@ -0,0 +1,677 @@
+//  (C) Copyright David Abrahams 2000. 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.
+//
+//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
+//  producing this work.
+
+#ifndef SUBCLASS_DWA051500_H_
+# define SUBCLASS_DWA051500_H_
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/types.hpp>
+# include <boost/python/objects.hpp>
+# include <boost/python/detail/singleton.hpp>
+# include <boost/utility.hpp>
+# include <boost/python/conversions.hpp>
+# include <boost/python/callback.hpp>
+
+namespace boost { namespace python {
+
+// A simple type which acts something like a built-in Python class obj.
+class BOOST_PYTHON_DECL instance
+    : public boost::python::detail::python_object
+{
+ public:
+    instance(PyTypeObject* class_);
+    ~instance();
+
+    // Standard Python functions.
+    PyObject* repr();
+    int compare(PyObject*);
+    PyObject* str();
+    long hash();
+    PyObject* call(PyObject* args, PyObject* keywords);
+    PyObject* getattr(const char* name, bool use_special_function = true);
+    int setattr(const char* name, PyObject* value);
+
+    // Mapping methods
+    int length();
+    PyObject* get_subscript(PyObject* key);
+    void set_subscript(PyObject* key, PyObject* value);
+
+    // Sequence methods
+    PyObject* get_slice(int start, int finish);
+    void set_slice(int start, int finish, PyObject* value);
+
+    // Number methods
+    PyObject* add(PyObject* other);
+    PyObject* subtract(PyObject* other);
+    PyObject* multiply(PyObject* other);
+    PyObject* divide(PyObject* other);
+    PyObject* remainder(PyObject* other);
+    PyObject* divmod(PyObject* other);
+    PyObject* power(PyObject*, PyObject*);
+    PyObject* negative();
+    PyObject* positive();
+    PyObject* absolute();
+    int nonzero();
+    PyObject* invert();
+    PyObject* lshift(PyObject* other);
+    PyObject* rshift(PyObject* other);
+    PyObject* do_and(PyObject* other);
+    PyObject* do_xor(PyObject* other);
+    PyObject* do_or(PyObject* other);
+    int coerce(PyObject**, PyObject**);
+    PyObject* as_int();
+    PyObject* as_long();
+    PyObject* as_float();
+    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);
+
+    // Inplace operations.
+    PyObject* inplace_add(PyObject* other);
+    PyObject* inplace_subtract(PyObject* other);
+    PyObject* inplace_multiply(PyObject* other);
+    PyObject* inplace_divide(PyObject* other);
+    PyObject* inplace_remainder(PyObject* other);
+    PyObject* inplace_power(PyObject* exponent, PyObject* modulus);
+    PyObject* inplace_lshift(PyObject* other);
+    PyObject* inplace_rshift(PyObject* other);
+    PyObject* inplace_and(PyObject* other);
+    PyObject* inplace_or(PyObject* other);
+    PyObject* inplace_xor(PyObject* other);
+
+ private: // noncopyable, without the size bloat
+    instance(const instance&);
+    void operator=(const instance&);
+
+ private: // helper functions
+    int setattr_dict(PyObject* value);
+    
+ private:
+    dictionary m_name_space;
+};
+
+template <class T> class meta_class;
+
+namespace detail {
+  class BOOST_PYTHON_DECL class_base : public type_object_base
+  {
+   public:
+      class_base(PyTypeObject* meta_class_obj, string name, tuple bases, const dictionary& name_space);
+      tuple bases() const;
+      string name() const;
+      dictionary& dict();
+      
+      // Standard Python functions.
+      PyObject* getattr(const char* name);
+      int setattr(const char* name, PyObject* value);
+      PyObject* repr() const;
+      void add_base(ref base);
+
+   protected:
+      bool initialize_instance(instance* obj, PyObject* args, PyObject* keywords);
+
+   private: // virtual functions
+      // Subclasses should override this to delete the particular obj type
+      virtual void delete_instance(PyObject*) const = 0;
+
+   private: // boost::python::type_object_base required interface implementation
+      void instance_dealloc(PyObject*) const; // subclasses should not override this
+    
+   private: // noncopyable, without the size bloat
+      class_base(const class_base&);
+      void operator=(const class_base&);
+      
+   private:
+      string m_name;
+      tuple m_bases;
+      dictionary m_name_space;
+  };
+
+  void enable_named_method(class_base* type_obj, const char* name);
+}
+
+// A type which acts a lot like a built-in Python class. T is the obj type,
+// so class_t<instance> is a very simple "class-alike".
+template <class T>
+class class_t : public boost::python::detail::class_base
+{
+ public:
+    class_t(meta_class<T>* meta_class_obj, string name, tuple bases, const dictionary& name_space);
+    ~class_t();
+    
+    // Standard Python functions.
+    PyObject* call(PyObject* args, PyObject* keywords);
+    
+ private: // Implement mapping methods on instances
+    PyObject* instance_repr(PyObject*) const;
+    int instance_compare(PyObject*, PyObject* other) const;
+    PyObject* instance_str(PyObject*) const;
+    long instance_hash(PyObject*) const;
+    int instance_mapping_length(PyObject*) const;
+    PyObject* instance_mapping_subscript(PyObject*, PyObject*) const;
+    int instance_mapping_ass_subscript(PyObject*, PyObject*, PyObject*) const;
+
+ private: // Implement sequence methods on instances
+    int instance_sequence_length(PyObject*) const;
+    PyObject* instance_sequence_item(PyObject* obj, int n) const;
+    int instance_sequence_ass_item(PyObject* obj, int n, PyObject* value) const;
+    PyObject* instance_sequence_slice(PyObject*, int start, int finish) const;
+    int instance_sequence_ass_slice(PyObject*, int start, int finish, PyObject* value) const;
+
+ private: // Implement number methods on instances
+    PyObject* instance_number_add(PyObject*, PyObject*) const;
+    PyObject* instance_number_subtract(PyObject*, PyObject*) const;
+    PyObject* instance_number_multiply(PyObject*, PyObject*) const;
+    PyObject* instance_number_divide(PyObject*, PyObject*) const;
+    PyObject* instance_number_remainder(PyObject*, PyObject*) const;
+    PyObject* instance_number_divmod(PyObject*, PyObject*) const;
+    PyObject* instance_number_power(PyObject*, PyObject*, PyObject*) const;
+    PyObject* instance_number_negative(PyObject*) const;
+    PyObject* instance_number_positive(PyObject*) const;
+    PyObject* instance_number_absolute(PyObject*) const;
+    int instance_number_nonzero(PyObject*) const;
+    PyObject* instance_number_invert(PyObject*) const;
+    PyObject* instance_number_lshift(PyObject*, PyObject*) const;
+    PyObject* instance_number_rshift(PyObject*, PyObject*) const;
+    PyObject* instance_number_and(PyObject*, PyObject*) const;
+    PyObject* instance_number_xor(PyObject*, PyObject*) const;
+    PyObject* instance_number_or(PyObject*, PyObject*) const;
+    int instance_number_coerce(PyObject*, PyObject**, PyObject**) const;
+    PyObject* instance_number_int(PyObject*) const;
+    PyObject* instance_number_long(PyObject*) const;
+    PyObject* instance_number_float(PyObject*) const;
+    PyObject* instance_number_oct(PyObject*) const;
+    PyObject* instance_number_hex(PyObject*) const;
+
+    PyObject* instance_number_inplace_add(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_subtract(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_multiply(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_divide(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_remainder(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_power(PyObject*, PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_lshift(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_rshift(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_and(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_or(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_xor(PyObject*, 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;
+    PyObject* instance_getattr(PyObject* obj, const char* name) const;
+    int instance_setattr(PyObject* obj, const char* name, PyObject* value) const;
+
+ private: // Implementation of boost::python::detail::class_base required interface
+    void delete_instance(PyObject*) const;
+};
+
+// The type of a class_t<T> object.
+template <class T>
+class meta_class
+    : public boost::python::detail::reprable<
+                boost::python::detail::callable<
+                   boost::python::detail::getattrable<
+                      boost::python::detail::setattrable<
+                         boost::python::detail::type_object<class_t<T> > > > > >,
+      private boost::noncopyable
+{
+ public:
+    meta_class();
+
+    // Standard Python functions.
+    PyObject* call(PyObject* args, PyObject* keywords);
+    
+    struct type_object
+        : boost::python::detail::singleton<type_object,
+             boost::python::detail::callable<
+                boost::python::detail::type_object<meta_class> > >
+    {
+        type_object() : singleton_base(&PyType_Type) {}
+    };
+};
+
+//
+// Member function implementations.
+//
+template <class T>
+meta_class<T>::meta_class()
+    : properties(type_object::instance())
+{
+} 
+
+template <class T>
+class_t<T>::class_t(meta_class<T>* meta_class_obj, string name, tuple bases, const dictionary& name_space)
+    : boost::python::detail::class_base(meta_class_obj, name, bases, name_space)
+{
+}
+
+template <class T>
+class_t<T>::~class_t()
+{
+}
+
+template <class T>
+void class_t<T>::delete_instance(PyObject* obj) const
+{
+    delete downcast<T>(obj);
+}
+
+template <class T>
+PyObject* class_t<T>::call(PyObject* args, PyObject* keywords)
+{
+    reference<T> result(new T(this));
+    if (!this->initialize_instance(result.get(), args, keywords))
+        return 0;
+    else
+        return result.release();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_repr(PyObject* obj) const
+{
+    return downcast<T>(obj)->repr();
+}
+
+template <class T>
+int class_t<T>::instance_compare(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->compare(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_str(PyObject* obj) const
+{
+    return downcast<T>(obj)->str();
+}
+
+template <class T>
+long class_t<T>::instance_hash(PyObject* obj) const
+{
+    return downcast<T>(obj)->hash();
+}
+
+template <class T>
+int class_t<T>::instance_mapping_length(PyObject* obj) const
+{
+    return downcast<T>(obj)->length();
+}
+
+template <class T>
+int class_t<T>::instance_sequence_length(PyObject* obj) const
+{
+    return downcast<T>(obj)->length();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_mapping_subscript(PyObject* obj, PyObject* key) const
+{
+    return downcast<T>(obj)->get_subscript(key);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_sequence_item(PyObject* obj, int n) const
+{
+    ref key(to_python(n));
+    return downcast<T>(obj)->get_subscript(key.get());
+}
+
+template <class T>
+int class_t<T>::instance_sequence_ass_item(PyObject* obj, int n, PyObject* value) const
+{
+    ref key(to_python(n));
+    downcast<T>(obj)->set_subscript(key.get(), value);
+    return 0;
+}
+
+template <class T>
+int class_t<T>::instance_mapping_ass_subscript(PyObject* obj, PyObject* key, PyObject* value) const
+{
+    downcast<T>(obj)->set_subscript(key, value);
+    return 0;
+}
+
+bool BOOST_PYTHON_DECL adjust_slice_indices(PyObject* obj, int& start, int& finish);
+
+template <class T>
+PyObject* class_t<T>::instance_sequence_slice(PyObject* obj, int start, int finish) const
+{
+    if (!adjust_slice_indices(obj, start, finish))
+        return 0;
+    return downcast<T>(obj)->get_slice(start, finish);
+}
+
+template <class T>
+int class_t<T>::instance_sequence_ass_slice(PyObject* obj, int start, int finish, PyObject* value) const
+{
+    if (!adjust_slice_indices(obj, start, finish))
+        return -1;
+    downcast<T>(obj)->set_slice(start, finish, value);
+    return 0;
+}
+
+template <class T>
+PyObject* class_t<T>::instance_call(PyObject* obj, PyObject* args, PyObject* keywords) const
+{
+    return downcast<T>(obj)->call(args, keywords);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_getattr(PyObject* obj, const char* name) const
+{
+    return downcast<T>(obj)->getattr(name);
+}
+
+
+template <class T>
+int class_t<T>::instance_setattr(PyObject* obj, const char* name, PyObject* value) const
+{
+    return downcast<T>(obj)->setattr(name, value);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_add(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->add(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_subtract(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->subtract(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_multiply(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->multiply(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_divide(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->divide(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_remainder(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->remainder(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_divmod(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->divmod(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_power(PyObject* obj, PyObject* exponent, PyObject* modulus) const
+{
+    return downcast<T>(obj)->power(exponent, modulus);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_negative(PyObject* obj) const
+{
+    return downcast<T>(obj)->negative();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_positive(PyObject* obj) const
+{
+    return downcast<T>(obj)->positive();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_absolute(PyObject* obj) const
+{
+    return downcast<T>(obj)->absolute();
+}
+
+template <class T>
+int class_t<T>::instance_number_nonzero(PyObject* obj) const
+{
+    return downcast<T>(obj)->nonzero();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_invert(PyObject* obj) const
+{
+    return downcast<T>(obj)->invert();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_lshift(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->lshift(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_rshift(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->rshift(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_and(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->do_and(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_xor(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->do_xor(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_or(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->do_or(other);
+}
+
+template <class T>
+int class_t<T>::instance_number_coerce(PyObject* obj, PyObject** x, PyObject** y) const
+{
+    return downcast<T>(obj)->coerce(x, y);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_int(PyObject* obj) const
+{
+    return downcast<T>(obj)->as_int();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_long(PyObject* obj) const
+{
+    return downcast<T>(obj)->as_long();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_float(PyObject* obj) const
+{
+    return downcast<T>(obj)->as_float();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_oct(PyObject* obj) const
+{
+    return downcast<T>(obj)->oct();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_hex(PyObject* obj) const
+{
+    return downcast<T>(obj)->hex();
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_add(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_add(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_subtract(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_subtract(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_multiply(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_multiply(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_divide(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_divide(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_remainder(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_remainder(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_power(PyObject* obj, PyObject* exponent, PyObject* modulus) const
+{
+    return downcast<T>(obj)->inplace_power(exponent, modulus);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_lshift(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_lshift(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_rshift(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_rshift(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_and(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_and(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_or(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_or(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_xor(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_xor(other);
+}
+
+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()
+  {
+      return m_name_space;
+  }
+
+  inline tuple class_base::bases() const
+  {
+      return m_bases;
+  }
+}
+
+template <class T>
+PyObject* meta_class<T>::call(PyObject* args, PyObject* /*keywords*/)
+{
+    PyObject* name;
+    PyObject* bases;
+    PyObject* name_space;
+    
+    if (!PyArg_ParseTuple(args, const_cast<char*>("O!O!O!"),
+                          &PyString_Type, &name,
+                          &PyTuple_Type, &bases,
+                          &PyDict_Type, &name_space))
+    {
+        return 0;
+    }
+    
+    return as_object(
+        new class_t<T>(this, string(ref(name, ref::increment_count)),
+                  tuple(ref(bases, ref::increment_count)),
+                  dictionary(ref(name_space, ref::increment_count)))
+        );
+}
+
+namespace detail {
+  const string& setattr_string();
+  const string& getattr_string();
+  const string& delattr_string();
+
+  inline string class_base::name() const
+  {
+      return m_name;
+  }
+}
+
+
+}} // namespace boost::python
+#endif

include/boost/python/conversions.hpp

@@ -0,0 +1,415 @@
+//  (C) Copyright David Abrahams 2000. 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.
+//
+//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
+//  producing this work.
+//
+// Revision History:
+// 31 Jul 01  convert int/double to complex (Peter Bienstman)
+// 04 Mar 01  Fixed std::complex<> stuff to work with MSVC (David Abrahams)
+// 03 Mar 01  added: converters for [plain] char and std::complex
+//            (Ralf W. Grosse-Kunstleve)
+
+#ifndef METHOD_DWA122899_H_
+# define METHOD_DWA122899_H_
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/detail/none.hpp>
+# include <boost/python/detail/signatures.hpp>
+# include <boost/shared_ptr.hpp>
+# include <boost/python/errors.hpp>
+# include <string>
+
+# ifdef BOOST_MSVC6_OR_EARLIER
+#  pragma warning(push)
+#  pragma warning(disable:4275) // disable a bogus warning caused by <complex>
+# endif
+
+# include <complex>
+
+# ifdef BOOST_MSVC6_OR_EARLIER
+#  pragma warning(pop)
+# endif
+
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
+
+// This can be instantiated on an enum to provide the to_python/from_python
+// conversions, provided the values can fit in a long.
+template <class EnumType>
+class py_enum_as_int_converters
+{
+    friend EnumType from_python(PyObject* x, boost::python::type<EnumType>)
+    {
+        return static_cast<EnumType>(
+            from_python(x, boost::python::type<long>()));
+    }
+
+    friend EnumType from_python(PyObject* x, boost::python::type<const EnumType&>)
+    {
+        return static_cast<EnumType>(
+            from_python(x, boost::python::type<long>()));
+    }
+
+    friend PyObject* to_python(EnumType x)
+    {
+        return to_python(static_cast<long>(x));
+    }
+};
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
+
+namespace boost { namespace python {
+template <class EnumType> class enum_as_int_converters
+    : public BOOST_PYTHON_CONVERSION::py_enum_as_int_converters<EnumType> {};
+
+template <class P, class T> class wrapped_pointer;
+
+//#pragma warn_possunwant off
+inline void decref_impl(PyObject* p) { Py_DECREF(p); }
+inline void xdecref_impl(PyObject* p) { Py_XDECREF(p); }
+//#pragma warn_possunwant reset
+
+template <class T>
+inline void decref(T* p)
+{
+    char* const raw_p = reinterpret_cast<char*>(p);
+    char* const p_base = raw_p - offsetof(PyObject, ob_refcnt);
+    decref_impl(reinterpret_cast<PyObject*>(p_base));
+}
+
+template <class T>
+inline void xdecref(T* p)
+{
+    char* const raw_p = reinterpret_cast<char*>(p);
+    char* const p_base = raw_p - offsetof(PyObject, ob_refcnt);
+    xdecref_impl(reinterpret_cast<PyObject*>(p_base));
+}
+
+namespace detail {
+
+  void expect_complex(PyObject*);
+
+  template <class T>
+  std::complex<T> complex_from_python(PyObject* p, boost::python::type<T>)
+  {
+      if (PyInt_Check(p)) return std::complex<T>(PyInt_AS_LONG(p));
+      if (PyLong_Check(p)) return std::complex<T>(PyLong_AsDouble(p));
+      if (PyFloat_Check(p)) return std::complex<T>(PyFloat_AS_DOUBLE(p));
+
+      expect_complex(p);
+
+      return std::complex<T>(
+        static_cast<T>(PyComplex_RealAsDouble(p)),
+        static_cast<T>(PyComplex_ImagAsDouble(p)));
+  }
+
+  template <class T>
+  PyObject* complex_to_python(const std::complex<T>& sc) {
+      Py_complex pcc;
+      pcc.real = sc.real();
+      pcc.imag = sc.imag();
+      return PyComplex_FromCComplex(pcc);
+  }
+
+}
+
+}} // namespace boost::python
+
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
+//
+// Converters
+//
+PyObject* to_python(long);
+BOOST_PYTHON_DECL long from_python(PyObject* p, boost::python::type<long>);
+long from_python(PyObject* p, boost::python::type<const long&>);
+
+BOOST_PYTHON_DECL PyObject* to_python(unsigned long);
+BOOST_PYTHON_DECL unsigned long from_python(PyObject* p, boost::python::type<unsigned long>);
+unsigned long from_python(PyObject* p, boost::python::type<const unsigned long&>);
+
+PyObject* to_python(int);
+BOOST_PYTHON_DECL int from_python(PyObject*, boost::python::type<int>);
+int from_python(PyObject*, boost::python::type<const int&>);
+    
+BOOST_PYTHON_DECL PyObject* to_python(unsigned int);
+BOOST_PYTHON_DECL unsigned int from_python(PyObject*, boost::python::type<unsigned int>);
+unsigned int from_python(PyObject*, boost::python::type<const unsigned int&>);
+
+PyObject* to_python(short);
+BOOST_PYTHON_DECL short from_python(PyObject*, boost::python::type<short>);
+short from_python(PyObject*, boost::python::type<const short&>);
+    
+BOOST_PYTHON_DECL PyObject* to_python(unsigned short);
+BOOST_PYTHON_DECL unsigned short from_python(PyObject*, boost::python::type<unsigned short>);
+unsigned short from_python(PyObject*, boost::python::type<const unsigned short&>);
+
+BOOST_PYTHON_DECL PyObject* to_python(char);
+BOOST_PYTHON_DECL char from_python(PyObject*, boost::python::type<char>);
+char from_python(PyObject*, boost::python::type<const char&>);
+
+BOOST_PYTHON_DECL PyObject* to_python(signed char);
+BOOST_PYTHON_DECL signed char from_python(PyObject*, boost::python::type<signed char>);
+signed char from_python(PyObject*, boost::python::type<const signed char&>);
+
+BOOST_PYTHON_DECL PyObject* to_python(unsigned char);
+BOOST_PYTHON_DECL unsigned char from_python(PyObject*, boost::python::type<unsigned char>);
+unsigned char from_python(PyObject*, boost::python::type<const unsigned char&>);
+
+BOOST_PYTHON_DECL float from_python(PyObject*, boost::python::type<float>);
+BOOST_PYTHON_DECL double from_python(PyObject*, boost::python::type<double>);
+
+# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
+PyObject* to_python(float);
+PyObject* to_python(double);
+# else
+BOOST_PYTHON_DECL PyObject* to_python(float);
+BOOST_PYTHON_DECL PyObject* to_python(double);
+# endif 
+float from_python(PyObject*, boost::python::type<const float&>);
+    
+double from_python(PyObject*, boost::python::type<const double&>);
+    
+PyObject* to_python(bool);
+BOOST_PYTHON_DECL bool from_python(PyObject*, boost::python::type<bool>);
+bool from_python(PyObject*, boost::python::type<const bool&>);
+
+BOOST_PYTHON_DECL PyObject* to_python(void);
+BOOST_PYTHON_DECL void from_python(PyObject*, boost::python::type<void>);
+
+PyObject* to_python(const char* s);
+BOOST_PYTHON_DECL const char* from_python(PyObject*, boost::python::type<const char*>);
+
+BOOST_PYTHON_DECL PyObject* to_python(const std::string& s);
+BOOST_PYTHON_DECL std::string from_python(PyObject*, boost::python::type<std::string>);
+std::string from_python(PyObject*, boost::python::type<const std::string&>);
+
+inline PyObject* to_python(const std::complex<float>& x)
+{
+    return boost::python::detail::complex_to_python<float>(x);
+}
+
+inline PyObject* to_python(const std::complex<double>& x)
+{
+    return boost::python::detail::complex_to_python<double>(x);
+}
+
+inline std::complex<double> from_python(PyObject* p,
+                                   boost::python::type<std::complex<double> >) {
+    return boost::python::detail::complex_from_python(p, boost::python::type<double>());
+}
+
+inline std::complex<double> from_python(PyObject* p,
+                                   boost::python::type<const std::complex<double>&>) {
+    return boost::python::detail::complex_from_python(p, boost::python::type<double>());
+}
+
+inline std::complex<float> from_python(PyObject* p,
+                                   boost::python::type<std::complex<float> >) {
+    return boost::python::detail::complex_from_python(p, boost::python::type<float>());
+}
+
+inline std::complex<float> from_python(PyObject* p,
+                                   boost::python::type<const std::complex<float>&>) {
+    return boost::python::detail::complex_from_python(p, boost::python::type<float>());
+}
+
+// For when your C++ function really wants to pass/return a PyObject*
+PyObject* to_python(PyObject*);
+PyObject* from_python(PyObject*, boost::python::type<PyObject*>);
+
+// Some standard conversions to/from smart pointer types. You can add your own
+// from these examples.  These are not generated using the friend technique from
+// wrapped_pointer because:
+//
+//      1. We want to be able to extend conversion to/from WrappedPointers using
+//      arbitrary smart pointer types.
+//
+//      2. It helps with compilation independence. This way, code which creates
+//      wrappers for functions accepting and returning smart_ptr<T> does not
+//      have to have already seen the invocation of wrapped_type<T>.
+//
+
+// Unfortunately, MSVC6 is so incredibly lame that we have to rely on the friend
+// technique to auto_generate standard pointer conversions for wrapped
+// types. This means that you need to write a non-templated function for each
+// specific smart_ptr<T> which you want to convert from_python. For example,
+//
+// namespace boost { namespace python {
+// #ifdef MUST_SUPPORT_MSVC
+//
+// MyPtr<Foo> from_python(PyObject*p, type<MyPtr<Foo> >)
+//     { return smart_ptr_from_python(p, type<MyPtr<Foo> >(), type<Foo>());}
+// }
+// 
+// MyPtr<Bar> from_python(PyObject*p, type<MyPtr<Bar> >)
+//     { return smart_ptr_from_python(p, type<MyPtr<Bar> >(), type<Bar>());}
+// 
+// ... // definitions for MyPtr<Baz>, MyPtr<Mumble>, etc.
+//
+// #else
+//
+// // Just once for all MyPtr<T>
+// template <class T>
+// MyPtr<T> from_python(PyObject*p, type<MyPtr<T> >)
+// {
+//    return smart_ptr_from_python(p, type<MyPtr<T> >(), type<T>());
+// }
+//
+// #endif
+// }} // namespace boost::python
+
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+template <class T>
+boost::shared_ptr<T> from_python(PyObject*p, boost::python::type<boost::shared_ptr<T> >)
+{
+    return smart_ptr_from_python(p, boost::python::type<boost::shared_ptr<T> >(), boost::python::type<T>());
+}
+#endif
+
+#if 0
+template <class T>
+PyObject* to_python(std::auto_ptr<T> p)
+{
+    return new boost::python::wrapped_pointer<std::auto_ptr<T>, T>(p);
+}
+
+template <class T>
+PyObject* to_python(boost::shared_ptr<T> p)
+{
+    return new boost::python::wrapped_pointer<boost::shared_ptr<T>, T>(p);
+}
+#endif
+
+//
+// inline implementations
+//
+
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
+inline PyObject* to_python(double d)
+{
+    return PyFloat_FromDouble(d);
+}
+
+inline PyObject* to_python(float f)
+{
+    return PyFloat_FromDouble(f);
+}
+#endif
+
+inline PyObject* to_python(long l)
+{
+    return PyInt_FromLong(l);
+}
+
+inline PyObject* to_python(int x)
+{
+    return PyInt_FromLong(x);
+}
+
+inline PyObject* to_python(short x)
+{
+    return PyInt_FromLong(x);
+}
+
+inline PyObject* to_python(bool b)
+{
+    return PyInt_FromLong(b);
+}
+
+inline PyObject* to_python(void)
+{
+    return boost::python::detail::none();
+}
+
+inline PyObject* to_python(const char* s)
+{
+    return PyString_FromString(s);
+}
+
+inline std::string from_python(PyObject* p, boost::python::type<const std::string&>)
+{
+    return from_python(p, boost::python::type<std::string>());
+}
+
+inline PyObject* to_python(PyObject* p)
+{
+    Py_INCREF(p);
+    return p;
+}
+
+inline PyObject* from_python(PyObject* p, boost::python::type<PyObject*>)
+{
+    return p;
+}
+
+inline const char* from_python(PyObject* p, boost::python::type<const char* const&>)
+{
+    return from_python(p, boost::python::type<const char*>());
+}
+
+inline double from_python(PyObject* p, boost::python::type<const double&>)
+{
+    return from_python(p, boost::python::type<double>());
+}
+
+inline float from_python(PyObject* p, boost::python::type<const float&>)
+{
+    return from_python(p, boost::python::type<float>());
+}
+
+inline int from_python(PyObject* p, boost::python::type<const int&>)
+{
+    return from_python(p, boost::python::type<int>());
+}
+
+inline short from_python(PyObject* p, boost::python::type<const short&>)
+{
+    return from_python(p, boost::python::type<short>());
+}
+
+inline long from_python(PyObject* p, boost::python::type<const long&>)
+{
+    return from_python(p, boost::python::type<long>());
+}
+
+inline bool from_python(PyObject* p, boost::python::type<const bool&>)
+{
+    return from_python(p, boost::python::type<bool>());
+}
+
+inline unsigned int from_python(PyObject* p, boost::python::type<const unsigned int&>)
+{
+    return from_python(p, boost::python::type<unsigned int>());
+}
+
+inline unsigned short from_python(PyObject* p, boost::python::type<const unsigned short&>)
+{
+    return from_python(p, boost::python::type<unsigned short>());
+}
+
+inline char from_python(PyObject* p, boost::python::type<const char&>)
+{
+    return from_python(p, boost::python::type<char>());
+}
+
+inline signed char from_python(PyObject* p, boost::python::type<const signed char&>)
+{
+    return from_python(p, boost::python::type<signed char>());
+}
+
+inline unsigned char from_python(PyObject* p, boost::python::type<const unsigned char&>)
+{
+    return from_python(p, boost::python::type<unsigned char>());
+}
+
+inline unsigned long from_python(PyObject* p, boost::python::type<const unsigned long&>)
+{
+    return from_python(p, boost::python::type<unsigned long>());
+}
+
+
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
+
+#endif // METHOD_DWA122899_H_

include/boost/python/converter/arg_from_python.hpp

@@ -0,0 +1,336 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef ARG_FROM_PYTHON_DWA2002127_HPP
+# define ARG_FROM_PYTHON_DWA2002127_HPP
+
+# include <boost/python/converter/from_python.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/python/converter/rvalue_from_python_data.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/python/converter/registered.hpp>
+# include <boost/python/converter/registered_pointee.hpp>
+# include <boost/python/detail/void_ptr.hpp>
+# include <boost/python/back_reference.hpp>
+# include <boost/python/detail/referent_storage.hpp>
+# include <boost/python/converter/obj_mgr_arg_from_python.hpp>
+
+namespace boost { namespace python
+{
+  template <class T> struct arg_from_python;
+}}
+
+// This header defines Python->C++ function argument converters,
+// parametrized on the argument type.
+
+namespace boost { namespace python { namespace converter {
+
+//
+// lvalue converters
+//
+//   These require that an lvalue of the type U is stored somewhere in
+//   the Python object being converted.
+
+// Used when T == U*const&
+template <class T>
+struct pointer_cref_arg_from_python
+{
+    typedef T result_type;
+    
+    pointer_cref_arg_from_python(PyObject*);
+    T operator()(PyObject*) const;
+    bool convertible() const;
+    
+ private: // storage for a U*
+    // needed because not all compilers will let us declare U* as the
+    // return type of operator() -- we return U*const& instead
+    typename python::detail::referent_storage<T>::type m_result;
+};
+
+// Base class for pointer and reference converters
+struct arg_lvalue_from_python_base
+{
+ public: // member functions
+    arg_lvalue_from_python_base(void* result);
+    bool convertible() const;
+    
+ protected: // member functions
+    void*const& result() const;
+    
+ private: // data members
+    void* m_result;
+};
+
+// Used when T == U* 
+template <class T>
+struct pointer_arg_from_python : arg_lvalue_from_python_base
+{
+    typedef T result_type;
+    
+    pointer_arg_from_python(PyObject*);
+    T operator()(PyObject*) const;
+};
+
+// Used when T == U& and (T != V const& or T == W volatile&)
+template <class T>
+struct reference_arg_from_python : arg_lvalue_from_python_base
+{
+    typedef T result_type;
+    
+    reference_arg_from_python(PyObject*);
+    T operator()(PyObject*) const;
+};
+
+// ===================
+
+//
+// rvalue converters
+//
+//   These require only that an object of type T can be created from
+//   the given Python object, but not that the T object exist
+//   somewhere in storage.
+//
+
+// Used when T is a plain value (non-pointer, non-reference) type or
+// a (non-volatile) const reference to a plain value type.
+template <class T>
+struct arg_rvalue_from_python
+{
+    typedef typename boost::add_reference<
+        typename boost::add_const<T>::type
+    >::type result_type;
+    
+    arg_rvalue_from_python(PyObject*);
+    bool convertible() const;
+    
+    result_type operator()(PyObject*);
+    
+ private:
+    rvalue_from_python_data<result_type> m_data;
+};
+
+
+// ==================
+
+// Converts to a (PyObject*,T) bundle, for when you need a reference
+// back to the Python object
+template <class T>
+struct back_reference_arg_from_python
+    : boost::python::arg_from_python<typename T::type>
+{
+    typedef T result_type;
+    
+    back_reference_arg_from_python(PyObject*);
+    T operator()(PyObject*);
+ private:
+    typedef boost::python::arg_from_python<typename T::type> base;
+};
+
+
+// ==================
+
+// This metafunction selects the appropriate arg_from_python converter
+// type for an argument of type T.
+template <class T>
+struct select_arg_from_python
+{
+    BOOST_STATIC_CONSTANT(
+        bool, obj_mgr = is_object_manager<T>::value);
+    
+    BOOST_STATIC_CONSTANT(
+        bool, obj_mgr_ref = is_reference_to_object_manager<T>::value);
+    
+    BOOST_STATIC_CONSTANT(
+        bool, ptr = is_pointer<T>::value);
+    
+    BOOST_STATIC_CONSTANT(
+        bool, ptr_cref
+            = boost::python::detail::is_reference_to_pointer<T>::value
+            && boost::python::detail::is_reference_to_const<T>::value
+            && !boost::python::detail::is_reference_to_volatile<T>::value);
+    
+    
+    BOOST_STATIC_CONSTANT(
+        bool, ref =
+        boost::python::detail::is_reference_to_non_const<T>::value
+        || boost::python::detail::is_reference_to_volatile<T>::value);
+
+    BOOST_STATIC_CONSTANT(
+        bool, back_ref =
+        boost::python::is_back_reference<T>::value);
+
+    typedef typename mpl::if_c<
+        obj_mgr
+        , object_manager_value_arg_from_python<T>
+        , typename mpl::if_c<
+            obj_mgr_ref
+            , object_manager_ref_arg_from_python<T>
+            , typename mpl::if_c<
+                ptr
+                , pointer_arg_from_python<T>
+                , typename mpl::if_c<
+                    ptr_cref
+                    , pointer_cref_arg_from_python<T>
+                    , typename mpl::if_c<
+                        ref
+                        , reference_arg_from_python<T>
+                        , typename mpl::if_c<
+                            back_ref
+                            , back_reference_arg_from_python<T>
+                            , arg_rvalue_from_python<T>
+                          >::type
+                      >::type
+                  >::type
+              >::type
+          >::type
+      >::type type;
+};
+
+// ==================
+
+//
+// implementations
+//
+
+// arg_lvalue_from_python_base
+//
+inline arg_lvalue_from_python_base::arg_lvalue_from_python_base(void* result)
+    : m_result(result)
+{
+}
+
+inline bool arg_lvalue_from_python_base::convertible() const
+{
+    return m_result != 0;
+}
+
+inline void*const& arg_lvalue_from_python_base::result() const
+{
+    return m_result;
+}
+
+// pointer_cref_arg_from_python
+//
+namespace detail
+{
+  // null_ptr_reference -- a function returning a reference to a null
+  // pointer of type U. Needed so that extractors for T*const& can
+  // convert Python's None.
+  template <class T>
+  struct null_ptr_owner
+  {
+      static T value;
+  };
+  template <class T> T null_ptr_owner<T>::value = 0;
+  
+  template <class U>
+  inline U& null_ptr_reference(U&(*)())
+  {
+      return null_ptr_owner<U>::value;
+  }
+}
+
+template <class T>
+inline pointer_cref_arg_from_python<T>::pointer_cref_arg_from_python(PyObject* p)
+{
+    // T == U*const&: store a U* in the m_result storage. Nonzero
+    // indicates success.  If find returns nonzero, it's a pointer to
+    // a U object.
+    python::detail::write_void_ptr_reference(
+        m_result.bytes
+        , p == Py_None ? p : converter::get_lvalue_from_python(p, registered_pointee<T>::converters)
+        , (T(*)())0);
+}
+
+template <class T>
+inline bool pointer_cref_arg_from_python<T>::convertible() const
+{
+    return python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0) != 0;
+}
+template <class T>
+inline T pointer_cref_arg_from_python<T>::operator()(PyObject* p) const
+{
+    return (p == Py_None)  // None ==> 0
+        ? detail::null_ptr_reference((T(*)())0)
+        // Otherwise, return a U*const& to the m_result storage.
+        : python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0);
+}
+
+// pointer_arg_from_python
+//
+template <class T>
+inline pointer_arg_from_python<T>::pointer_arg_from_python(PyObject* p)
+    : arg_lvalue_from_python_base(
+        p == Py_None ? p : converter::get_lvalue_from_python(p, registered_pointee<T>::converters))
+{
+}
+
+template <class T>
+inline T pointer_arg_from_python<T>::operator()(PyObject* p) const
+{
+    return (p == Py_None) ? 0 : T(result());
+}
+
+// reference_arg_from_python
+//
+template <class T>
+inline reference_arg_from_python<T>::reference_arg_from_python(PyObject* p)
+    : arg_lvalue_from_python_base(converter::get_lvalue_from_python(p,registered<T>::converters))
+{
+}
+
+template <class T>
+inline T reference_arg_from_python<T>::operator()(PyObject*) const
+{
+    return python::detail::void_ptr_to_reference(result(), (T(*)())0);
+}
+
+
+// arg_rvalue_from_python
+//
+template <class T>
+inline arg_rvalue_from_python<T>::arg_rvalue_from_python(PyObject* obj)
+    : m_data(converter::rvalue_from_python_stage1(obj, registered<T>::converters))
+{
+}
+
+template <class T>
+inline bool arg_rvalue_from_python<T>::convertible() const
+{
+    return m_data.stage1.convertible != 0;
+}
+
+template <class T>
+inline typename arg_rvalue_from_python<T>::result_type
+arg_rvalue_from_python<T>::operator()(PyObject* p)
+{
+    if (m_data.stage1.construct != 0)
+        m_data.stage1.construct(p, &m_data.stage1);
+    
+    return python::detail::void_ptr_to_reference(m_data.stage1.convertible, (result_type(*)())0);
+}
+
+// back_reference_arg_from_python
+//
+template <class T>
+back_reference_arg_from_python<T>::back_reference_arg_from_python(PyObject* x)
+    : base(x)
+{
+}
+
+template <class T>
+inline T
+back_reference_arg_from_python<T>::operator()(PyObject* x)
+{
+    return T(x, base::operator()(x));
+}
+
+}}} // namespace boost::python::converter
+
+#endif // ARG_FROM_PYTHON_DWA2002127_HPP

include/boost/python/converter/arg_to_python.hpp

@@ -0,0 +1,247 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef ARG_TO_PYTHON_DWA200265_HPP
+# define ARG_TO_PYTHON_DWA200265_HPP
+
+# include <boost/python/ptr.hpp>
+# include <boost/python/converter/registered.hpp>
+# include <boost/python/converter/registered_pointee.hpp>
+# include <boost/python/converter/arg_to_python_base.hpp>
+# include <boost/python/to_python_indirect.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+# include <boost/type_traits/function_traits.hpp>
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/python/detail/convertible.hpp>
+# include <boost/python/detail/string_literal.hpp>
+# include <boost/python/base_type_traits.hpp>
+// Bring in specializations
+# include <boost/python/converter/builtin_converters.hpp>
+# include <boost/python/tag.hpp>
+# include <boost/python/object/function_handle.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class T> struct is_object_manager;
+
+namespace detail
+{
+  BOOST_PYTHON_DECL void throw_no_class_registered();
+
+  template <class T>
+  struct function_arg_to_python : handle<>
+  {
+      function_arg_to_python(T const& x);
+  };
+
+  template <class T>
+  struct reference_arg_to_python : handle<>
+  {
+      reference_arg_to_python(T& x);
+   private:
+      static PyObject* get_object(T& x);
+  };
+
+  template <class T>
+  struct value_arg_to_python : arg_to_python_base
+  {
+      // Throw an exception if the conversion can't succeed
+      value_arg_to_python(T const&);
+  };
+
+  template <class Ptr>
+  struct pointer_deep_arg_to_python : arg_to_python_base
+  {
+      // Throw an exception if the conversion can't succeed
+      pointer_deep_arg_to_python(Ptr);
+  };
+
+  template <class Ptr>
+  struct pointer_shallow_arg_to_python : handle<>
+  {
+      // Throw an exception if the conversion can't succeed
+      pointer_shallow_arg_to_python(Ptr);
+   private:
+      static PyObject* get_object(Ptr p);
+  };
+
+  // Convert types that manage a Python object to_python
+  template <class T>
+  struct object_manager_arg_to_python
+  {
+      object_manager_arg_to_python(T const& x) : m_src(x) {}
+      
+      PyObject* get() const
+      {
+          return python::upcast<PyObject>(get_managed_object(m_src, tag));
+      }
+      
+   private:
+      T const& m_src;
+  };
+
+  template <class T>
+  struct select_arg_to_python
+  {
+      // Special handling for char const[N]; interpret them as char
+      // const* for the sake of conversion
+      BOOST_STATIC_CONSTANT(
+          bool, is_string = python::detail::is_string_literal<T const>::value);
+      
+      BOOST_STATIC_CONSTANT(
+          bool, function = is_function<T>::value | python::detail::is_pointer_to_function<T>::value | is_member_function_pointer<T>::value);
+      
+      BOOST_STATIC_CONSTANT(
+          bool, manager = is_object_manager<T>::value);
+      
+      BOOST_STATIC_CONSTANT(
+          bool, ptr = is_pointer<T>::value);
+      
+      BOOST_STATIC_CONSTANT(
+          bool, ref_wrapper = is_reference_wrapper<T>::value);
+
+      BOOST_STATIC_CONSTANT(
+          bool, ptr_wrapper = is_pointer_wrapper<T>::value);
+
+      typedef typename unwrap_reference<T>::type unwrapped_referent;
+      typedef typename unwrap_pointer<T>::type unwrapped_ptr;
+
+      typedef typename mpl::if_c<
+          is_string
+          , arg_to_python<char const*>
+          , typename mpl::if_c<
+              function
+              , function_arg_to_python<T>
+              , typename mpl::if_c<
+                  manager
+                  , object_manager_arg_to_python<T>
+                  , typename mpl::if_c<
+                      ptr
+                      , pointer_deep_arg_to_python<T>
+                      , typename mpl::if_c<
+                          ptr_wrapper
+                          , pointer_shallow_arg_to_python<unwrapped_ptr>
+                          , typename mpl::if_c<
+                              ref_wrapper
+                              , reference_arg_to_python<unwrapped_referent>
+                              , value_arg_to_python<T>
+                            >::type
+                        >::type
+                    >::type
+                >::type
+            >::type
+        >::type
+      type;
+  };
+}
+
+template <class T>
+struct arg_to_python
+    : detail::select_arg_to_python<T>::type
+{
+    typedef typename detail::select_arg_to_python<T>::type base;
+ public: // member functions
+    // Throw an exception if the conversion can't succeed
+    arg_to_python(T const& x);
+};
+
+//
+// implementations
+//
+namespace detail
+{
+  // reject_raw_object_ptr -- cause a compile-time error if the user
+  // should pass a raw Python object pointer
+  using python::detail::yes_convertible;
+  using python::detail::no_convertible;
+  using python::detail::unspecialized;
+  
+  template <class T> struct cannot_convert_raw_PyObject;
+
+  template <class T, class Convertibility>
+  struct reject_raw_object_helper
+  {
+      static void error(Convertibility)
+      {
+          cannot_convert_raw_PyObject<T*>::to_python_use_handle_instead();
+      }
+      static void error(...) {}
+  };
+  
+  template <class T>
+  inline void reject_raw_object_ptr(T*)
+  {
+      reject_raw_object_helper<T,yes_convertible>::error(
+          python::detail::convertible<PyObject const volatile*>::check((T*)0));
+      
+      typedef typename remove_cv<T>::type value_type;
+      
+      reject_raw_object_helper<T,no_convertible>::error(
+          python::detail::convertible<unspecialized*>::check(
+              (base_type_traits<value_type>*)0
+              ));
+  }
+  // ---------
+      
+  template <class T>
+  inline function_arg_to_python<T>::function_arg_to_python(T const& x)
+      : handle<>(python::objects::make_function_handle(x))
+  {
+  }
+
+  template <class T>
+  inline value_arg_to_python<T>::value_arg_to_python(T const& x)
+      : arg_to_python_base(&x, registered<T>::converters)
+  {
+  }
+
+  template <class Ptr>
+  inline pointer_deep_arg_to_python<Ptr>::pointer_deep_arg_to_python(Ptr x)
+      : arg_to_python_base(x, registered_pointee<Ptr>::converters)
+  {
+      detail::reject_raw_object_ptr((Ptr)0);
+  }
+
+  template <class T>
+  inline PyObject* reference_arg_to_python<T>::get_object(T& x)
+  {
+      to_python_indirect<T&,python::detail::make_reference_holder> convert;
+      if (!convert.convertible())
+          throw_no_class_registered();
+      return convert(x);
+  }
+
+  template <class T>
+  inline reference_arg_to_python<T>::reference_arg_to_python(T& x)
+      : handle<>(reference_arg_to_python<T>::get_object(x))
+  {
+  }
+
+  template <class Ptr>
+  inline pointer_shallow_arg_to_python<Ptr>::pointer_shallow_arg_to_python(Ptr x)
+      : handle<>(pointer_shallow_arg_to_python<Ptr>::get_object(x))
+  {
+      detail::reject_raw_object_ptr((Ptr)0);
+  }
+
+  template <class Ptr>
+  inline PyObject* pointer_shallow_arg_to_python<Ptr>::get_object(Ptr x)
+  {
+      to_python_indirect<Ptr,python::detail::make_reference_holder> convert;
+      if (!convert.convertible())
+          throw_no_class_registered();
+      return x ? convert(x) : python::detail::none();
+  }
+}
+
+template <class T>
+inline arg_to_python<T>::arg_to_python(T const& x)
+    : base(x)
+{}
+
+}}} // namespace boost::python::converter
+
+#endif // ARG_TO_PYTHON_DWA200265_HPP

include/boost/python/converter/arg_to_python_base.hpp

@@ -0,0 +1,35 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef ARG_TO_PYTHON_BASE_DWA200237_HPP
+# define ARG_TO_PYTHON_BASE_DWA200237_HPP
+# include <boost/python/converter/to_python_function_type.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/handle.hpp>
+
+namespace boost { namespace python { namespace converter {
+
+struct registration;
+
+namespace detail
+{
+  struct BOOST_PYTHON_DECL arg_to_python_base
+# if !defined(BOOST_MSVC) || BOOST_MSVC <= 1300 || _MSC_FULL_VER > 13102179
+      : handle<>
+# endif 
+  {
+      arg_to_python_base(void const volatile* source, registration const&);
+# if defined(BOOST_MSVC) && BOOST_MSVC > 1300 && _MSC_FULL_VER <= 13102179
+      PyObject* get() const { return m_ptr.get(); }
+      PyObject* release() { return m_ptr.release(); }
+   private:
+      handle<> m_ptr;
+# endif 
+  };
+}
+
+}}} // namespace boost::python::converter
+
+#endif // ARG_TO_PYTHON_BASE_DWA200237_HPP

include/boost/python/converter/builtin_converters.hpp

@@ -0,0 +1,123 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef BUILTIN_CONVERTERS_DWA2002124_HPP
+# define BUILTIN_CONVERTERS_DWA2002124_HPP
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/detail/none.hpp>
+# include <boost/python/handle.hpp>
+# include <string>
+# include <complex>
+
+// Since all we can use to decide how to convert an object to_python
+// is its C++ type, there can be only one such converter for each
+// type. Therefore, for built-in conversions we can bypass registry
+// lookups using explicit specializations of arg_to_python and
+// result_to_python.
+
+namespace boost { namespace python {
+
+namespace converter
+{
+  template <class T> struct arg_to_python;
+  BOOST_PYTHON_DECL PyObject* do_return_to_python(char);
+  BOOST_PYTHON_DECL PyObject* do_return_to_python(char const*);
+  BOOST_PYTHON_DECL PyObject* do_return_to_python(PyObject*);
+  BOOST_PYTHON_DECL PyObject* do_arg_to_python(PyObject*);
+}
+
+// Provide specializations of to_python_value
+template <class T> struct to_python_value;
+
+namespace detail
+{
+  // Since there's no registry lookup, always report the existence of
+  // a converter.
+  struct builtin_to_python
+  {
+      static bool convertible() { return true; }
+  };
+}
+
+// Use expr to create the PyObject corresponding to x
+# define BOOST_PYTHON_RETURN_TO_PYTHON_BY_VALUE(T, expr)        \
+    template <> struct to_python_value<T&>                      \
+        : detail::builtin_to_python                             \
+    {                                                           \
+        inline PyObject* operator()(T const& x) const           \
+        {                                                       \
+            return (expr);                                      \
+        }                                                       \
+    };                                                          \
+    template <> struct to_python_value<T const&>                \
+        : detail::builtin_to_python                             \
+    {                                                           \
+        inline PyObject* operator()(T const& x) const           \
+        {                                                       \
+            return (expr);                                      \
+        }                                                       \
+    };
+
+# define BOOST_PYTHON_ARG_TO_PYTHON_BY_VALUE(T, expr)   \
+    namespace converter                                 \
+    {                                                   \
+      template <> struct arg_to_python< T >             \
+        : handle<>                                      \
+      {                                                 \
+          arg_to_python(T const& x)                     \
+            : python::handle<>(expr) {}                 \
+      };                                                \
+    } 
+
+// Specialize argument and return value converters for T using expr
+# define BOOST_PYTHON_TO_PYTHON_BY_VALUE(T, expr)       \
+        BOOST_PYTHON_RETURN_TO_PYTHON_BY_VALUE(T,expr)  \
+        BOOST_PYTHON_ARG_TO_PYTHON_BY_VALUE(T,expr)
+
+// Specialize converters for signed and unsigned T to Python Int
+# define BOOST_PYTHON_TO_INT(T)                                         \
+    BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed T, PyInt_FromLong(x))        \
+    BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned T, PyInt_FromLong(x))
+
+// Bool is not signed.
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(bool, PyInt_FromLong(x))
+
+// note: handles signed char and unsigned char, but not char (see below)
+BOOST_PYTHON_TO_INT(char)
+
+BOOST_PYTHON_TO_INT(short)
+BOOST_PYTHON_TO_INT(int)
+BOOST_PYTHON_TO_INT(long)
+
+// using Python's macro instead of Boost's - we don't seem to get the
+// config right all the time.
+# ifdef HAVE_LONG_LONG 
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed LONG_LONG, PyLong_FromLongLong(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned LONG_LONG, PyLong_FromUnsignedLongLong(x))
+# endif
+    
+# undef BOOST_TO_PYTHON_INT
+
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(char, converter::do_return_to_python(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, converter::do_return_to_python(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::string, PyString_FromString(x.c_str()))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(float, PyFloat_FromDouble(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(double, PyFloat_FromDouble(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(long double, PyFloat_FromDouble(x))
+BOOST_PYTHON_RETURN_TO_PYTHON_BY_VALUE(PyObject*, converter::do_return_to_python(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<float>, PyComplex_FromDoubles(x.real(), x.imag()))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<double>, PyComplex_FromDoubles(x.real(), x.imag()))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<long double>, PyComplex_FromDoubles(x.real(), x.imag()))
+
+namespace converter
+{ 
+
+  void initialize_builtin_converters();
+
+}
+
+}} // namespace boost::python::converter
+
+#endif // BUILTIN_CONVERTERS_DWA2002124_HPP

include/boost/python/converter/callback.hpp

@@ -0,0 +1,278 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef CALLBACK_DWA2002228_HPP
+# define CALLBACK_DWA2002228_HPP
+
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/converter/to_python_function.hpp>
+# include <boost/python/converter/pointee_to_python_function.hpp>
+# include <boost/python/converter/from_python.hpp>
+# include <boost/mpl/select_if.hpp>
+# include <boost/python/converter/callback_to_python_base.hpp>
+# include <boost/python/converter/callback_from_python_base.hpp>
+# include <boost/python/converter/builtin_converters.hpp>
+# include <boost/python/to_python_indirect.hpp>
+# include <boost/python/detail/none.hpp>
+# include <boost/python/ptr.hpp>
+# include <boost/python/errors.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+namespace detail
+{
+  template <class T>
+  struct pointer_callback_from_python
+  {
+      pointer_callback_from_python();
+      T operator()(PyObject*) const;
+  };
+  
+  template <class T>
+  struct reference_callback_from_python
+  {
+      reference_callback_from_python();
+      T operator()(PyObject*) const;
+  };
+  
+  template <class T>
+  struct rvalue_callback_from_python
+  {
+      rvalue_callback_from_python();
+      T const& operator()(PyObject*);
+   private:
+      rvalue_data<T> m_data;
+  };
+  
+  template <class T>
+  struct select_callback_from_python
+  {
+      BOOST_STATIC_CONSTANT(
+          bool, ptr = is_pointer<T>::value);
+    
+      BOOST_STATIC_CONSTANT(
+          bool, ref = is_reference<T>::value);
+
+      typedef typename mpl::select_if_c<
+          ptr
+          , pointer_callback_from_python<T>
+          , typename mpl::select_if_c<
+              ref
+              , reference_callback_from_python<T>
+              , rvalue_callback_from_python<T>
+            >::type
+          >::type type;
+  };
+
+
+  template <class T>
+  struct reference_callback_to_python : callback_to_python_holder
+  {
+      reference_callback_to_python(T& x);
+   private:
+      static PyObject* get_object(T& x);
+  };
+
+  template <class T>
+  struct value_callback_to_python : callback_to_python_base
+  {
+      // Throw an exception if the conversion can't succeed
+      value_callback_to_python(T const&);
+  };
+
+  template <class Ptr>
+  struct pointer_deep_callback_to_python : callback_to_python_base
+  {
+      // Throw an exception if the conversion can't succeed
+      pointer_deep_callback_to_python(Ptr);
+  };
+
+  template <class Ptr>
+  struct pointer_shallow_callback_to_python : callback_to_python_holder
+  {
+      // Throw an exception if the conversion can't succeed
+      pointer_shallow_callback_to_python(Ptr);
+   private:
+      static PyObject* get_object(Ptr p);
+  };
+
+  template <class T>
+  struct select_callback_to_python
+  {
+      BOOST_STATIC_CONSTANT(
+          bool, ptr = is_pointer<T>::value);
+      
+      BOOST_STATIC_CONSTANT(
+          bool, ref_wrapper = is_reference_wrapper<T>::value);
+
+      BOOST_STATIC_CONSTANT(
+          bool, ptr_wrapper = is_pointer_wrapper<T>::value);
+
+      typedef typename unwrap_reference<T>::type unwrapped_referent;
+      typedef typename unwrap_pointer<T>::type unwrapped_ptr;
+
+      typedef typename mpl::select_if_c<
+          ptr
+          , pointer_deep_callback_to_python<T>
+          , typename mpl::select_if_c<
+              ptr_wrapper
+              , pointer_shallow_callback_to_python<unwrapped_ptr>
+              , typename mpl::select_if_c<
+                  ref_wrapper
+                  , reference_callback_to_python<unwrapped_referent>
+                  , value_callback_to_python<T>
+                >::type
+            >::type
+        >::type type;
+  };
+}
+
+template <class T>
+struct callback_from_python
+    : detail::select_callback_from_python<T>::type
+{
+    typedef T result_type;
+};
+
+struct void_result
+{
+ private: 
+    void_result() {}
+    void operator=(void_result const&);
+    
+    // I would prefer to make this completely untouchable, but few
+    // compilers support template friends
+# if 0
+    void_result(void_result const&);
+# endif
+    friend struct callback_from_python<void>;
+};
+
+// Specialization as a convenience for call and call_method
+template <>
+struct callback_from_python<void>
+{
+    typedef void_result result_type;
+    result_type operator()(PyObject* x) const
+    {
+        Py_DECREF(expect_non_null(x));
+        return result_type();
+    }
+};
+
+template <class T>
+struct callback_to_python
+    : detail::select_callback_to_python<T>::type
+{
+    typedef typename detail::select_callback_to_python<T>::type base;
+ public: // member functions
+    // Throw an exception if the conversion can't succeed
+    callback_to_python(T const& x);
+};
+
+// Convenience macros for call<> and call_method<> code generation
+# define BOOST_PYTHON_CALLBACK_TO_PYTHON_GET(index,ignored)     \
+    converter::callback_to_python<BOOST_PP_CAT(A,index)>(       \
+        BOOST_PP_CAT(a,index)).get()
+
+# define BOOST_PYTHON_ARG_STRING(nargs)                         \
+    "(" BOOST_PP_REPEAT(nargs,BOOST_PYTHON_PROJECT_2ND,"O") ")"
+
+//
+// Implementations
+//
+namespace detail
+{
+  template <class T>
+  inline rvalue_callback_from_python<T>::rvalue_callback_from_python()
+      : m_data(rvalue_from_python_chain<T>::value)
+  {
+      throw_if_not_registered(m_data.stage1);
+  }
+  
+  template <class T>
+  inline T const& rvalue_callback_from_python<T>::operator()(PyObject* obj)
+  {
+      return *(T*)convert_rvalue(obj, m_data.stage1, m_data.storage.bytes);
+  }
+
+  BOOST_PYTHON_DECL void throw_no_class_registered();
+
+  template <class T>
+  inline reference_callback_from_python<T>::reference_callback_from_python()
+  {
+      detail::throw_if_not_registered(lvalue_from_python_chain<T,true>::value);
+  }
+  
+  template <class T>
+  inline T reference_callback_from_python<T>::operator()(PyObject* obj) const
+  {
+      return python::detail::void_ptr_to_reference(
+          callback_convert_reference(obj, lvalue_from_python_chain<T,true>::value)
+          , (T(*)())0);
+  }
+
+  template <class T>
+  inline pointer_callback_from_python<T>::pointer_callback_from_python()
+  {
+      detail::throw_if_not_registered(lvalue_from_python_chain<T,true>::value);
+  }
+  
+  template <class T>
+  inline T pointer_callback_from_python<T>::operator()(PyObject* obj) const
+  {
+      return T(callback_convert_pointer(obj, lvalue_from_python_chain<T,true>::value));
+  }
+
+  template <class T>
+  inline value_callback_to_python<T>::value_callback_to_python(T const& x)
+      : callback_to_python_base(&x, to_python_function<T>::value)
+  {
+  }
+
+  template <class Ptr>
+  inline pointer_deep_callback_to_python<Ptr>::pointer_deep_callback_to_python(Ptr x)
+      : callback_to_python_base(x, pointee_to_python_function<Ptr>::value)
+  {
+  }
+
+  template <class T>
+  inline PyObject* reference_callback_to_python<T>::get_object(T& x)
+  {
+      to_python_indirect<T&,python::detail::make_reference_holder> convert;
+      if (!convert.convertible())
+          throw_no_class_registered();
+      return convert(x);
+  }
+
+  template <class T>
+  inline reference_callback_to_python<T>::reference_callback_to_python(T& x)
+      : callback_to_python_holder(get_object(x))
+  {
+  }
+
+  template <class Ptr>
+  inline pointer_shallow_callback_to_python<Ptr>::pointer_shallow_callback_to_python(Ptr x)
+      : callback_to_python_holder(get_object(x))
+  {}
+
+  template <class Ptr>
+  inline PyObject* pointer_shallow_callback_to_python<Ptr>::get_object(Ptr x)
+  {
+      to_python_indirect<Ptr,python::detail::make_reference_holder> convert;
+      if (!convert.convertible())
+          throw_no_class_registered();
+      return x ? convert(x) : python::detail::none();
+  }
+}
+
+template <class T>
+inline callback_to_python<T>::callback_to_python(T const& x)
+    : base(x)
+{}
+
+}}} // namespace boost::python::converter
+
+#endif // CALLBACK_DWA2002228_HPP

include/boost/python/converter/callback_from_python_base.hpp

@@ -0,0 +1,25 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef CALLBACK_FROM_PYTHON_BASE_DWA200237_HPP
+# define CALLBACK_FROM_PYTHON_BASE_DWA200237_HPP
+
+namespace boost { namespace python { namespace converter { 
+
+namespace detail
+{
+
+  // Throw an exception
+  BOOST_PYTHON_DECL void throw_if_not_registered(rvalue_stage1_data const&);
+  BOOST_PYTHON_DECL void* convert_rvalue(PyObject*, rvalue_stage1_data& data, void* storage);
+  
+  BOOST_PYTHON_DECL void throw_if_not_registered(lvalue_from_python_registration*const&);
+  BOOST_PYTHON_DECL void* callback_convert_reference(PyObject*, lvalue_from_python_registration*const&);
+  BOOST_PYTHON_DECL void* callback_convert_pointer(PyObject*, lvalue_from_python_registration*const&);
+}
+
+}}} // namespace boost::python::converter
+
+#endif // CALLBACK_FROM_PYTHON_BASE_DWA200237_HPP

include/boost/python/converter/callback_to_python_base.hpp

@@ -0,0 +1,45 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef CALLBACK_TO_PYTHON_BASE_DWA200237_HPP
+# define CALLBACK_TO_PYTHON_BASE_DWA200237_HPP
+# include <boost/python/converter/to_python_function_type.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/reference.hpp>
+
+namespace boost { namespace python { namespace converter {
+
+namespace detail
+{
+  struct callback_to_python_holder
+  {
+      callback_to_python_holder(PyObject* obj);
+      inline PyObject* get() const;
+   private:
+      ref m_held;
+  };
+  
+  struct BOOST_PYTHON_DECL callback_to_python_base : callback_to_python_holder
+  {
+      callback_to_python_base(void const volatile* source, to_python_function_t);
+  };
+
+  //
+  // implmentation
+  //
+  inline callback_to_python_holder::callback_to_python_holder(PyObject* obj)
+      : m_held(obj)
+  {
+  }
+  
+  inline PyObject* callback_to_python_holder::get() const
+  {
+      return m_held.get();
+  }
+}
+
+}}} // namespace boost::python::converter
+
+#endif // CALLBACK_TO_PYTHON_BASE_DWA200237_HPP

include/boost/python/converter/constructor_function.hpp

@@ -0,0 +1,18 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef CONSTRUCTOR_FUNCTION_DWA200278_HPP
+# define CONSTRUCTOR_FUNCTION_DWA200278_HPP
+
+namespace boost { namespace python { namespace converter { 
+
+// Declares the type of functions used to construct C++ objects for
+// rvalue from_python conversions.
+struct rvalue_from_python_stage1_data;
+typedef void (*constructor_function)(PyObject* source, rvalue_from_python_stage1_data*);
+
+}}} // namespace boost::python::converter
+
+#endif // CONSTRUCTOR_FUNCTION_DWA200278_HPP

include/boost/python/converter/convertible_function.hpp

@@ -0,0 +1,15 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef CONVERTIBLE_FUNCTION_DWA200278_HPP
+# define CONVERTIBLE_FUNCTION_DWA200278_HPP
+
+namespace boost { namespace python { namespace converter { 
+
+typedef void* (*convertible_function)(PyObject*);
+    
+}}} // namespace boost::python::converter
+
+#endif // CONVERTIBLE_FUNCTION_DWA200278_HPP

include/boost/python/converter/find_from_python.hpp

@@ -0,0 +1,29 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef FIND_FROM_PYTHON_DWA2002223_HPP
+# define FIND_FROM_PYTHON_DWA2002223_HPP
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/converter/from_python_stage1_data.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct lvalue_from_python_registration;
+struct rvalue_from_python_registration;
+
+BOOST_PYTHON_DECL void* find(
+    PyObject* source, lvalue_from_python_registration const*);
+
+BOOST_PYTHON_DECL rvalue_stage1_data find(
+    PyObject* source, rvalue_from_python_registration const*);
+
+BOOST_PYTHON_DECL rvalue_from_python_registration const* find_chain(
+    PyObject* source, rvalue_from_python_registration const*);
+
+}}} // namespace boost::python::converter
+
+#endif // FIND_FROM_PYTHON_DWA2002223_HPP

include/boost/python/converter/from_python.hpp

@@ -0,0 +1,43 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef FIND_FROM_PYTHON_DWA2002223_HPP
+# define FIND_FROM_PYTHON_DWA2002223_HPP
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/converter/rvalue_from_python_data.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct registration;
+struct rvalue_from_python_chain;
+
+BOOST_PYTHON_DECL void* get_lvalue_from_python(
+    PyObject* source, registration const&);
+
+BOOST_PYTHON_DECL rvalue_from_python_chain const* implicit_conversion_chain(
+    PyObject* source, registration const&);
+
+BOOST_PYTHON_DECL rvalue_from_python_stage1_data rvalue_from_python_stage1(
+    PyObject* source, registration const&);
+
+BOOST_PYTHON_DECL void* rvalue_from_python_stage2(
+    PyObject* source, rvalue_from_python_stage1_data&, registration const&);
+
+BOOST_PYTHON_DECL void* rvalue_result_from_python(
+    PyObject*, rvalue_from_python_stage1_data&);
+
+BOOST_PYTHON_DECL void* reference_result_from_python(PyObject*, registration const&);
+BOOST_PYTHON_DECL void* pointer_result_from_python(PyObject*, registration const&);
+
+BOOST_PYTHON_DECL void void_result_from_python(PyObject*);
+
+BOOST_PYTHON_DECL void throw_no_pointer_from_python(PyObject*, registration const&);
+BOOST_PYTHON_DECL void throw_no_reference_from_python(PyObject*, registration const&);
+
+}}} // namespace boost::python::converter
+
+#endif // FIND_FROM_PYTHON_DWA2002223_HPP

include/boost/python/converter/from_python_data.hpp

@@ -0,0 +1,129 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef FROM_PYTHON_AUX_DATA_DWA2002128_HPP
+# define FROM_PYTHON_AUX_DATA_DWA2002128_HPP
+
+# include <boost/python/detail/char_array.hpp>
+# include <boost/mpl/select_if.hpp>
+# include <boost/type_traits/same_traits.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/static_assert.hpp>
+# include <boost/python/converter/from_python_stage1_data.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/python/detail/destroy.hpp>
+# include <boost/preprocessor/list/for_each_i.hpp>
+# include <boost/preprocessor/tuple/to_list.hpp>
+# include <boost/preprocessor/cat.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+namespace detail
+{
+  template <class T> struct referent_size;
+  
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  
+  template <class T>
+  struct referent_size<T&>
+  {
+      BOOST_STATIC_CONSTANT(
+          std::size_t, value = sizeof(T));
+  };
+
+# else
+
+  template <class T> struct referent_size
+  {
+      static T f();
+      BOOST_STATIC_CONSTANT(std::size_t, value = sizeof(f()));
+  };
+  
+# endif
+  struct alignment_dummy;
+  typedef void (*function_ptr)();
+  typedef int (alignment_dummy::*member_ptr);
+  typedef int (alignment_dummy::*member_function_ptr)();
+
+# define BOOST_PYTHON_ALIGNMENT_TYPES BOOST_PP_TUPLE_TO_LIST( \
+        11, ( \
+        char, short, int, long, float, double, long double \
+        , void*, function_ptr, member_ptr, member_function_ptr))
+
+# define BOOST_PYTHON_CHOOSE_LOWER_SIZE(R,P,I,T) \
+        typename mpl::select_if_c< \
+           sizeof(T) <= target, T, char>::type BOOST_PP_CAT(t,I);
+           
+# define BOOST_PYTHON_CHOOSE_T(R,P,I,T) T BOOST_PP_CAT(t,I);
+           
+  template <std::size_t target>
+  union lower_size
+  {
+      BOOST_PP_LIST_FOR_EACH_I(
+          BOOST_PYTHON_CHOOSE_LOWER_SIZE
+          , ignored, BOOST_PYTHON_ALIGNMENT_TYPES)
+  };
+
+  template <class Align, std::size_t size>
+  union aligned_storage
+  {
+      Align align;
+      char bytes[size];
+  };
+
+  template <class Reference>
+  struct referent_storage
+  {
+      typedef lower_size<referent_size<Reference>::value> align_t;
+      typedef aligned_storage<align_t,referent_size<Reference>::value> type;
+  };
+}
+
+template <class T>
+struct rvalue_base_data
+{
+    rvalue_stage1_data stage1;
+    
+    typename detail::referent_storage<
+        typename add_reference<T>::type
+    >::type storage;
+};
+
+template <class T>
+struct rvalue_data : rvalue_base_data<T>
+{
+    rvalue_data(rvalue_stage1_data const&);
+    rvalue_data(void*);
+    ~rvalue_data();
+ private:
+    typedef typename add_reference<typename add_cv<T>::type>::type ref_type;
+};
+
+//
+// Implementataions
+//
+template <class T>
+inline rvalue_data<T>::rvalue_data(rvalue_stage1_data const& stage1)
+{
+    this->stage1 = stage1;
+}
+
+template <class T>
+inline rvalue_data<T>::rvalue_data(void* convertible)
+{
+    this->stage1.convertible = convertible;
+}
+
+template <class T>
+inline rvalue_data<T>::~rvalue_data()
+{
+    if (this->stage1.convertible == this->storage.bytes)
+        python::detail::destroy_reference<ref_type>(this->storage.bytes);
+}
+
+}}} // namespace boost::python::converter
+
+#endif // FROM_PYTHON_AUX_DATA_DWA2002128_HPP

include/boost/python/converter/from_python_function.hpp

@@ -0,0 +1,18 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef FROM_PYTHON_FUNCTION_DWA2002128_HPP
+# define FROM_PYTHON_FUNCTION_DWA2002128_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct rvalue_stage1_data;
+typedef void (*constructor_function)(PyObject* source, rvalue_stage1_data*);
+
+}}} // namespace boost::python::converter
+
+#endif // FROM_PYTHON_FUNCTION_DWA2002128_HPP

include/boost/python/converter/from_python_stage1_data.hpp

@@ -0,0 +1,21 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef FROM_PYTHON_STAGE1_DATA_DWA2002223_HPP
+# define FROM_PYTHON_STAGE1_DATA_DWA2002223_HPP
+
+# include <boost/python/converter/from_python_function.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct rvalue_stage1_data
+{
+    void* convertible;
+    constructor_function construct;
+};
+
+}}} // namespace boost::python::converter
+
+#endif // FROM_PYTHON_STAGE1_DATA_DWA2002223_HPP

include/boost/python/converter/implicit.hpp

@@ -0,0 +1,57 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef IMPLICIT_DWA2002326_HPP
+# define IMPLICIT_DWA2002326_HPP
+# include <boost/python/converter/rvalue_from_python_data.hpp>
+# include <boost/python/converter/registrations.hpp>
+# include <boost/python/converter/registered.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class Source, class Target>
+struct implicit
+{
+    static void* convertible(PyObject* obj)
+    {
+        // Find a converter chain which can produce a Source instance
+        // from obj. The user has told us that Source can be converted
+        // to Target, and instantiating construct() below, ensures
+        // that at compile-time.
+        return const_cast<rvalue_from_python_chain*>(
+            converter::implicit_conversion_chain(obj, registered<Source>::converters));
+    }
+      
+    static void construct(PyObject* obj, rvalue_from_python_stage1_data* data)
+    {
+        // This is the chain we got from the convertible step
+        rvalue_from_python_chain const* chain
+            = static_cast<rvalue_from_python_chain*>(data->convertible);
+
+        // Call the convertible function again
+        rvalue_from_python_data<Source> intermediate_data(chain->convertible(obj));
+          
+        // Use the result to construct the source type if the first
+        // converter was an rvalue converter.
+        if (chain->construct != 0)
+            chain->construct(obj, &intermediate_data.stage1);
+          
+        void* storage = ((rvalue_from_python_storage<Target>*)data)->storage.bytes;
+#   if !defined(BOOST_MSVC) || _MSC_FULL_VER != 13012108 // vc7.01 alpha workaround
+        new (storage) Target(*static_cast<Source*>(intermediate_data.stage1.convertible));
+#   else
+        Target x(*static_cast<Source*>(intermediate_data.stage1.convertible));
+        new (storage) Target(x);
+#   endif 
+
+        // record successful construction
+        data->convertible = storage;
+          
+    }
+};
+
+}}} // namespace boost::python::converter
+
+#endif // IMPLICIT_DWA2002326_HPP

include/boost/python/converter/lvalue_from_python_chain.hpp

@@ -0,0 +1,70 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef LVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP
+# define LVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP
+
+# include <boost/python/converter/pointer_type_id.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// Given T == U*cv&, T == U*, or T == U&, lvalue_from_python_chain<T>
+// declares a "templated global reference" to the lvalue from_python
+// converter chain for U. The optional bool second argument callback,
+// when true, removes special treatment for T == U*cv& so that the
+// converter for U* is found.
+namespace detail
+{
+  template <class T>
+  struct ptr_or_ptr_ref_lvalue_from_python_chain
+  {
+      static lvalue_from_python_registration*const& value;
+  };
+    
+  template <class T>
+  lvalue_from_python_registration*const&
+  ptr_or_ptr_ref_lvalue_from_python_chain<T>::value
+     = registry::lvalue_converters(pointer_type_id<T>());
+
+  template <class T>
+  struct ref_lvalue_from_python_chain
+  {
+      static lvalue_from_python_registration*const& value;
+  };
+
+  template <class T>
+  lvalue_from_python_registration*const&
+  ref_lvalue_from_python_chain<T>::value
+     = registry::lvalue_converters(undecorated_type_id<T>());
+
+  template <class T, bool callback>
+  struct select_lvalue_from_python_chain
+  {
+      BOOST_STATIC_CONSTANT(
+          bool, ptr
+          = !callback && boost::python::detail::is_reference_to_pointer<T>::value
+            || is_pointer<T>::value);
+
+      typedef typename add_reference<typename add_cv<T>::type>::type normalized;
+
+      typedef typename mpl::select_if_c<
+          ptr
+          , ptr_or_ptr_ref_lvalue_from_python_chain<normalized>
+          , ref_lvalue_from_python_chain<normalized>
+          >::type type;
+  };
+}
+
+template <class T, bool callback = false>
+struct lvalue_from_python_chain
+    : detail::select_lvalue_from_python_chain<T,callback>::type
+{
+};
+
+}}} // namespace boost::python::converter
+
+#endif // LVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP

include/boost/python/converter/obj_mgr_arg_from_python.hpp

@@ -0,0 +1,116 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef OBJ_MGR_ARG_FROM_PYTHON_DWA2002628_HPP
+# define OBJ_MGR_ARG_FROM_PYTHON_DWA2002628_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/detail/referent_storage.hpp>
+# include <boost/python/detail/destroy.hpp>
+# include <boost/python/detail/construct.hpp>
+# include <boost/python/converter/object_manager.hpp>
+# include <boost/python/detail/raw_pyobject.hpp>
+# include <boost/python/tag.hpp>
+
+//
+// arg_from_python converters for Python type wrappers, to be used as
+// base classes for specializations.
+//
+namespace boost { namespace python { namespace converter { 
+
+template <class T>
+struct object_manager_value_arg_from_python
+{
+    typedef T result_type;
+    
+    object_manager_value_arg_from_python(PyObject*);
+    bool convertible() const;
+    T operator()(PyObject*) const;
+ private:
+    PyObject* m_source;
+};
+
+// Used for converting reference-to-object-manager arguments from
+// python. The process used here is a little bit odd. Upon
+// construction, we build the object manager object in the m_result
+// object, *forcing* it to accept the source Python object by casting
+// its pointer to detail::borrowed_reference. This is supposed to
+// bypass any type checking of the source object. The convertible
+// check then extracts the owned object and checks it. If the check
+// fails, nothing else in the program ever gets to touch this strange
+// "forced" object.
+template <class Ref>
+struct object_manager_ref_arg_from_python
+{
+    typedef Ref result_type;
+    
+    object_manager_ref_arg_from_python(PyObject*);
+    bool convertible() const;
+    Ref operator()(PyObject*) const;
+    ~object_manager_ref_arg_from_python();
+ private:
+    typename python::detail::referent_storage<Ref>::type m_result;
+};
+
+//
+// implementations
+//
+
+template <class T>
+inline object_manager_value_arg_from_python<T>::object_manager_value_arg_from_python(PyObject* x)
+    : m_source(x)
+{
+}
+    
+template <class T>
+inline bool object_manager_value_arg_from_python<T>::convertible() const
+{
+    return object_manager_traits<T>::check(m_source);
+}
+
+template <class T>
+inline T object_manager_value_arg_from_python<T>::operator()(PyObject* x) const
+{
+    return T(python::detail::borrowed_reference(x));
+}
+
+template <class Ref>
+inline object_manager_ref_arg_from_python<Ref>::object_manager_ref_arg_from_python(PyObject* x)
+{
+    python::detail::construct_referent<Ref>(&m_result.bytes, python::detail::borrowed_reference(x));
+}
+
+template <class Ref>
+inline object_manager_ref_arg_from_python<Ref>::~object_manager_ref_arg_from_python()
+{
+    python::detail::destroy_referent<Ref>(this->m_result.bytes);
+}
+
+namespace detail
+{
+  template <class T>
+  inline bool object_manager_ref_check(T const& x)
+  {
+      return object_manager_traits<T>::check(get_managed_object(x, tag));
+  }
+}
+
+template <class Ref>
+inline bool object_manager_ref_arg_from_python<Ref>::convertible() const
+{
+    return detail::object_manager_ref_check(
+        python::detail::void_ptr_to_reference(this->m_result.bytes, (Ref(*)())0));
+}
+
+template <class Ref>
+inline Ref object_manager_ref_arg_from_python<Ref>::operator()(PyObject*) const
+{
+    return python::detail::void_ptr_to_reference(
+        this->m_result.bytes, (Ref(*)())0);
+}
+
+}}} // namespace boost::python::converter
+
+#endif // OBJ_MGR_ARG_FROM_PYTHON_DWA2002628_HPP

include/boost/python/converter/object_manager.hpp

@@ -0,0 +1,232 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef OBJECT_MANAGER_DWA2002614_HPP
+# define OBJECT_MANAGER_DWA2002614_HPP
+
+# include <boost/python/handle.hpp>
+# include <boost/python/cast.hpp>
+# include <boost/python/converter/pyobject_traits.hpp>
+# include <boost/type_traits/object_traits.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/python/detail/indirect_traits.hpp>
+
+// Facilities for dealing with types which always manage Python
+// objects. Some examples are object, list, str, et. al. Different
+// to_python/from_python conversion rules apply here because in
+// contrast to other types which are typically embedded inside a
+// Python object, these are wrapped around a Python object. For most
+// object managers T, a C++ non-const T reference argument does not
+// imply the existence of a T lvalue embedded in the corresponding
+// Python argument, since mutating member functions on T actually only
+// modify the held Python object.
+//
+// handle<T> is an object manager, though strictly speaking it should
+// not be. In other words, even though mutating member functions of
+// hanlde<T> actually modify the handle<T> and not the T object,
+// handle<T>& arguments of wrapped functions will bind to "rvalues"
+// wrapping the actual Python argument, just as with other object
+// manager classes. Making an exception for handle<T> is simply not
+// worth the trouble.
+//
+// borrowed<T> cv* is an object manager so that we can use the general
+// to_python mechanisms to convert raw Python object pointers to
+// python, without the usual semantic problems of using raw pointers.
+
+
+// Object Manager Concept requirements:
+//
+//    T is an Object Manager
+//    p is a PyObject*
+//    x is a T
+//
+//    * object_manager_traits<T>::is_specialized == true
+//
+//    * T(detail::borrowed_reference(p))
+//        Manages p without checking its type
+//
+//    * get_managed_object(x, boost::python::tag)
+//        Convertible to PyObject*
+//
+// Additional requirements if T can be converted from_python:
+//
+//    * T(object_manager_traits<T>::adopt(p))
+//        steals a reference to p, or throws a TypeError exception if
+//        p doesn't have an appropriate type. May assume p is non-null
+//
+//    * X::check(p)
+//        convertible to bool. True iff T(X::construct(p)) will not
+//        throw.
+
+// Forward declarations
+//
+namespace boost { namespace python
+{
+  namespace api
+  {
+    class object; 
+  }
+}}
+
+namespace boost { namespace python { namespace converter { 
+
+
+// Specializations for handle<T>
+template <class T>
+struct handle_object_manager_traits
+    : pyobject_traits<typename T::element_type>
+{
+ private:
+  typedef pyobject_traits<typename T::element_type> base;
+  
+ public:
+  BOOST_STATIC_CONSTANT(bool, is_specialized = true);
+
+  // Initialize with a null_ok pointer for efficiency, bypassing the
+  // null check since the source is always non-null.
+  static null_ok<typename T::element_type>* adopt(PyObject* p)
+  {
+      return python::allow_null(base::checked_downcast(p));
+  }
+};
+
+template <class T>
+struct default_object_manager_traits
+{
+    BOOST_STATIC_CONSTANT(
+        bool, is_specialized = python::detail::is_borrowed_ptr<T>::value
+        );
+};
+
+template <class T>
+struct object_manager_traits
+    : mpl::if_c<
+         is_handle<T>::value
+       , handle_object_manager_traits<T>
+       , default_object_manager_traits<T>
+    >::type
+{
+};
+
+//
+// Traits for detecting whether a type is an object manager or a
+// (cv-qualified) reference to an object manager.
+// 
+
+template <class T>
+struct is_object_manager
+{
+    BOOST_STATIC_CONSTANT(
+        bool, value = object_manager_traits<T>::is_specialized);
+};
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template <class T>
+struct is_reference_to_object_manager
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template <class T>
+struct is_reference_to_object_manager<T&>
+    : is_object_manager<T>
+{
+};
+
+template <class T>
+struct is_reference_to_object_manager<T const&>
+    : is_object_manager<T>
+{
+};
+
+template <class T>
+struct is_reference_to_object_manager<T volatile&>
+    : is_object_manager<T>
+{
+};
+
+template <class T>
+struct is_reference_to_object_manager<T const volatile&>
+    : is_object_manager<T>
+{
+};
+# else
+
+namespace detail
+{
+  typedef char (&yes_reference_to_object_manager)[1];
+  typedef char (&no_reference_to_object_manager)[2];
+
+  // A number of nastinesses go on here in order to work around MSVC6
+  // bugs.
+  template <class T>
+  struct is_object_manager_help
+  {
+      typedef typename mpl::if_c<
+          is_object_manager<T>::value
+          , yes_reference_to_object_manager
+          , no_reference_to_object_manager
+          >::type type;
+
+      // If we just use the type instead of the result of calling this
+      // function, VC6 will ICE.
+      static type call();
+  };
+
+  // A set of overloads for each cv-qualification. The same argument
+  // is passed twice: the first one is used to unwind the cv*, and the
+  // second one is used to avoid relying on partial ordering for
+  // overload resolution.
+  template <class U>
+  typename is_object_manager_help<U>
+  is_object_manager_helper(U*, void*);
+  
+  template <class U>
+  typename is_object_manager_help<U>
+  is_object_manager_helper(U const*, void const*);
+  
+  template <class U>
+  typename is_object_manager_help<U>
+  is_object_manager_helper(U volatile*, void volatile*);
+  
+  template <class U>
+  typename is_object_manager_help<U>
+  is_object_manager_helper(U const volatile*, void const volatile*);
+  
+  template <class T>
+  struct is_reference_to_object_manager_nonref
+  {
+      BOOST_STATIC_CONSTANT(bool, value = false);
+  };
+
+  template <class T>
+  struct is_reference_to_object_manager_ref
+  {
+      static T sample_object;
+      BOOST_STATIC_CONSTANT(
+        bool, value
+        = (sizeof(is_object_manager_helper(&sample_object, &sample_object).call())
+            == sizeof(detail::yes_reference_to_object_manager)
+          )
+        );
+  };
+}
+
+template <class T>
+struct is_reference_to_object_manager
+{
+    typedef typename mpl::if_c<
+        is_reference<T>::value
+        , detail::is_reference_to_object_manager_ref<T>
+        , detail::is_reference_to_object_manager_nonref<T>
+    > chooser;
+
+    BOOST_STATIC_CONSTANT(bool, value = chooser::type::value);
+};
+# endif 
+
+}}} // namespace boost::python::converter
+
+#endif // OBJECT_MANAGER_DWA2002614_HPP

include/boost/python/converter/pointee_to_python_function.hpp

@@ -0,0 +1,51 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef POINTEE_TO_PYTHON_FUNCTION_DWA2002128_HPP
+# define POINTEE_TO_PYTHON_FUNCTION_DWA2002128_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/python/converter/to_python_function_type.hpp>
+# include <boost/python/converter/pointer_type_id.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// pointee_to_python_function --
+//
+// essentially a "templated global reference" which holds the
+// converter for converting a type to Python by-value. We "normalize"
+// T by adding "const volatile&" so that fewer global variables and
+// associated static initializations are generated.
+namespace detail
+{
+  template <class T>
+  struct pointee_to_python_function_base
+  {
+      static to_python_function_t const& value;
+  };
+  
+  template <class T>
+  to_python_function_t const&
+  pointee_to_python_function_base<T>::value
+        = converter::registry::get_to_python_function(pointer_type_id<T>());
+}
+
+template <class T>
+struct pointee_to_python_function
+    : detail::pointee_to_python_function_base<
+        typename add_reference<
+          typename add_cv<T>::type
+        >::type
+      >
+{
+};
+
+}}} // namespace boost::python::converter
+
+#endif // POINTEE_TO_PYTHON_FUNCTION_DWA2002128_HPP

include/boost/python/converter/pointer_type_id.hpp

@@ -0,0 +1,69 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef POINTER_TYPE_ID_DWA2002222_HPP
+# define POINTER_TYPE_ID_DWA2002222_HPP
+
+# include <boost/python/type_id.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+namespace detail
+{
+  template <bool is_ref = false>
+  struct pointer_typeid_select
+  {
+      template <class T>
+      static inline type_info execute(T*(*)() = 0)
+      {
+          return type_id<T>();
+      }
+  };
+
+  template <>
+  struct pointer_typeid_select<true>
+  {
+      template <class T>
+      static inline type_info execute(T* const volatile&(*)() = 0)
+      {
+          return type_id<T>();
+      }
+    
+      template <class T>
+      static inline type_info execute(T*volatile&(*)() = 0)
+      {
+          return type_id<T>();
+      }
+    
+      template <class T>
+      static inline type_info execute(T*const&(*)() = 0)
+      {
+          return type_id<T>();
+      }
+
+      template <class T>
+      static inline type_info execute(T*&(*)() = 0)
+      {
+          return type_id<T>();
+      }
+  };
+}
+
+// Usage: pointer_type_id<T>()
+//
+// Returns a type_info associated with the type pointed
+// to by T, which may be a pointer or a reference to a pointer.
+template <class T>
+type_info pointer_type_id(T(*)() = 0)
+{
+    return detail::pointer_typeid_select<
+          is_reference<T>::value
+        >::execute((T(*)())0);
+}
+
+}}} // namespace boost::python::converter
+
+#endif // POINTER_TYPE_ID_DWA2002222_HPP

include/boost/python/converter/pyobject_traits.hpp

@@ -0,0 +1,42 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef PYOBJECT_TRAITS_DWA2002720_HPP
+# define PYOBJECT_TRAITS_DWA2002720_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/converter/pyobject_type.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class> struct pyobject_traits;
+
+template <>
+struct pyobject_traits<PyObject>
+{
+    // All objects are convertible to PyObject
+    static bool check(PyObject*) { return true; }
+    static PyObject* checked_downcast(PyObject* x) { return x; }
+};
+
+//
+// Specializations
+//
+
+# define BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(T)                  \
+    template <> struct pyobject_traits<Py##T##Object>           \
+        : pyobject_type<Py##T##Object, &Py##T##_Type> {}
+
+// This is not an exhaustive list; should be expanded.
+BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Type);
+BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(List);
+BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Int);
+BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Long);
+BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Dict);
+BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Tuple);
+
+}}} // namespace boost::python::converter
+
+#endif // PYOBJECT_TRAITS_DWA2002720_HPP

include/boost/python/converter/pyobject_type.hpp

@@ -0,0 +1,36 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef PYOBJECT_TYPE_DWA2002720_HPP
+# define PYOBJECT_TYPE_DWA2002720_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/cast.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+BOOST_PYTHON_DECL PyObject* checked_downcast_impl(PyObject*, PyTypeObject*);
+
+// Used as a base class for specializations which need to provide
+// Python type checking capability.
+template <class Object, PyTypeObject* pytype>
+struct pyobject_type
+{
+    static bool check(PyObject* x)
+    {
+        return ::PyObject_IsInstance(x, (PyObject*)pytype);
+    }
+
+    static Object* checked_downcast(PyObject* x)
+    {
+        return python::downcast<Object>(
+            (checked_downcast_impl)(x, pytype)
+            );
+    }
+};
+
+}}} // namespace boost::python::converter
+
+#endif // PYOBJECT_TYPE_DWA2002720_HPP

include/boost/python/converter/pytype_arg_from_python.hpp

@@ -0,0 +1,99 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef PYTYPE_ARG_FROM_PYTHON_DWA2002628_HPP
+# define PYTYPE_ARG_FROM_PYTHON_DWA2002628_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+
+//
+// arg_from_python converters for Python type wrappers, to be used as
+// base classes for specializations.
+//
+namespace boost { namespace python { namespace converter { 
+
+template <PyTypeObject* python_type>
+struct pytype_arg_from_python
+{
+    pytype_arg_from_python(PyObject*);
+    bool convertible() const;
+ private:
+    PyObject* m_src;
+};
+
+// rvalue converter base
+template <class Wrapper, PyTypeObject* python_type>
+struct pytype_wrapper_value_arg_from_python
+    : pytype_arg_from_python<python_type>
+{
+    typedef Wrapper result_type;
+    
+    pytype_wrapper_value_arg_from_python(PyObject*);
+    Wrapper operator()(PyObject*) const;
+};
+
+// Special case for Wrapper& - must store an lvalue internally. This
+// OK because the entire state of the object is actually in the Python
+// object.
+template <class Wrapper, PyTypeObject* python_type>
+struct pytype_wrapper_ref_arg_from_python
+    : pytype_arg_from_python<python_type>
+{
+    typedef Wrapper& result_type;
+    
+    pytype_wrapper_ref_arg_from_python(PyObject*);
+    Wrapper& operator()(PyObject*) const;
+ private:
+    mutable Wrapper m_result;
+};
+
+//
+// implementations
+//
+
+template <PyTypeObject* python_type>
+inline pytype_arg_from_python<python_type>::pytype_arg_from_python(PyObject* x)
+    : m_src(x)
+{
+}
+
+template <PyTypeObject* python_type>
+inline bool pytype_arg_from_python<python_type>::convertible() const
+{
+    return PyObject_IsInstance(m_src, (PyObject*)python_type);
+}
+
+template <class Wrapper, PyTypeObject* python_type>
+pytype_wrapper_value_arg_from_python<Wrapper,python_type>::pytype_wrapper_value_arg_from_python(
+    PyObject* p)
+    : pytype_arg_from_python<python_type>(p)
+{
+}
+
+template <class Wrapper, PyTypeObject* python_type>
+Wrapper pytype_wrapper_value_arg_from_python<Wrapper,python_type>::operator()(
+    PyObject* x) const
+{
+    return Wrapper(python::detail::borrowed_reference(x));
+}
+
+template <class Wrapper, PyTypeObject* python_type>
+pytype_wrapper_ref_arg_from_python<Wrapper,python_type>::pytype_wrapper_ref_arg_from_python(
+    PyObject* p)
+    : pytype_arg_from_python<python_type>(p)
+      , m_result(python::detail::borrowed_reference(p))
+{
+}
+
+template <class Wrapper, PyTypeObject* python_type>
+Wrapper& pytype_wrapper_ref_arg_from_python<Wrapper,python_type>::operator()(
+    PyObject* x) const
+{
+    return m_result;
+}
+
+}}} // namespace boost::python::converter
+
+#endif // PYTYPE_ARG_FROM_PYTHON_DWA2002628_HPP

include/boost/python/converter/pytype_object_mgr_traits.hpp

@@ -0,0 +1,43 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef PYTYPE_OBJECT_MANAGER_TRAITS_DWA2002716_HPP
+# define PYTYPE_OBJECT_MANAGER_TRAITS_DWA2002716_HPP
+
+# include <boost/python/detail/raw_pyobject.hpp>
+# include <boost/python/cast.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/converter/pyobject_type.hpp>
+# include <boost/python/errors.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// Provide a forward declaration as a convenience for clients, who all
+// need it.
+template <class T> struct object_manager_traits;
+
+// Derive specializations of object_manager_traits from this class
+// when T is an object manager for a particular Python type hierarchy.
+//
+template <PyTypeObject* pytype, class T>
+struct pytype_object_manager_traits
+    : pyobject_type<T, pytype> // provides check()
+{
+    BOOST_STATIC_CONSTANT(bool, is_specialized = true);
+    static inline python::detail::new_reference adopt(PyObject*);
+};
+
+//
+// implementations
+//
+template <PyTypeObject* pytype, class T>
+inline python::detail::new_reference pytype_object_manager_traits<pytype,T>::adopt(PyObject* x)
+{
+    return python::detail::new_reference(python::pytype_check(pytype, x));
+}
+
+}}} // namespace boost::python::converter
+
+#endif // PYTYPE_OBJECT_MANAGER_TRAITS_DWA2002716_HPP

include/boost/python/converter/registered.hpp

@@ -0,0 +1,54 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef REGISTERED_DWA2002710_HPP
+# define REGISTERED_DWA2002710_HPP
+# include <boost/python/type_id.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/python/converter/registrations.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct registration;
+
+namespace detail
+{
+  template <class T>
+  struct registered_base
+  {
+      static registration const& converters;
+  };
+}
+
+template <class T>
+struct registered
+    : detail::registered_base<
+        typename add_reference<
+           typename add_cv<T>::type
+        >::type
+    >
+{
+};
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+// collapses a few more types to the same static instance
+template <class T>
+struct registered<T&> : registered<T> {};
+# endif
+
+//
+// implementations
+//
+namespace detail
+{
+  template <class T>
+  registration const& registered_base<T>::converters
+     = registry::lookup(type_id<T>());
+}
+}}} // namespace boost::python::converter
+
+#endif // REGISTERED_DWA2002710_HPP

include/boost/python/converter/registered_pointee.hpp

@@ -0,0 +1,63 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef REGISTERED_POINTEE_DWA2002710_HPP
+# define REGISTERED_POINTEE_DWA2002710_HPP
+# include <boost/python/converter/registered.hpp>
+# include <boost/python/converter/pointer_type_id.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct registration;
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template <class T>
+struct registered_pointee
+    : registered<
+        typename remove_pointer<
+           typename remove_cv<
+              typename remove_reference<T>::type
+           >::type
+        >::type
+    >
+{
+};
+# else
+namespace detail
+{
+  template <class T>
+  struct registered_pointee_base
+  {
+      static registration const& converters;
+  };
+}
+
+template <class T>
+struct registered_pointee
+    : detail::registered_pointee_base<
+        typename add_reference<
+           typename add_cv<T>::type
+        >::type
+    >
+{
+};
+
+//
+// implementations
+//
+namespace detail
+{
+  template <class T>
+  registration const& registered_pointee_base<T>::converters
+     = registry::lookup(pointer_type_id<T>());
+}
+
+# endif 
+}}} // namespace boost::python::converter
+
+#endif // REGISTERED_POINTEE_DWA2002710_HPP

include/boost/python/converter/registrations.hpp

@@ -0,0 +1,67 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef REGISTRATIONS_DWA2002223_HPP
+# define REGISTRATIONS_DWA2002223_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/converter/convertible_function.hpp>
+# include <boost/python/converter/constructor_function.hpp>
+# include <boost/python/converter/to_python_function_type.hpp>
+# include <boost/python/type_id.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct lvalue_from_python_chain
+{
+    convertible_function convert;
+    lvalue_from_python_chain* next;
+};
+
+struct rvalue_from_python_chain
+{
+    convertible_function convertible;
+    constructor_function construct;
+    rvalue_from_python_chain* next;
+};
+
+struct registration
+{
+    explicit registration(type_info);
+    
+    const python::type_info target_type;
+
+    // The chain of eligible from_python converters when an lvalue is required
+    lvalue_from_python_chain* lvalue_chain;
+
+    // The chain of eligible from_python converters when an rvalue is acceptable
+    rvalue_from_python_chain* rvalue_chain;
+    
+    // The unique to_python converter for the associated C++ type.
+    to_python_function_t to_python;
+
+    // The class object associated with this type
+    PyTypeObject* class_object;
+};
+
+//
+// implementations
+//
+inline registration::registration(type_info target_type)
+    : target_type(target_type)
+      , lvalue_chain(0)
+      , rvalue_chain(0)
+      , to_python(0)
+      , class_object(0)
+{}
+
+inline bool operator<(registration const& lhs, registration const& rhs)
+{
+    return lhs.target_type < rhs.target_type;
+}
+
+}}} // namespace boost::python::converter
+
+#endif // REGISTRATIONS_DWA2002223_HPP

include/boost/python/converter/registry.hpp

@@ -0,0 +1,52 @@
+//  Copyright David Abrahams 2001. Permission to copy, use,
+//  modify, sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+#ifndef REGISTRY_DWA20011127_HPP
+# define REGISTRY_DWA20011127_HPP
+# include <boost/python/type_id.hpp>
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/converter/to_python_function_type.hpp>
+# include <boost/python/converter/rvalue_from_python_data.hpp>
+# include <boost/python/converter/constructor_function.hpp>
+# include <boost/python/converter/convertible_function.hpp>
+
+namespace boost { namespace python { namespace converter {
+
+struct registration;
+
+// This namespace acts as a sort of singleton
+namespace registry
+{
+  // Get the registration corresponding to the type, creating it if neccessary
+  BOOST_PYTHON_DECL registration const& lookup(type_info);
+
+  // Return a pointer to the corresponding registration, if one exists
+  BOOST_PYTHON_DECL registration const* query(type_info);
+  
+  BOOST_PYTHON_DECL void insert(to_python_function_t, type_info);
+
+  // Insert an lvalue from_python converter
+  BOOST_PYTHON_DECL void insert(void* (*convert)(PyObject*), type_info);
+
+  // Insert an rvalue from_python converter
+  BOOST_PYTHON_DECL void insert(
+      convertible_function
+      , constructor_function
+      , type_info
+      );
+  
+  // Insert an rvalue from_python converter at the tail of the
+  // chain. Used for implicit conversions
+  BOOST_PYTHON_DECL void push_back(
+      convertible_function
+      , constructor_function
+      , type_info
+      );
+}
+
+}}} // namespace boost::python::converter
+
+#endif // REGISTRY_DWA20011127_HPP

include/boost/python/converter/return_from_python.hpp

@@ -0,0 +1,151 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef RETURN_FROM_PYTHON_DWA200265_HPP
+# define RETURN_FROM_PYTHON_DWA200265_HPP
+
+# include <boost/python/converter/from_python.hpp>
+# include <boost/python/converter/rvalue_from_python_data.hpp>
+# include <boost/python/converter/registered.hpp>
+# include <boost/python/converter/registered_pointee.hpp>
+# include <boost/python/detail/void_ptr.hpp>
+# include <boost/call_traits.hpp>
+# include <boost/python/detail/void_return.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class T> struct is_object_manager;
+
+namespace detail
+{
+  template <class T>
+  struct return_pointer_from_python
+  {
+      typedef T result_type;
+      T operator()(PyObject*) const;
+  };
+  
+  template <class T>
+  struct return_reference_from_python
+  {
+      typedef T result_type;
+      T operator()(PyObject*) const;
+  };
+  
+  template <class T>
+  struct return_rvalue_from_python
+  {
+      typedef typename call_traits<T>::param_type result_type;
+      return_rvalue_from_python();
+      result_type operator()(PyObject*);
+   private:
+      rvalue_from_python_data<T> m_data;
+  };
+  
+  template <class T>
+  struct return_object_manager_from_python
+  {
+      typedef T result_type;
+      result_type operator()(PyObject*) const;
+  };
+  
+  template <class T>
+  struct select_return_from_python
+  {
+      BOOST_STATIC_CONSTANT(
+          bool, obj_mgr = is_object_manager<T>::value);
+
+      BOOST_STATIC_CONSTANT(
+          bool, ptr = is_pointer<T>::value);
+    
+      BOOST_STATIC_CONSTANT(
+          bool, ref = is_reference<T>::value);
+
+      typedef typename mpl::if_c<
+          obj_mgr
+          , return_object_manager_from_python<T>
+          , typename mpl::if_c<
+              ptr
+              , return_pointer_from_python<T>
+              , typename mpl::if_c<
+                  ref
+                  , return_reference_from_python<T>
+                  , return_rvalue_from_python<T>
+                >::type
+            >::type
+         >::type type;
+  };
+}
+
+template <class T>
+struct return_from_python
+    : detail::select_return_from_python<T>::type
+{
+};
+
+// Specialization as a convenience for call and call_method
+template <>
+struct return_from_python<void>
+{
+    typedef python::detail::returnable<void>::type result_type;
+    
+    result_type operator()(PyObject* x) const
+    {
+        (void_result_from_python)(x);
+# ifdef BOOST_NO_VOID_RETURNS
+        return result_type();
+# endif 
+    }
+};
+
+//
+// Implementations
+//
+namespace detail
+{
+  template <class T>
+  inline return_rvalue_from_python<T>::return_rvalue_from_python()
+      : m_data(
+          const_cast<registration*>(&registered<T>::converters)
+          )
+  {
+  }
+  
+  template <class T>
+  inline typename return_rvalue_from_python<T>::result_type
+  return_rvalue_from_python<T>::operator()(PyObject* obj)
+  {
+      return *(T*)
+          (rvalue_result_from_python)(obj, m_data.stage1);
+  }
+
+  template <class T>
+  inline T return_reference_from_python<T>::operator()(PyObject* obj) const
+  {
+      return python::detail::void_ptr_to_reference(
+          (reference_result_from_python)(obj, registered<T>::converters)
+          , (T(*)())0);
+  }
+
+  template <class T>
+  inline T return_pointer_from_python<T>::operator()(PyObject* obj) const
+  {
+      return T(
+          (pointer_result_from_python)(obj, registered_pointee<T>::converters)
+          );
+  }
+
+  template <class T>
+  inline T return_object_manager_from_python<T>::operator()(PyObject* obj) const
+  {
+      return T(
+          object_manager_traits<T>::adopt(obj)
+          );
+  }
+}
+  
+}}} // namespace boost::python::converter
+
+#endif // RETURN_FROM_PYTHON_DWA200265_HPP

include/boost/python/converter/rvalue_from_python_chain.hpp

@@ -0,0 +1,39 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef RVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP
+# define RVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP
+# include <boost/python/converter/registry.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+namespace detail
+{
+  template <class T>
+  struct rvalue_from_python_chain_impl
+  {
+      static rvalue_from_python_registration*const& value;
+  };
+
+  template <class T>
+  rvalue_from_python_registration*const& rvalue_from_python_chain_impl<T>::value
+      = registry::rvalue_converters(undecorated_type_id<T>());
+}
+
+template <class T>
+struct rvalue_from_python_chain
+    : detail::rvalue_from_python_chain_impl<
+        typename add_reference<
+          typename add_cv<T>::type
+        >::type
+      >
+{
+};
+
+}}} // namespace boost::python::converter
+
+#endif // RVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP

include/boost/python/converter/rvalue_from_python_data.hpp

@@ -0,0 +1,140 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef FROM_PYTHON_AUX_DATA_DWA2002128_HPP
+# define FROM_PYTHON_AUX_DATA_DWA2002128_HPP
+
+# include <boost/python/converter/constructor_function.hpp>
+# include <boost/python/detail/referent_storage.hpp>
+# include <boost/python/detail/destroy.hpp>
+# include <boost/static_assert.hpp>
+# include <boost/type_traits/add_reference.hpp>
+# include <boost/type_traits/add_cv.hpp>
+# include <cstddef>
+
+// Data management for potential rvalue conversions from Python to C++
+// types. When a client requests a conversion to T* or T&, we
+// generally require that an object of type T exists in the source
+// Python object, and the code here does not apply**. This implements
+// conversions which may create new temporaries of type T. The classic
+// example is a conversion which converts a Python tuple to a
+// std::vector. Since no std::vector lvalue exists in the Python
+// object -- it must be created "on-the-fly" by the converter, and
+// which must manage the lifetime of the created object.
+//
+// Note that the client is not precluded from using a registered
+// lvalue conversion to T in this case. In other words, we will
+// happily accept a Python object which /does/ contain a std::vector
+// lvalue, provided an appropriate converter is registered. So, while
+// this is an rvalue conversion from the client's point-of-view, the
+// converter registry may serve up lvalue or rvalue conversions for
+// the target type.
+//
+// ** C++ argument from_python conversions to T const& are an
+// exception to the rule for references: since in C++, const
+// references can bind to temporary rvalues, we allow rvalue
+// converters to be chosen when the target type is T const& for some
+// T.
+namespace boost { namespace python { namespace converter { 
+
+// Conversions begin by filling in and returning a copy of this
+// structure. The process looks up a converter in the rvalue converter
+// registry for the target type. It calls the convertible() function
+// of each registered converter, passing the source PyObject* as an
+// argument, until a non-null result is returned. This result goes in
+// the convertible field, and the converter's construct() function is
+// stored in the construct field.
+//
+// If no appropriate converter is found, conversion fails and the
+// convertible field is null. When used in argument conversion for
+// wrapped C++ functions, it causes overload resolution to reject the
+// current function but not to fail completely. If an exception is
+// thrown, overload resolution stops and the exception propagates back
+// through the caller.
+//
+// If an lvalue converter is matched, its convertible() function is
+// expected to return a pointer to the stored T object; its
+// construct() function will be NULL. The convertible() function of
+// rvalue converters may return any non-singular pointer; the actual
+// target object will only be available once the converter's
+// construct() function is called.
+struct rvalue_from_python_stage1_data
+{
+    void* convertible;
+    constructor_function construct;
+};
+
+// Augments rvalue_from_python_stage1_data by adding storage for
+// constructing an object of remove_reference<T>::type. The
+// construct() function of rvalue converters (stored in m_construct
+// above) will cast the rvalue_from_python_stage1_data to an
+// appropriate instantiation of this template in order to access that
+// storage.
+template <class T>
+struct rvalue_from_python_storage
+{
+    rvalue_from_python_stage1_data stage1;
+
+    // Storage for the result, in case an rvalue must be constructed
+    typename python::detail::referent_storage<
+        typename add_reference<T>::type
+    >::type storage;
+};
+
+// Augments rvalue_from_python_storage<T> with a destructor. If
+// stage1.convertible == storage.bytes, it indicates that an object of
+// remove_reference<T>::type has been constructed in storage and
+// should will be destroyed in ~rvalue_from_python_data(). It is
+// crucial that successful rvalue conversions establish this equality
+// and that unsuccessful ones do not.
+template <class T>
+struct rvalue_from_python_data : rvalue_from_python_storage<T>
+{
+# if (!defined(__MWERKS__) || __MWERKS__ >= 0x3000) \
+        && (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 245) \
+        && (!defined(__DECCXX_VER) || __DECCXX_VER > 60590014)
+    // This must always be a POD struct with m_data its first member.
+    BOOST_STATIC_ASSERT(offsetof(rvalue_from_python_storage<T>,stage1) == 0);
+# endif
+    
+    // The usual constructor 
+    rvalue_from_python_data(rvalue_from_python_stage1_data const&);
+
+    // This constructor just sets m_convertible -- used by
+    // implicitly_convertible<> to perform the final step of the
+    // conversion, where the construct() function is already known.
+    rvalue_from_python_data(void* convertible);
+
+    // Destroys any object constructed in the storage.
+    ~rvalue_from_python_data();
+ private:
+    typedef typename add_reference<typename add_cv<T>::type>::type ref_type;
+};
+
+//
+// Implementataions
+//
+template <class T>
+inline rvalue_from_python_data<T>::rvalue_from_python_data(rvalue_from_python_stage1_data const& stage1)
+{
+    this->stage1 = stage1;
+}
+
+template <class T>
+inline rvalue_from_python_data<T>::rvalue_from_python_data(void* convertible)
+{
+    this->stage1.convertible = convertible;
+}
+
+template <class T>
+inline rvalue_from_python_data<T>::~rvalue_from_python_data()
+{
+    if (this->stage1.convertible == this->storage.bytes)
+        python::detail::destroy_referent<ref_type>(this->storage.bytes);
+}
+
+}}} // namespace boost::python::converter
+
+#endif // FROM_PYTHON_AUX_DATA_DWA2002128_HPP

include/boost/python/converter/smart_ptr.hpp

@@ -0,0 +1,70 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef SMART_PTR_DWA2002123_HPP
+# define SMART_PTR_DWA2002123_HPP
+
+# include <boost/python/converter/class.hpp>
+# include <boost/python/object/pointer_holder.hpp>
+namespace boost { namespace python { namespace converter { 
+
+template <class Pointer, class Value>
+class smart_ptr_wrapper
+    : wrapper<Pointer const&>
+{
+    smart_ptr_wrapper(ref const& type_)
+        : m_class_object(type_)
+    {
+        assert(type_->ob_type == (PyTypeObject*)class_metatype().get());
+    }
+    
+    PyObject* convert(Pointer x) const;
+    
+ private:
+    ref m_class_object;
+    
+    smart_ptr_converters();
+}
+
+
+//
+// implementations
+//
+
+template <class Pointer, class Value>
+PyObject* smart_ptr_wrapper<Pointer,Value>::convert(Pointer x) const
+{
+    if (x.operator->() == 0)
+        return detail::none();
+        
+    // Don't call the type to do the construction, since that
+    // would require the registration of an __init__ copy
+    // constructor. Instead, just construct the object in place.
+    PyObject* raw_result = (PyObject*)PyObject_New(
+        instance, (PyTypeObject*)m_class_object.get());
+        
+    if (raw_result == 0)
+        return 0;
+
+    // Everything's OK; Bypass NULL checks but guard against
+    // exceptions.
+    ref result(raw_result, ref::allow_null());
+
+    // Build a value_holder to contain the object using the copy
+    // constructor
+    objects::pointer_holder<Pointer,Value>*
+        p = new objects::pointer_holder<Pointer,Value>(x);
+
+    // Install it in the instance
+    p->install(raw_result);
+
+    // Return the new result
+    return result.release();
+}
+    
+
+}}} // namespace boost::python::converter
+
+#endif // SMART_PTR_DWA2002123_HPP

include/boost/python/converter/to_python_function.hpp

@@ -0,0 +1,50 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef TO_PYTHON_FUNCTION_DWA2002128_HPP
+# define TO_PYTHON_FUNCTION_DWA2002128_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/python/converter/to_python_function_type.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// to_python_function --
+//
+// essentially a "templated global reference" which holds the
+// converter for converting a type to Python by-value. We "normalize"
+// T by adding "const volatile&" so that fewer global variables and
+// associated static initializations are generated.
+namespace detail
+{
+  template <class T>
+  struct to_python_function_base
+  {
+      static to_python_function_t const& value;
+  };
+  
+  template <class T>
+  to_python_function_t const&
+  to_python_function_base<T>::value
+        = converter::registry::get_to_python_function(undecorated_type_id<T>());
+}
+
+template <class T>
+struct to_python_function
+    : detail::to_python_function_base<
+        typename add_reference<
+          typename add_cv<T>::type
+        >::type
+      >
+{
+};
+
+}}} // namespace boost::python::converter
+
+#endif // TO_PYTHON_FUNCTION_DWA2002128_HPP

include/boost/python/converter/to_python_function_type.hpp

@@ -0,0 +1,30 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef TO_PYTHON_FUNCTION_TYPE_DWA200236_HPP
+# define TO_PYTHON_FUNCTION_TYPE_DWA200236_HPP
+# include <boost/python/detail/wrap_python.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// The type of stored function pointers which actually do conversion
+// by-value. The void* points to the object to be converted, and
+// type-safety is preserved through runtime registration.
+typedef PyObject* (*to_python_function_t)(void const*);
+
+// Given a typesafe to_python conversion function, produces a
+// to_python_function_t which can be registered in the usual way.
+template <class T, class ToPython>
+struct as_to_python_function
+{
+    static PyObject* convert(void const* x)
+    {
+        return ToPython::convert(*(T const*)x);
+    }
+};
+
+}}} // namespace boost::python::converter
+
+#endif // TO_PYTHON_FUNCTION_TYPE_DWA200236_HPP

include/boost/python/converter/type_id.hpp

@@ -0,0 +1,176 @@
+//  Copyright David Abrahams 2001. Permission to copy, use,
+//  modify, sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+#ifndef TYPE_ID_DWA20011127_HPP
+# define TYPE_ID_DWA20011127_HPP
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/python/detail/msvc_typeinfo.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+# include <boost/mpl/select_if.hpp>
+# include <boost/operators.hpp>
+# include <boost/type.hpp>
+# include <typeinfo>
+# include <iosfwd>
+# include <cstring>
+
+
+namespace boost { namespace python { namespace converter { 
+
+// for this compiler at least, cross-shared-library type_info
+// comparisons don't work, so use typeid(x).name() instead. It's not
+// yet clear what the best default strategy is.
+# if defined(__GNUC__) && __GNUC__ >= 3
+#  define BOOST_PYTHON_TYPE_ID_NAME
+# endif 
+
+// type ids which represent the same information as std::type_info
+// (i.e. the top-level reference and cv-qualifiers are stripped), but
+// which works across shared libraries.
+struct undecorated_type_id_t : totally_ordered<undecorated_type_id_t>
+{
+    undecorated_type_id_t(std::type_info const&);
+    
+    // default constructor needed to build arrays, etc.
+    undecorated_type_id_t();
+
+    bool operator<(undecorated_type_id_t const& rhs) const;
+    bool operator==(undecorated_type_id_t const& rhs) const;
+
+    char const* name() const;
+    friend BOOST_PYTHON_DECL std::ostream& operator<<(
+        std::ostream&, undecorated_type_id_t const&);
+    
+ private: // data members
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+    typedef char const* base_id_t;
+#  else
+    typedef std::type_info const* base_id_t;
+#  endif
+    
+    base_id_t m_base_type;
+};
+
+struct type_id_t : totally_ordered<type_id_t>
+{
+    enum decoration { const_ = 0x1, volatile_ = 0x2, reference = 0x4 };
+    
+    type_id_t(undecorated_type_id_t, decoration = decoration());
+
+    bool operator<(type_id_t const& rhs) const;
+    bool operator==(type_id_t const& rhs) const;
+
+    friend BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, type_id_t const&);
+
+    operator undecorated_type_id_t const&() const;
+ private: // type
+    typedef undecorated_type_id_t base_id_t;
+    
+ private: // data members
+    decoration m_decoration;
+    base_id_t m_base_type;
+};
+
+template <class T>
+inline undecorated_type_id_t undecorated_type_id(boost::type<T>* = 0)
+{
+    return undecorated_type_id_t(
+#  if (!defined(BOOST_MSVC) || BOOST_MSVC > 1300) && (!defined(BOOST_INTEL_CXX_VERSION) || BOOST_INTEL_CXX_VERSION > 600)
+        typeid(T)
+#  else // strip the decoration which msvc and Intel mistakenly leave in
+        python::detail::msvc_typeid<T>()
+#  endif 
+        );
+}
+
+template <class T>
+inline type_id_t type_id(boost::type<T>* = 0)
+{
+    return type_id_t(
+        undecorated_type_id<T>()
+        , type_id_t::decoration(
+            (is_const<T>::value || python::detail::is_reference_to_const<T>::value
+             ? type_id_t::const_ : 0)
+            | (is_volatile<T>::value || python::detail::is_reference_to_volatile<T>::value
+               ? type_id_t::volatile_ : 0)
+            | (is_reference<T>::value ? type_id_t::reference : 0)
+            )
+        );
+}
+
+inline undecorated_type_id_t::undecorated_type_id_t(std::type_info const& id)
+    : m_base_type(
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+        id.name()
+#  else
+        &id
+#  endif
+        )
+{
+}
+
+inline undecorated_type_id_t::undecorated_type_id_t()
+    : m_base_type()
+{
+}
+
+inline type_id_t::type_id_t(undecorated_type_id_t base_t, decoration decoration)
+    : m_decoration(decoration)
+    , m_base_type(base_t)
+{
+}
+
+inline bool undecorated_type_id_t::operator<(undecorated_type_id_t const& rhs) const
+{
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+    return std::strcmp(m_base_type, rhs.m_base_type) < 0;
+#  else
+    return m_base_type->before(*rhs.m_base_type);
+#  endif 
+}
+
+inline bool type_id_t::operator<(type_id_t const& rhs) const
+{
+    return m_decoration < rhs.m_decoration
+        || m_decoration == rhs.m_decoration
+           && m_base_type < rhs.m_base_type;
+}
+
+inline bool undecorated_type_id_t::operator==(undecorated_type_id_t const& rhs) const
+{
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+    return !std::strcmp(m_base_type, rhs.m_base_type);
+#  else
+    return *m_base_type == *rhs.m_base_type;
+#  endif 
+}
+
+inline bool type_id_t::operator==(type_id_t const& rhs) const
+{
+    return m_decoration == rhs.m_decoration && m_base_type == rhs.m_base_type;
+}
+
+inline type_id_t::operator undecorated_type_id_t const&() const
+{
+    return m_base_type;
+}
+
+inline char const* undecorated_type_id_t::name() const
+{
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+    return m_base_type;
+#  else
+    return m_base_type->name();
+#  endif 
+}
+
+
+BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, undecorated_type_id_t const&);
+BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, type_id_t const&);
+
+}}} // namespace boost::python::converter
+
+#endif // TYPE_ID_DWA20011127_HPP

include/boost/python/copy_const_reference.hpp

@@ -0,0 +1,42 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef COPY_CONST_REFERENCE_DWA2002131_HPP
+# define COPY_CONST_REFERENCE_DWA2002131_HPP
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/python/to_python_value.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  template <class R>
+  struct copy_const_reference_expects_a_const_reference_return_type
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+  {}
+# endif
+  ;
+}
+
+template <class T> struct to_python_value;
+
+struct copy_const_reference
+{
+    template <class T>
+    struct apply
+    {
+        typedef typename mpl::if_c<
+            detail::is_reference_to_const<T>::value
+            , to_python_value<T>
+            , detail::copy_const_reference_expects_a_const_reference_return_type<T>
+        >::type type;
+    };
+};
+
+
+}} // namespace boost::python
+
+#endif // COPY_CONST_REFERENCE_DWA2002131_HPP

include/boost/python/copy_mutable_reference.hpp

@@ -0,0 +1,41 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef COPY_MUTABLE_REFERENCE_DWA2002131_HPP
+# define COPY_MUTABLE_REFERENCE_DWA2002131_HPP
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/mpl/select_if.hpp>
+# include <boost/python/to_python_value.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  template <class R>
+  struct copy_mutable_reference_expects_a_reference_to_non_const_return_type
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+  {}
+# endif
+  ;
+}
+
+template <class T> struct to_python_value;
+
+struct copy_mutable_reference
+{
+    template <class T>
+    struct apply
+    {
+        typedef typename mpl::select_if_c<
+            detail::is_reference_to_non_const<T>::value
+            , to_python_value<T>
+            , detail::copy_mutable_reference_expects_a_reference_to_non_const_return_type<T>
+        >::type type;
+    };
+};
+
+}} // namespace boost::python
+
+#endif // COPY_MUTABLE_REFERENCE_DWA2002131_HPP

include/boost/python/copy_non_const_reference.hpp

@@ -0,0 +1,42 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef COPY_NON_CONST_REFERENCE_DWA2002131_HPP
+# define COPY_NON_CONST_REFERENCE_DWA2002131_HPP
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/python/to_python_value.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  template <class R>
+  struct copy_non_const_reference_expects_a_non_const_reference_return_type
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+  {}
+# endif
+  ;
+}
+
+template <class T> struct to_python_value;
+
+struct copy_non_const_reference
+{
+    template <class T>
+    struct apply
+    {
+        typedef typename mpl::if_c<
+            boost::python::detail::is_reference_to_non_const<T>::value
+            , to_python_value<T>
+            , detail::copy_non_const_reference_expects_a_non_const_reference_return_type<T>
+        >::type type;
+    };
+};
+
+
+}} // namespace boost::python
+
+#endif // COPY_NON_CONST_REFERENCE_DWA2002131_HPP

include/boost/python/cross_module.hpp

@@ -18,26 +18,32 @@
 # include <boost/python/class_builder.hpp>
 
 namespace boost { namespace python {
-    struct import_error : error_already_set {};
-    struct export_error : error_already_set {};
-}}
 
-namespace boost { namespace python { namespace detail {
+struct BOOST_PYTHON_DECL import_error: error_already_set {};
+struct BOOST_PYTHON_DECL export_error : error_already_set {};
+
+void BOOST_PYTHON_DECL throw_import_error();
+void BOOST_PYTHON_DECL throw_export_error();
+
+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 = 4;
-const int export_converters_api_minor = 1;
-extern const char* converters_attribute_name;
-void* import_converter_object(const std::string& module_name,
-                              const std::string& py_class_name,
-                              const std::string& attribute_name);
-void check_export_converters_api(const int importing_major,
-                                 const int importing_minor,
-                                 const int imported_major,
-                                 const int imported_minor);
+  const int export_converters_api_major = 4;
+  const int export_converters_api_minor = 1;
+  extern BOOST_PYTHON_DECL const char* converters_attribute_name;
+  BOOST_PYTHON_DECL void* import_converter_object(const std::string& module_name,
+                                const std::string& py_class_name,
+                                const std::string& attribute_name);
+  BOOST_PYTHON_DECL void check_export_converters_api(const int importing_major,
+                                   const int importing_minor,
+                                   const int imported_major,
+                                   const int imported_minor);
 
-}}}
+}
+
+}} // namespace boost::python
 
 // forward declaration
 namespace boost { namespace python { namespace detail {
@@ -168,7 +174,8 @@ 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();
+        throw_import_error();
+        return 0;
     }
 
     virtual T* from_python_Ts(PyObject* p, boost::python::type<T*> t) {
@@ -229,56 +236,56 @@ struct export_converter_object : export_converter_object_noncopyable<T>
     }
 };
 
-namespace detail {
+namespace detail
+{
 
 /* 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>
-{
- public:
-    inline import_extension_class(const char* module, const char* py_class) {
-      m_module = module;
-      m_py_class = py_class;
-    }
+*/
+  template <class T>
+  class import_extension_class
+      : public python_import_extension_class_converters<T>
+  {
+   public:
+      inline import_extension_class(const char* module, const char* py_class) {
+          m_module = module;
+          m_py_class = py_class;
+      }
 
-    static boost::python::export_converter_object_base<T>* get_converters();
+      static boost::python::export_converter_object_base<T>* get_converters();
 
-  private:
-    static std::string m_module;
-    static std::string m_py_class;
-    static boost::python::export_converter_object_base<T>* imported_converters;
-};
+   private:
+      static std::string m_module;
+      static std::string m_py_class;
+      static boost::python::export_converter_object_base<T>* imported_converters;
+  };
 
-template <class T> std::string import_extension_class<T>::m_module;
-template <class T> std::string import_extension_class<T>::m_py_class;
-template <class T>
-boost::python::export_converter_object_base<T>*
-import_extension_class<T>::imported_converters = 0;
+  template <class T> std::string import_extension_class<T>::m_module;
+  template <class T> std::string import_extension_class<T>::m_py_class;
+  template <class T>
+  boost::python::export_converter_object_base<T>*
+  import_extension_class<T>::imported_converters = 0;
 
-template <class T>
-boost::python::export_converter_object_base<T>*
-import_extension_class<T>::get_converters() {
-  if (imported_converters == 0) {
-    void* cobject
-      = import_converter_object(m_module, m_py_class,
-                                converters_attribute_name);
-    imported_converters
-      = static_cast<boost::python::export_converter_object_base<T>*>(cobject);
-    check_export_converters_api(
-      export_converters_api_major,
-      export_converters_api_minor,
-      imported_converters->get_api_major(),
-      imported_converters->get_api_minor());
+  template <class T>
+  boost::python::export_converter_object_base<T>*
+  import_extension_class<T>::get_converters() {
+      if (imported_converters == 0) {
+          void* cobject
+              = import_converter_object(m_module, m_py_class,
+                                        converters_attribute_name);
+          imported_converters
+              = static_cast<boost::python::export_converter_object_base<T>*>(cobject);
+          check_export_converters_api(
+              export_converters_api_major,
+              export_converters_api_minor,
+              imported_converters->get_api_major(),
+              imported_converters->get_api_minor());
+      }
+      return imported_converters;
   }
-  return imported_converters;
-}
-
 }}} // namespace boost::python::detail
 
 namespace boost { namespace python {

include/boost/python/data_members.hpp

@@ -0,0 +1,111 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef DATA_MEMBERS_DWA2002328_HPP
+# define DATA_MEMBERS_DWA2002328_HPP
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/python/return_value_policy.hpp>
+# include <boost/python/copy_non_const_reference.hpp>
+# include <boost/python/object/function_object.hpp>
+# include <boost/python/arg_from_python.hpp>
+# include <boost/bind.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  template <class Data, class Class, class Policies>
+  struct member
+  {
+      static PyObject* get(Data Class::*pm, PyObject* args_, PyObject*, Policies const& policies)
+      {
+          arg_from_python<Class*> c0(PyTuple_GET_ITEM(args_, 0));
+          if (!c0.convertible()) return 0;
+
+          // find the result converter
+          typedef typename Policies::result_converter result_converter;
+          typedef typename boost::add_reference<Data>::type source;
+          typename mpl::apply1<result_converter,source>::type cr;
+          if (!cr.convertible()) return 0;
+        
+          if (!policies.precall(args_)) return 0;
+
+          PyObject* result = cr( (c0(PyTuple_GET_ITEM(args_, 0)))->*pm );
+        
+          return policies.postcall(args_, result);
+      }
+  
+      static PyObject* set(Data Class::*pm, PyObject* args_, PyObject*, Policies const& policies)
+      {
+          // check that each of the arguments is convertible
+          arg_from_python<Class*> c0(PyTuple_GET_ITEM(args_, 0));
+          if (!c0.convertible()) return 0;
+
+          typedef typename add_const<Data>::type target1;
+          typedef typename add_reference<target1>::type target;
+          arg_from_python<target> c1(PyTuple_GET_ITEM(args_, 1));
+      
+          if (!c1.convertible()) return 0;
+
+          if (!policies.precall(args_)) return 0;
+
+          (c0(PyTuple_GET_ITEM(args_, 0)))->*pm = c1(PyTuple_GET_ITEM(args_, 1));
+        
+          return policies.postcall(args_, detail::none());
+      }
+  };
+}
+
+template <class C, class D>
+object make_getter(D C::*pm)
+{
+    typedef return_value_policy<copy_non_const_reference> default_policy;
+    
+    return objects::function_object(
+        ::boost::bind(
+            &detail::member<D,C,default_policy>::get, pm, _1, _2
+            , default_policy())
+        , 1);
+        
+}
+
+template <class C, class D, class Policies>
+object make_getter(D C::*pm, Policies const& policies)
+{
+    return objects::function_object(
+            ::boost::bind(
+                &detail::member<D,C,Policies>::get, pm, _1, _2
+                , policies)
+        , 1);
+}
+
+template <class C, class D>
+object make_setter(D C::*pm)
+{
+    return objects::function_object(
+        ::boost::bind(
+            &detail::member<D,C,default_call_policies>::set, pm, _1, _2
+            , default_call_policies())
+        , 2);
+}
+
+template <class C, class D, class Policies>
+object make_setter(D C::*pm, Policies const& policies)
+{
+    return objects::function_object(
+        ::boost::bind(
+            &detail::member<D,C,Policies>::set, pm, _1, _2
+            , policies)
+        , 2);
+}
+
+    
+}} // namespace boost::python
+
+#endif // DATA_MEMBERS_DWA2002328_HPP

include/boost/python/def.hpp

@@ -0,0 +1,94 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef DEF_DWA200292_HPP
+# define DEF_DWA200292_HPP
+
+# include <boost/python/object_fwd.hpp>
+# include <boost/python/make_function.hpp>
+# include <boost/python/detail/def_helper.hpp>
+# include <boost/python/detail/defaults_def.hpp>
+# include <boost/python/scope.hpp>
+# include <boost/python/signature.hpp>
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  void BOOST_PYTHON_DECL scope_setattr_doc(char const* name, object const& obj, char const* doc);
+
+  template <class Fn, class CallPolicyOrDoc>
+  void
+  dispatch_def(
+      void const*,
+      char const* name,
+      Fn fn,
+      CallPolicyOrDoc const& policy_or_doc,
+      char const* doc = 0)
+  {
+      typedef detail::def_helper<CallPolicyOrDoc> helper;
+
+      detail::scope_setattr_doc(
+          name, boost::python::make_function(fn, helper::get_policy(policy_or_doc)),
+          helper::get_doc(policy_or_doc, doc));
+  }
+
+    template <class StubsT, class SigT>
+    void dispatch_def(
+        detail::func_stubs_base const*,
+        char const* name,
+        SigT sig,
+        StubsT const& stubs)
+    {
+        //  convert sig to a type_list (see detail::get_signature in signature.hpp)
+        //  before calling detail::define_with_defaults.
+
+        scope current;
+        detail::define_with_defaults(
+            name, stubs, current, detail::get_signature(sig));
+    }
+}
+
+template <class Fn>
+void def(char const* name, Fn fn)
+{
+    detail::scope_setattr_doc(name, boost::python::make_function(fn), 0);
+}
+
+template <class Arg1T, class Arg2T>
+void def(char const* name, Arg1T arg1, Arg2T const& arg2)
+{
+    //  The arguments may be:
+    //      def(name, function)
+    //      def(name, function, policy)
+    //      def(name, function, doc_string)
+    //      def(name, signature, stubs)
+
+    detail::dispatch_def(&arg2, name, arg1, arg2);
+}
+
+template <class Arg1T, class Arg2T, class Arg3T>
+void def(char const* name, Arg1T arg1, Arg2T const& arg2, Arg3T const& arg3)
+{
+    //  The arguments are definitely:
+    //      def(name, function, policy, doc_string) // TODO: exchange policy, doc_string position
+
+    detail::dispatch_def(&arg2, name, arg1, arg2, arg3);
+}
+
+//template <class Arg1T, class Arg2T, class Arg3T>
+//void def(char const* name, Arg1T arg1, Arg2T const& arg2, Arg3T const& arg3, char const* doc)
+//{
+//    //  The arguments are definitely:
+//    //  arg1:   signature
+//    //  arg2:   stubs
+//    //  arg3:   policy
+//
+//    detail::dispatch_def(&arg2, name, arg1, arg2, arg3, doc);
+//}
+
+}} // namespace boost::python
+
+#endif // DEF_DWA200292_HPP

include/boost/python/default_call_policies.hpp

@@ -0,0 +1,78 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef DEFAULT_CALL_POLICIES_DWA2002131_HPP
+# define DEFAULT_CALL_POLICIES_DWA2002131_HPP
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/python/to_python_value.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+
+namespace boost { namespace python { 
+
+template <class T> struct to_python_value;
+
+namespace detail
+{
+// for "readable" error messages
+  template <class T> struct specify_a_result_policy_to_wrap_functions_returning
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+  {}
+# endif 
+  ;
+}
+
+struct default_result_converter;
+
+struct default_call_policies
+{
+    // Nothing to do
+    static bool precall(PyObject*)
+    {
+        return true;
+    }
+
+    // Pass the result through
+    static PyObject* postcall(PyObject*, PyObject* result)
+    {
+        return result;
+    }
+
+    typedef default_result_converter result_converter;
+};
+
+struct default_result_converter
+{
+    template <class R>
+    struct apply
+    {
+        BOOST_STATIC_CONSTANT(bool, is_illegal = is_reference<R>::value || is_pointer<R>::value);
+        
+        typedef typename mpl::if_c<
+            is_illegal
+            , detail::specify_a_result_policy_to_wrap_functions_returning<R>
+            , boost::python::to_python_value<
+                typename add_reference<typename add_const<R>::type>::type
+                >
+        >::type type;
+    };
+};
+
+// Exceptions for c strings an PyObject*s
+template <>
+struct default_result_converter::apply<char const*>
+{
+    typedef boost::python::to_python_value<char const*const&> type;
+};
+
+template <>
+struct default_result_converter::apply<PyObject*>
+{
+    typedef boost::python::to_python_value<PyObject*const&> type;
+};
+
+}} // namespace boost::python
+
+#endif // DEFAULT_CALL_POLICIES_DWA2002131_HPP

include/boost/python/detail/aix_init_module.hpp

@@ -0,0 +1,24 @@
+// Copyright David Abrahams 2002. 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.
+#ifndef AIX_INIT_MODULE_DWA2002529_HPP
+# define AIX_INIT_MODULE_DWA2002529_HPP
+# ifdef _AIX
+# include <boost/python/detail/wrap_python.hpp>
+# include <cstdio>
+
+namespace boost { namespace python { namespace detail { 
+
+extern "C"
+{
+    typedef PyObject* (*so_load_function)(char*,char*,FILE*);
+}
+
+void aix_init_module(so_load_function, char const* name, void (*init_module)());
+
+}}} // namespace boost::python::detail
+# endif
+
+#endif // AIX_INIT_MODULE_DWA2002529_HPP

include/boost/python/detail/api_placeholder.hpp

@@ -0,0 +1,14 @@
+#ifndef BOOST_PYTHON_API_PLACE_HOLDER_HPP
+#define BOOST_PYTHON_API_PLACE_HOLDER_HPP
+
+namespace boost { namespace python {
+
+    inline long len(object const& obj)
+    {
+        long result = PyObject_Length(obj.ptr());
+        if (PyErr_Occurred()) throw_error_already_set();
+        return result;
+    }
+}} // namespace boost::python
+
+#endif // BOOST_PYTHON_API_PLACE_HOLDER_HPP

include/boost/python/detail/arg_tuple_size.hpp

@@ -0,0 +1,127 @@
+#if !defined(BOOST_PP_IS_ITERATING)
+
+//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  This work was funded in part by Lawrence Berkeley National Labs
+//
+//  This file generated for 5-argument member functions and 6-argument free
+//  functions by gen_arg_tuple_size.python
+
+#ifndef ARG_TUPLE_SIZE_DWA20011201_HPP
+# define ARG_TUPLE_SIZE_DWA20011201_HPP 
+
+# include <boost/config.hpp>
+
+# include <boost/python/detail/char_array.hpp>
+# include <boost/python/detail/preprocessor.hpp>
+
+# include <boost/preprocessor/comma_if.hpp>
+# include <boost/preprocessor/iterate.hpp>
+# include <boost/preprocessor/debug/line.hpp>
+
+namespace boost { namespace python { namespace detail {
+
+// Computes (at compile-time) the number of elements that a Python
+// argument tuple must have in order to be passed to a wrapped C++
+// (member) function of the given type.
+template <class F> struct arg_tuple_size;
+
+// We will use the "sizeof() trick" to work around the lack of
+// partial specialization in MSVC6 and its broken-ness in borland.
+// See http://opensource.adobe.com  or
+// http://groups.yahoo.com/group/boost/message/5441 for
+// more examples
+
+// The following helper functions are never actually called, since
+// they are only used within a sizeof() expression, but the type of
+// their return value is used to discriminate between various free
+// and member function pointers at compile-time.
+
+// Specializations for function pointers
+# define BOOST_PP_ITERATION_PARAMS_1 \
+     (4, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/arg_tuple_size.hpp>, BOOST_PYTHON_FUNCTION_POINTER))
+# include BOOST_PP_ITERATE()
+
+// Specializations for member function pointers
+# define BOOST_PP_ITERATION_PARAMS_1 \
+    (4, (0, BOOST_PYTHON_CV_COUNT - 1, <boost/python/detail/arg_tuple_size.hpp>, BOOST_PYTHON_POINTER_TO_MEMBER))
+# include BOOST_PP_ITERATE()
+
+# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <class F>
+struct arg_tuple_size
+{
+    // The sizeof() magic happens here
+    BOOST_STATIC_CONSTANT(std::size_t, value
+        = sizeof(arg_tuple_size_helper(F(0)).elements) - 1);
+};
+
+# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+}}} // namespace boost::python::detail
+
+#endif // ARG_TUPLE_SIZE_DWA20011201_HPP
+
+// --------------- function pointers --------------- //
+#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_FUNCTION_POINTER
+# line BOOST_PP_LINE(__LINE__, arg_tuple_size.hpp(function pointers))
+
+# define N BOOST_PP_ITERATION()
+
+# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <class R BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)>
+struct arg_tuple_size<R (*)(BOOST_PYTHON_UNARY_ENUM(N, A))>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = N);
+};
+
+# else
+
+template<class R BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)>
+char_array<N> arg_tuple_size_helper(
+        R (*)(BOOST_PYTHON_UNARY_ENUM(N, A)));
+
+# endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+# undef N
+
+// --------------- pointers-to-members --------------- //
+#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_POINTER_TO_MEMBER
+// Outer iteration over cv-qualifications
+
+# define BOOST_PP_ITERATION_PARAMS_2 \
+    (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/arg_tuple_size.hpp>))
+# include BOOST_PP_ITERATE()
+
+#elif BOOST_PP_ITERATION_DEPTH() == 2 && BOOST_PP_RELATIVE_FLAGS(1) == BOOST_PYTHON_POINTER_TO_MEMBER
+# line BOOST_PP_LINE(__LINE__, arg_tuple_size.hpp(pointers-to-members))
+// Inner iteration over arities
+    
+# define N BOOST_PP_ITERATION()
+# define Q BOOST_PYTHON_CV_QUALIFIER(BOOST_PP_RELATIVE_ITERATION(1))
+
+# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <class R, class T BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)>
+struct arg_tuple_size<R (T::*)(BOOST_PYTHON_UNARY_ENUM(N, A)) Q>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = N + 1U);
+};
+
+# else
+
+template <class R, class T BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)>
+char_array<N + 1> arg_tuple_size_helper(
+    R (T::*)(BOOST_PYTHON_UNARY_ENUM(N, A)) Q);
+
+# endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+# undef Q
+# undef N
+
+#endif // !defined(BOOST_PP_IS_ITERATING)

include/boost/python/detail/base_object.hpp

@@ -0,0 +1,60 @@
+//  (C) Copyright David Abrahams 2000. 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.
+//
+//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
+//  producing this work.
+//
+// Revision History:
+// Mar 01 01  Use PyObject_INIT() instead of trying to hand-initialize (David Abrahams)
+
+#ifndef BASE_OBJECT_DWA051600_H_
+# define BASE_OBJECT_DWA051600_H_
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <cstring>
+
+namespace boost { namespace python { namespace detail {
+
+// base_object - adds a constructor and non-virtual destructor to a
+// base Python type (e.g. PyObject, PyTypeObject).
+template <class PythonType>
+struct base_object : PythonType
+{
+    typedef PythonType base_python_type;
+
+    // Initializes type and reference count. All other fields of base_python_type are 0
+    base_object(PyTypeObject* type_obj);
+
+    // Decrements reference count on the type
+    ~base_object();
+};
+
+// Easy typedefs for common usage
+typedef base_object<PyObject> python_object;
+typedef base_object<PyTypeObject> python_type;
+
+
+//
+// base_object member function implementations 
+//
+template <class PythonType>
+base_object<PythonType>::base_object(PyTypeObject* type_obj)
+{
+    base_python_type* bp = this;
+    BOOST_CSTD_::memset(bp, 0, sizeof(base_python_type));
+    Py_INCREF(type_obj);
+    PyObject_INIT(bp, type_obj);
+}
+
+template <class PythonType>
+inline base_object<PythonType>::~base_object()
+{
+    Py_DECREF(ob_type);
+}
+
+}}} // namespace boost::python::detail
+
+#endif // BASE_OBJECT_DWA051600_H_

include/boost/python/detail/borrowed_ptr.hpp

@@ -0,0 +1,112 @@
+#ifndef BORROWED_PTR_DWA20020601_HPP
+# define BORROWED_PTR_DWA20020601_HPP
+// Copyright David Abrahams 2002. 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.
+
+# include <boost/config.hpp>
+# include <boost/type.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/type_traits/object_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/python/tag.hpp>
+
+namespace boost { namespace python { namespace detail {
+
+template<class T> class borrowed
+{ 
+    typedef T type;
+};
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template<typename T>
+struct is_borrowed_ptr
+{
+    BOOST_STATIC_CONSTANT(bool, value = false); 
+};
+
+#  if !defined(__MWERKS__) || __MWERKS__ > 0x3000
+template<typename T>
+struct is_borrowed_ptr<borrowed<T>*>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template<typename T>
+struct is_borrowed_ptr<borrowed<T> const*>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template<typename T>
+struct is_borrowed_ptr<borrowed<T> volatile*>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template<typename T>
+struct is_borrowed_ptr<borrowed<T> const volatile*>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+#  else
+template<typename T>
+struct is_borrowed
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+template<typename T>
+struct is_borrowed<borrowed<T> >
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+template<typename T>
+struct is_borrowed_ptr<T*>
+    : is_borrowed<typename remove_cv<T>::type>
+{
+};
+#  endif 
+
+# else // no partial specialization
+
+typedef char (&yes_borrowed_ptr_t)[1];
+typedef char (&no_borrowed_ptr_t)[2];
+
+no_borrowed_ptr_t is_borrowed_ptr_test(...);
+
+template <class T>
+typename mpl::if_c<
+    is_pointer<T>::value
+    , T
+    , int
+    >::type
+is_borrowed_ptr_test1(boost::type<T>);
+
+template<typename T>
+yes_borrowed_ptr_t is_borrowed_ptr_test(borrowed<T> const volatile*);
+
+template<typename T>
+class is_borrowed_ptr
+{
+ public:
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            sizeof(detail::is_borrowed_ptr_test(is_borrowed_ptr_test1(boost::type<T>())))
+            == sizeof(detail::yes_borrowed_ptr_t)));
+};
+
+# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+}
+
+template <class T>
+inline T* get_managed_object(detail::borrowed<T> const volatile* p, tag_t)
+{
+    return (T*)p;
+}
+
+}} // namespace boost::python::detail
+
+#endif // #ifndef BORROWED_PTR_DWA20020601_HPP

include/boost/python/detail/call_object.hpp

@@ -0,0 +1,66 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CALL_OBJECT_DWA20011222_HPP
+# define CALL_OBJECT_DWA20011222_HPP
+# include <boost/python/errors.hpp>
+# include <boost/python/detail/types.hpp>
+# include <boost/bind.hpp>
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  // A function object adaptor which turns a function returning R into
+  // an "equivalent" function returning void, but taking an R& in
+  // which the adapted function's result is stored.
+  template <class R, class F>
+  struct return_by_reference
+  {
+      typedef void return_type;
+      
+      return_by_reference(R& result, F f)
+          : m_result(result)
+          , m_f(f)
+      {
+      }
+      
+      void operator()() const
+      {
+          m_result = m_f();
+      }
+      
+      R& m_result;
+      F m_f;
+  };
+
+  // An object generator for the above adaptors
+  template <class R, class F>
+  return_by_reference<R,F> bind_return(R& result, F f)
+  {
+      return return_by_reference<R,F>(result, f);
+  }
+
+  // Given a function object f with signature
+  //
+  //    R f(PyTypeObject*,PyObject*)
+  //
+  // calls f inside of handle_exception_impl, placing f's result in
+  // ret. Returns true iff an exception is thrown by f, leaving ret
+  // unmodified.
+  template <class R, class F>
+  bool call_object(R& ret, PyObject* obj, F f)
+  {
+      return handle_exception(
+          detail::bind_return(
+              ret
+              , boost::bind<R>(
+                  f, static_cast<type_object_base*>(obj->ob_type), obj)));
+  }
+} // namespace detail
+
+}} // namespace boost::python
+
+#endif // CALL_OBJECT_DWA20011222_HPP

include/boost/python/detail/caller.hpp

@@ -0,0 +1,105 @@
+#if !defined(BOOST_PP_IS_ITERATING)
+
+//  (C) Copyright David Abrahams 2000. 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.
+//
+//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
+//  producing this work.
+//
+//  This file generated for 10-argument member functions and 11-argument free
+//  functions by gen_caller.python
+
+# ifndef CALLER_DWA20011214_HPP
+#  define CALLER_DWA20011214_HPP
+
+#  include <boost/python/detail/wrap_python.hpp>
+#  include <boost/python/detail/returning.hpp>
+#  include <boost/python/detail/preprocessor.hpp>
+
+#  include <boost/type_traits/composite_traits.hpp>
+#  include <boost/type_traits/same_traits.hpp>
+
+#  include <boost/preprocessor/comma_if.hpp>
+#  include <boost/preprocessor/iterate.hpp>
+#  include <boost/preprocessor/debug/line.hpp>
+
+namespace boost { namespace python
+{
+    template <class T> struct to_python;
+}}
+
+namespace boost { namespace python { namespace detail {
+
+struct caller
+{
+    typedef PyObject* result_type;
+
+    // function pointers
+#  define BOOST_PP_ITERATION_PARAMS_1 \
+    (4, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/caller.hpp>, BOOST_PYTHON_FUNCTION_POINTER))
+#  include BOOST_PP_ITERATE()
+
+    // pointers-to-members
+#  define BOOST_PP_ITERATION_PARAMS_1 \
+    (4, (0, 3, <boost/python/detail/caller.hpp>, BOOST_PYTHON_POINTER_TO_MEMBER))
+#  include BOOST_PP_ITERATE()
+
+};
+
+}}} // namespace boost::python::detail
+
+# endif // CALLER_DWA20011214_HPP
+
+/* ---------- function pointers --------- */
+#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_FUNCTION_POINTER
+# line BOOST_PP_LINE(__LINE__, detail/caller.hpp(function pointers))
+
+# define N BOOST_PP_ITERATION()
+
+template <
+    class P, class R
+    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)
+    >
+PyObject* operator()(
+    R (*pf)(BOOST_PYTHON_UNARY_ENUM(N, A))
+    , PyObject* args
+    , PyObject* keywords
+    , P const& policies) const
+{
+    return returning<R>::call(pf, args, keywords, &policies);
+}
+
+# undef N
+
+/* ---------- pointers-to-members ---------- */
+#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_POINTER_TO_MEMBER
+// outer over cv-qualifiers
+
+# define BOOST_PP_ITERATION_PARAMS_2 (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/caller.hpp>))
+# include BOOST_PP_ITERATE()
+
+#elif BOOST_PP_ITERATION_DEPTH() == 2
+// inner over arities
+
+#define N BOOST_PP_ITERATION()
+#define Q BOOST_PYTHON_CV_QUALIFIER(BOOST_PP_RELATIVE_ITERATION(1))
+
+template <
+    class P, class R, class T
+    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)
+    >
+PyObject* operator()(
+    R (T::*pmf)(BOOST_PYTHON_UNARY_ENUM(N, A)) Q
+    , PyObject* args, PyObject* keywords
+    , P const& policies
+    ) const
+{
+    return returning<R>::call(pmf, args, keywords, &policies);
+}
+
+#undef N
+#undef Q
+
+#endif

include/boost/python/detail/cast.hpp

@@ -0,0 +1,81 @@
+//  (C) Copyright David Abrahams 2000. 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.
+//
+//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
+//  producing this work.
+
+#ifndef CAST_DWA052500_H_
+# define CAST_DWA052500_H_
+
+# ifndef BOOST_PYTHON_V2
+#  include <boost/python/detail/wrap_python.hpp>
+#  include <boost/operators.hpp>
+
+namespace boost { namespace python {
+
+namespace detail {
+  inline PyTypeObject* as_base_object(const PyTypeObject*, PyObject* p)
+  {
+      return reinterpret_cast<PyTypeObject*>(p);
+  }
+
+  inline PyObject* as_base_object(const PyObject*, PyObject* p)
+  {
+      return p;
+  }
+
+  inline const PyTypeObject* as_base_object(const PyTypeObject*, const PyObject* p)
+  {
+      return reinterpret_cast<const PyTypeObject*>(p);
+  }
+
+  inline const PyObject* as_base_object(const PyObject*, const PyObject* p)
+  {
+      return p;
+  }
+} // namespace detail
+
+// Convert a pointer to any type derived from PyObject or PyTypeObject to a PyObject*
+inline PyObject* as_object(PyObject* p) { return p; }
+inline PyObject* as_object(PyTypeObject* p) { return reinterpret_cast<PyObject*>(p); }
+
+// If I didn't have to support stupid MSVC6 we could just use a simple template function:
+// template <class T> T* downcast(PyObject*).
+template <class T>
+struct downcast
+{
+    downcast(PyObject* p)
+        : m_p(static_cast<T*>(detail::as_base_object((T*)0, p)))
+        {}
+    
+    downcast(const PyObject* p)
+        : m_p(static_cast<T*>(detail::as_base_object((const T*)0, p)))
+        {}
+    
+    downcast(PyTypeObject* p)
+        : m_p(static_cast<T*>(p))
+        {}
+    
+    downcast(const PyTypeObject* p)
+        : m_p(static_cast<T*>(p))
+        {}
+    
+    operator T*() const { return m_p; }
+
+    // MSVC doesn't like boost::dereferencable unless T has a default
+    // constructor, so operator-> must be defined by hand :(
+    T* operator->() const { return &**this; }
+    
+    T* get() const { return m_p; }
+    T& operator*() const { return *m_p; }
+ private:
+    T* m_p;
+};
+
+}} // namespace boost::python
+
+# endif // BOOST_PYTHON_V2
+
+#endif // CAST_DWA052500_H_