Changes for MPL v2

[SVN r13504]

build/Jamfile

@@ -1,142 +0,0 @@
-#  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
-#  distribute this software is granted provided this copyright notice appears
-#  in all copies. This software is provided "as is" without express or implied
-#  warranty, and with no claim as to its suitability for any purpose.
-#
-# Boost.Python build and test Jamfile
-#
-# To run all tests quietly: jam test
-# To run all tests with verbose output: jam -sPYTHON_TEST_ARGS=-v test
-#
-# Declares the following targets:
-#   1. libboost_python, a static link library to be linked with all
-#      Boost.Python modules
-#
-#   2. pairs of test targets of the form <name>.test and <name>.run
-#      <name>.test runs the test when it is out-of-date, and the "test"
-#      pseudotarget depends on it. <name>.run runs
-#      a test unconditionally, and can be used to force a test to run.. Each
-#      test target builds one or more Boost.Python modules and runs a Python
-#      script to test them. The test names are:
-#
-#      from ../test
-#
-#         comprehensive         - a comprehensive test of Boost.Python features
-#
-#      from ../example:
-#         abstract              -
-#         getting_started1      -
-#         getting_started2      -
-#         simple_vector         -
-#         do_it_yourself_convts -
-#         pickle1               -
-#         pickle2               -
-#         pickle3               -
-#
-#         dvect1                -
-#         dvect2                -
-#         ivect1                -
-#         ivect2                -
-#         noncopyable           -
-#
-# subproject-specific environment/command-line variables:
-#
-# PYTHON                - How to invoke the Python interpreter. Defaults to "python"
-#
-# PYTHON_ROOT           - Windows only: where Python is installed. Defaults to "c:/tools/python"
-#
-# PYTHON_VERSION        - Version of Python. Defaults to "2.1" on Windows, "1.5" on Unix
-#
-# PYTHON_TEST_ARGS      - specifies arguments to be passed to test scripts on
-#                         the command line. "-v" can be useful if you want to
-#                         see the output of successful tests.
-#
-# PYTHON_VECT_ITERATIONS - specifies the number of test iterations to use for
-#                          the dvect and ivect tests above.
-
-# declare the location of this subproject relative to the root
-subproject libs/python/build ;
-
-# bring in the rules for python
-SEARCH on <module@>python.jam = $(BOOST_BUILD_PATH) ;
-include <module@>python.jam ;
-
-#######################
-local rule bpl-test ( test-name : sources + )
-{
-    boost-python-test $(test-name) : $(sources) <lib>libboost_python ;
-}
-
-#######################
-
-#
-# Declare the boost python static link library
-#
-
-# Base names of the source files for libboost_python
-local CPP_SOURCES =
-    types classes conversions extension_class functions 
-    init_function module_builder objects  cross_module ;
-
-lib libboost_python : ../src/$(CPP_SOURCES).cpp
-    # requirements
-    : $(BOOST_PYTHON_INCLUDES)
-    <shared-linkable>true
-    $(PYTHON_PROPERTIES) ;
-
-    
-############# comprehensive module and test ###########
-bpl-test boost_python_test
-      : ../test/comprehensive.cpp ;
-
-boost-python-runtest comprehensive
-         : ../test/comprehensive.py <lib>boost_python_test <lib>libboost_python ;
-
-############# simple tests from ../example ############
-
-local rule boost-python-example-runtest ( name )
-{
-    bpl-test $(name)
-      : ../example/$(name).cpp ;
-    
-    boost-python-runtest $(name)
-      : ../example/test_$(name).py <lib>$(name) ;
-}
-
-
-boost-python-example-runtest abstract ;
-boost-python-example-runtest getting_started1 ;
-boost-python-example-runtest getting_started2 ;
-boost-python-example-runtest simple_vector ;
-boost-python-example-runtest do_it_yourself_convts ;
-boost-python-example-runtest pickle1 ;
-boost-python-example-runtest pickle2 ;
-boost-python-example-runtest pickle3 ;
-
-
-bpl-test ivect : ../example/ivect.cpp ;
-bpl-test dvect : ../example/dvect.cpp ;
-bpl-test noncopyable_export : ../example/noncopyable_export.cpp ;
-bpl-test noncopyable_import : ../example/noncopyable_import.cpp ;
-
-############## cross-module tests from ../example ##########
-
-# A simple rule to build a test which depends on multiple modules in the PYTHONPATH
-local rule boost-python-multi-example-runtest ( test-name : modules + )
-{
-    boost-python-runtest $(test-name)
-        : ../example/tst_$(test-name).py <lib>$(modules) <lib>libboost_python
-        : : : $(PYTHON_VECT_ITERATIONS) ;
-}
-
-PYTHON_VECT_ITERATIONS ?= 10 ;
-
-boost-python-multi-example-runtest dvect1 : ivect dvect ;
-boost-python-multi-example-runtest dvect2 : ivect dvect ;
-
-boost-python-multi-example-runtest ivect1 : ivect dvect ;
-boost-python-multi-example-runtest ivect2 : ivect dvect ;
-
-boost-python-multi-example-runtest
-        noncopyable : noncopyable_import noncopyable_export ;
-

build/Makefile.linux_gcc

@@ -0,0 +1,166 @@
+# Usage:
+#
+#   Create a new empty directory anywhere (preferably not in the boost tree).
+#   Copy this Makefile to that new directory and rename it to "Makefile"
+#   Set the BOOST pathname 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
+
+BOOST= /net/cci/rwgk/boost
+
+PYEXE= /usr/local/Python-1.5.2/bin/python
+PYINC= -I/usr/local/Python-1.5.2/include/python1.5
+#PYEXE= /usr/local/Python-2.0/bin/python
+#PYINC= -I/usr/local/Python-2.0/include/python2.0
+#STLPORTINC= -I/usr/local/STLport-4.1b3/stlport
+#STLPORTOPTS= \
+# -D__USE_STD_IOSTREAM \
+# -D__STL_NO_SGI_IOSTREAMS \
+# -D__STL_USE_NATIVE_STRING \
+# -D__STL_NO_NEW_C_HEADERS \
+# -D_RWSTD_COMPILE_INSTANTIATE=1
+#STLPORTINC= -I/usr/local/STLport-4.1b4/stlport
+#STLPORTOPTS= -D__NO_USE_STD_IOSTREAM -D__STL_NO_SGI_IOSTREAMS
+#STLPORTINC= -I/net/cci/xp/C++_C_headers
+
+STDOPTS= -ftemplate-depth-21
+WARNOPTS=
+# use -msg_display_number to obtain integer tags for -msg_disable
+
+CPP= g++
+CPPOPTS= $(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
+         $(STDOPTS) $(WARNOPTS) -g
+MAKEDEP= -M
+
+LD= g++
+LDOPTS= -shared
+
+#HIDDEN= -hidden
+
+BPL_SRC = $(BOOST)/libs/python/src
+BPL_TST = $(BOOST)/libs/python/test
+BPL_EXA = $(BOOST)/libs/python/example
+SOFTLINKS = \
+$(BPL_SRC)/classes.cpp \
+$(BPL_SRC)/conversions.cpp \
+$(BPL_SRC)/extension_class.cpp \
+$(BPL_SRC)/functions.cpp \
+$(BPL_SRC)/init_function.cpp \
+$(BPL_SRC)/module_builder.cpp \
+$(BPL_SRC)/objects.cpp \
+$(BPL_SRC)/types.cpp \
+$(BPL_TST)/comprehensive.cpp \
+$(BPL_TST)/comprehensive.hpp \
+$(BPL_TST)/comprehensive.py \
+$(BPL_TST)/doctest.py \
+$(BPL_EXA)/abstract.cpp \
+$(BPL_EXA)/getting_started1.cpp \
+$(BPL_EXA)/getting_started2.cpp \
+$(BPL_EXA)/getting_started3.cpp \
+$(BPL_EXA)/getting_started4.cpp \
+$(BPL_EXA)/getting_started5.cpp \
+$(BPL_EXA)/test_abstract.py \
+$(BPL_EXA)/test_getting_started1.py \
+$(BPL_EXA)/test_getting_started2.py \
+$(BPL_EXA)/test_getting_started3.py \
+$(BPL_EXA)/test_getting_started4.py \
+$(BPL_EXA)/test_getting_started5.py
+
+OBJ = classes.o conversions.o extension_class.o functions.o \
+      init_function.o module_builder.o \
+      objects.o types.o
+DEPOBJ= $(OBJ) comprehensive.o abstract.o \
+        getting_started1.o getting_started2.o getting_started3.o \
+        getting_started4.o getting_started5.o
+
+.SUFFIXES: .o .cpp
+
+all: libbpl.a boost_python_test.so abstract.so \
+     getting_started1.so getting_started2.so getting_started3.so \
+     getting_started4.so getting_started5.so
+
+softlinks:
+	@ for pn in $(SOFTLINKS); \
+	  do \
+            bn=`basename "$$pn"`; \
+	    if [ ! -e "$$bn" ]; then \
+              echo "ln -s $$pn ."; \
+	      ln -s "$$pn" .; \
+            else \
+              echo "info: no softlink created (file exists): $$bn"; \
+	    fi; \
+	  done
+
+unlink:
+	@ for pn in $(SOFTLINKS); \
+	  do \
+            bn=`basename "$$pn"`; \
+	    if [ -L "$$bn" ]; then \
+              echo "rm $$bn"; \
+              rm "$$bn"; \
+            elif [ -e "$$bn" ]; then \
+              echo "info: not a softlink: $$bn"; \
+	    fi; \
+	  done
+
+libbpl.a: $(OBJ)
+	rm -f libbpl.a
+	ar r libbpl.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
+
+getting_started4.so: $(OBJ) getting_started4.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started4.o -o getting_started4.so
+
+getting_started5.so: $(OBJ) getting_started5.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started5.o -o getting_started5.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_getting_started4.py
+	$(PYEXE) test_getting_started5.py
+
+clean:
+	rm -f $(OBJ) libbpl.a libbpl.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 getting_started4.o getting_started4.so
+	rm -f getting_started5.o getting_started5.so
+	rm -f so_locations *.pyc
+	rm -rf cxx_repository
+
+depend:
+	@ cat Makefile.nodepend; \
+          for obj in $(DEPOBJ); \
+          do \
+            bn=`echo "$$obj" | cut -d. -f1`; \
+            $(CPP) $(CPPOPTS) $(MAKEDEP) "$$bn".cpp; \
+          done
+

build/Makefile.tru64_cxx

@@ -0,0 +1,170 @@
+# Usage:
+#
+#   Create a new empty directory anywhere (preferably not in the boost tree).
+#   Copy this Makefile to that new directory and rename it to "Makefile"
+#   Set the BOOST pathname 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
+
+BOOST= /net/cci/rwgk/boost
+
+PYEXE= /usr/local/Python-1.5.2/bin/python
+PYINC= -I/usr/local/Python-1.5.2/include/python1.5
+#PYEXE= /usr/local/Python-2.0/bin/python
+#PYINC= -I/usr/local/Python-2.0/include/python2.0
+#STLPORTINC= -I/usr/local/STLport-4.1b3/stlport
+#STLPORTOPTS= \
+# -D__USE_STD_IOSTREAM \
+# -D__STL_NO_SGI_IOSTREAMS \
+# -D__STL_USE_NATIVE_STRING \
+# -D__STL_NO_NEW_C_HEADERS \
+# -D_RWSTD_COMPILE_INSTANTIATE=1
+#STLPORTINC= -I/usr/local/STLport-4.1b4/stlport
+#STLPORTOPTS= -D__NO_USE_STD_IOSTREAM -D__STL_NO_SGI_IOSTREAMS
+STLPORTINC= -I/net/cci/xp/C++_C_headers
+
+STDOPTS= -std strict_ansi
+WARNOPTS= -msg_disable 186,450,1115
+# use -msg_display_number to obtain integer tags for -msg_disable
+
+CPP= cxx
+CPPOPTS= $(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
+         $(STDOPTS) $(WARNOPTS) -g
+MAKEDEP= -Em
+
+LD= cxx
+LDOPTS= -shared -expect_unresolved 'Py*' -expect_unresolved '_Py*'
+
+#HIDDEN= -hidden
+
+BPL_SRC = $(BOOST)/libs/python/src
+BPL_TST = $(BOOST)/libs/python/test
+BPL_EXA = $(BOOST)/libs/python/example
+SOFTLINKS = \
+$(BPL_SRC)/classes.cpp \
+$(BPL_SRC)/conversions.cpp \
+$(BPL_SRC)/extension_class.cpp \
+$(BPL_SRC)/functions.cpp \
+$(BPL_SRC)/init_function.cpp \
+$(BPL_SRC)/module_builder.cpp \
+$(BPL_SRC)/objects.cpp \
+$(BPL_SRC)/types.cpp \
+$(BPL_TST)/comprehensive.cpp \
+$(BPL_TST)/comprehensive.hpp \
+$(BPL_TST)/comprehensive.py \
+$(BPL_TST)/doctest.py \
+$(BPL_EXA)/abstract.cpp \
+$(BPL_EXA)/getting_started1.cpp \
+$(BPL_EXA)/getting_started2.cpp \
+$(BPL_EXA)/getting_started3.cpp \
+$(BPL_EXA)/getting_started4.cpp \
+$(BPL_EXA)/getting_started5.cpp \
+$(BPL_EXA)/test_abstract.py \
+$(BPL_EXA)/test_getting_started1.py \
+$(BPL_EXA)/test_getting_started2.py \
+$(BPL_EXA)/test_getting_started3.py \
+$(BPL_EXA)/test_getting_started4.py \
+$(BPL_EXA)/test_getting_started5.py
+
+OBJ = classes.o conversions.o extension_class.o functions.o \
+      init_function.o module_builder.o \
+      objects.o types.o
+DEPOBJ= $(OBJ) comprehensive.o abstract.o \
+        getting_started1.o getting_started2.o getting_started3.o \
+        getting_started4.o getting_started5.o
+
+.SUFFIXES: .o .cpp
+
+all: libbpl.a boost_python_test.so abstract.so \
+     getting_started1.so getting_started2.so getting_started3.so \
+     getting_started4.so getting_started5.so
+
+softlinks:
+	@ for pn in $(SOFTLINKS); \
+	  do \
+            bn=`basename "$$pn"`; \
+	    if [ ! -e "$$bn" ]; then \
+              echo "ln -s $$pn ."; \
+	      ln -s "$$pn" .; \
+            else \
+              echo "info: no softlink created (file exists): $$bn"; \
+	    fi; \
+	  done
+
+unlink:
+	@ for pn in $(SOFTLINKS); \
+	  do \
+            bn=`basename "$$pn"`; \
+	    if [ -L "$$bn" ]; then \
+              echo "rm $$bn"; \
+              rm "$$bn"; \
+            elif [ -e "$$bn" ]; then \
+              echo "info: not a softlink: $$bn"; \
+	    fi; \
+	  done
+
+libbpl.a: $(OBJ)
+	rm -f libbpl.a
+	cd cxx_repository; \
+          ls -1 > ../libbpl.a.input; \
+          ar r ../libbpl.a -input ../libbpl.a.input
+	rm -f libbpl.a.input
+	ar r libbpl.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
+
+getting_started4.so: $(OBJ) getting_started4.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started4.o -o getting_started4.so
+
+getting_started5.so: $(OBJ) getting_started5.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started5.o -o getting_started5.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_getting_started4.py
+	$(PYEXE) test_getting_started5.py
+
+clean:
+	rm -f $(OBJ) libbpl.a libbpl.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 getting_started4.o getting_started4.so
+	rm -f getting_started5.o getting_started5.so
+	rm -f so_locations *.pyc
+	rm -rf cxx_repository
+
+depend:
+	@ cat Makefile.nodepend; \
+          for obj in $(DEPOBJ); \
+          do \
+            bn=`echo "$$obj" | cut -d. -f1`; \
+            $(CPP) $(CPPOPTS) $(MAKEDEP) "$$bn".cpp; \
+          done
+

build/bpl_static.dsp

@@ -0,0 +1,241 @@
+# Microsoft Developer Studio Project File - Name="bpl_static" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=bpl_static - Win32 DebugPython
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "bpl_static.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "bpl_static.mak" CFG="bpl_static - Win32 DebugPython"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "bpl_static - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "bpl_static - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE "bpl_static - Win32 DebugPython" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "bpl_static - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /MD /W4 /WX /GR /GX /O2 /I "..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /FR /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "bpl_static - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W4 /WX /Gm- /GR /GX /Zi /Od /I "..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /FR /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "bpl_static - Win32 DebugPython"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "bpl_static___Win32_DebugPython"
+# PROP BASE Intermediate_Dir "bpl_static___Win32_DebugPython"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "DebugPython"
+# PROP Intermediate_Dir "DebugPython"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MDd /W4 /WX /Gm /GR /GX /Zi /Od /I "..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /FR /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W4 /WX /Gm- /GR /GX /Zi /Od /I "..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /D "BOOST_DEBUG_PYTHON" /FR /YX /FD /GZ /EHs /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ENDIF 
+
+# Begin Target
+
+# Name "bpl_static - Win32 Release"
+# Name "bpl_static - Win32 Debug"
+# Name "bpl_static - Win32 DebugPython"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=..\src\classes.cpp
+# ADD CPP /W3
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\conversions.cpp
+# ADD CPP /W3
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\extension_class.cpp
+# ADD CPP /W3
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\functions.cpp
+# ADD CPP /W3
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\init_function.cpp
+# ADD CPP /W3
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\module_builder.cpp
+# ADD CPP /W3
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\objects.cpp
+# ADD CPP /W3
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\types.cpp
+# ADD CPP /W3
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\detail\base_object.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\callback.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\caller.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\detail\cast.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\class_builder.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\classes.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\detail\config.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\conversions.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\errors.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\detail\extension_class.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\detail\functions.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\detail\init_function.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\module_builder.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\detail\none.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\objects.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\operators.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\reference.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\detail\signatures.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\detail\singleton.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\detail\types.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\boost\python\detail\wrap_python.hpp
+# End Source File
+# End Group
+# End Target
+# End Project

example/dvect.cpp

@@ -0,0 +1,69 @@
+#include "ivect.h"
+#include "dvect.h"
+#include <boost/python/class_builder.hpp>
+#include <boost/python/detail/import_extension_class.hpp>
+namespace python = boost::python;
+
+namespace {
+
+  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::tuple ivect_as_tuple(const vects::ivect& iv)
+  {
+    return iv.as_tuple();
+  }
+
+  std::auto_ptr<vects::ivect> auto_ptr_ivect(const vects::dvect& dv)
+  {
+    return std::auto_ptr<vects::ivect>(new vects::ivect(dvect_as_ivect(dv)));
+  }
+
+  boost::shared_ptr<vects::ivect> shared_ptr_ivect(const vects::dvect& dv)
+  {
+    return boost::shared_ptr<vects::ivect>(new vects::ivect(dvect_as_ivect(dv)));
+  }
+
+  boost::python::tuple auto_ptr_ivect_as_tuple(std::auto_ptr<vects::ivect>& iv)
+  {
+    return iv->as_tuple();
+  }
+
+  boost::python::tuple shared_ptr_ivect_as_tuple(boost::shared_ptr<vects::ivect>& iv)
+  {
+    return iv->as_tuple();
+  }
+}
+
+extern "C"
+DL_EXPORT(void)
+initdvect()
+{
+  try
+  {
+    python::module_builder this_module("dvect");
+
+    python::x_class_builder<vects::dvect> dvect_class(this_module, "dvect");
+
+    python::import_class_builder<vects::ivect> ivect_class("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");
+
+    this_module.def(ivect_as_tuple, "ivect_as_tuple");
+    dvect_class.def(auto_ptr_ivect, "auto_ptr_ivect");
+    dvect_class.def(shared_ptr_ivect, "shared_ptr_ivect");
+    this_module.def(auto_ptr_ivect_as_tuple, "auto_ptr_ivect_as_tuple");
+    this_module.def(shared_ptr_ivect_as_tuple, "shared_ptr_ivect_as_tuple");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}

example/dvect.h

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

example/getting_started5.cpp

@@ -0,0 +1,128 @@
+/*
+   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(const 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
+
+extern "C"
+DL_EXPORT(void)
+initgetting_started5()
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("getting_started5");
+
+    // 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/ivect.cpp

@@ -0,0 +1,69 @@
+#include "ivect.h"
+#include "dvect.h"
+#include <boost/python/class_builder.hpp>
+#include <boost/python/detail/import_extension_class.hpp>
+namespace python = boost::python;
+
+namespace {
+
+  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::tuple dvect_as_tuple(const vects::dvect& dv)
+  {
+    return dv.as_tuple();
+  }
+
+  std::auto_ptr<vects::dvect> auto_ptr_dvect(const vects::ivect& iv)
+  {
+    return std::auto_ptr<vects::dvect>(new vects::dvect(ivect_as_dvect(iv)));
+  }
+
+  boost::shared_ptr<vects::dvect> shared_ptr_dvect(const vects::ivect& iv)
+  {
+    return boost::shared_ptr<vects::dvect>(new vects::dvect(ivect_as_dvect(iv)));
+  }
+
+  boost::python::tuple auto_ptr_dvect_as_tuple(std::auto_ptr<vects::dvect>& dv)
+  {
+    return dv->as_tuple();
+  }
+
+  boost::python::tuple shared_ptr_dvect_as_tuple(boost::shared_ptr<vects::dvect>& dv)
+  {
+    return dv->as_tuple();
+  }
+}
+
+extern "C"
+DL_EXPORT(void)
+initivect()
+{
+  try
+  {
+    python::module_builder this_module("ivect");
+
+    python::x_class_builder<vects::ivect> ivect_class(this_module, "ivect");
+
+    python::import_class_builder<vects::dvect> dvect_class("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");
+
+    this_module.def(dvect_as_tuple, "dvect_as_tuple");
+    ivect_class.def(auto_ptr_dvect, "auto_ptr_dvect");
+    ivect_class.def(shared_ptr_dvect, "shared_ptr_dvect");
+    this_module.def(auto_ptr_dvect_as_tuple, "auto_ptr_dvect_as_tuple");
+    this_module.def(shared_ptr_dvect_as_tuple, "shared_ptr_dvect_as_tuple");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}

example/ivect.h

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

example/noncopyable_export.cpp

@@ -0,0 +1,24 @@
+#include <boost/python/class_builder.hpp>
+#include <boost/python/detail/import_extension_class.hpp>
+namespace python = boost::python;
+
+#include "store.h"
+
+extern "C"
+DL_EXPORT(void)
+initnoncopyable_export()
+{
+  try
+  {
+    python::module_builder this_module("noncopyable_export");
+
+    python::xptr_class_builder<store> store_class(this_module, "store");
+
+    store_class.def(python::constructor<int>());
+    store_class.def(&store::recall, "recall");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}

example/noncopyable_import.cpp

@@ -0,0 +1,42 @@
+#include <boost/python/class_builder.hpp>
+#include <boost/python/detail/import_extension_class.hpp>
+namespace python = boost::python;
+
+#include "store.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;
+  }
+}
+
+extern "C"
+DL_EXPORT(void)
+initnoncopyable_import()
+{
+  try
+  {
+    python::module_builder this_module("noncopyable_import");
+
+    python::import_class_builder<store>
+      dvect_class("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/store.h

@@ -0,0 +1,14 @@
+#ifndef STORE_H
+#define STORE_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 // STORE_H

example/tst_dvect.py

@@ -0,0 +1,16 @@
+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.ivect_as_tuple(iv)
+aiv = dv.auto_ptr_ivect()
+print aiv
+siv = dv.shared_ptr_ivect()
+print dvect.auto_ptr_ivect_as_tuple(aiv)
+print dvect.ivect_as_tuple(aiv)
+print dvect.shared_ptr_ivect_as_tuple(siv)
+print dvect.ivect_as_tuple(siv)

example/tst_ivect.py

@@ -0,0 +1,16 @@
+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.dvect_as_tuple(dv)
+adv = iv.auto_ptr_dvect()
+print adv
+sdv = iv.shared_ptr_dvect()
+print ivect.auto_ptr_dvect_as_tuple(adv)
+print ivect.dvect_as_tuple(adv)
+print ivect.shared_ptr_dvect_as_tuple(sdv)
+print ivect.dvect_as_tuple(sdv)

example/tst_noncopyable.py

@@ -0,0 +1,8 @@
+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/detail/arg_tuple_size.hpp

@@ -1,233 +0,0 @@
-//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  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
-
-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;
-
-# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__BORLANDC__)
-
-template <class R>
-struct arg_tuple_size<R (*)()>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 0);
-};
-
-template <class R, class A1>
-struct arg_tuple_size<R (*)(A1)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 1);
-};
-
-template <class R, class A1, class A2>
-struct arg_tuple_size<R (*)(A1, A2)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 2);
-};
-
-template <class R, class A1, class A2, class A3>
-struct arg_tuple_size<R (*)(A1, A2, A3)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 3);
-};
-
-template <class R, class A1, class A2, class A3, class A4>
-struct arg_tuple_size<R (*)(A1, A2, A3, A4)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 4);
-};
-
-template <class R, class A1, class A2, class A3, class A4, class A5>
-struct arg_tuple_size<R (*)(A1, A2, A3, A4, A5)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 5);
-};
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
-struct arg_tuple_size<R (*)(A1, A2, A3, A4, A5, A6)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 6);
-};
-
-
-template <class R, class A0>
-struct arg_tuple_size<R (A0::*)()>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 1);
-};
-
-template <class R, class A0, class A1>
-struct arg_tuple_size<R (A0::*)(A1)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 2);
-};
-
-template <class R, class A0, class A1, class A2>
-struct arg_tuple_size<R (A0::*)(A1, A2)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 3);
-};
-
-template <class R, class A0, class A1, class A2, class A3>
-struct arg_tuple_size<R (A0::*)(A1, A2, A3)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 4);
-};
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-struct arg_tuple_size<R (A0::*)(A1, A2, A3, A4)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 5);
-};
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-struct arg_tuple_size<R (A0::*)(A1, A2, A3, A4, A5)>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = 6);
-};
-
-# else
-
-// 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
-
-// This little package is used to transmit the number of arguments
-// from the helper functions below to the sizeof() expression below.
-// Because we can never have an array of fewer than 1 element, we
-// add 1 to n and then subtract 1 from the result of sizeof() below.
-template <int n>
-struct char_array
-{
-    char elements[n+1];
-};
-
-// 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.
-
-template <class R>
-char_array<0> arg_tuple_size_helper(R (*)());
-
-template <class R, class A1>
-char_array<1> arg_tuple_size_helper(R (*)(A1));
-
-template <class R, class A1, class A2>
-char_array<2> arg_tuple_size_helper(R (*)(A1, A2));
-
-template <class R, class A1, class A2, class A3>
-char_array<3> arg_tuple_size_helper(R (*)(A1, A2, A3));
-
-template <class R, class A1, class A2, class A3, class A4>
-char_array<4> arg_tuple_size_helper(R (*)(A1, A2, A3, A4));
-
-template <class R, class A1, class A2, class A3, class A4, class A5>
-char_array<5> arg_tuple_size_helper(R (*)(A1, A2, A3, A4, A5));
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
-char_array<6> arg_tuple_size_helper(R (*)(A1, A2, A3, A4, A5, A6));
-
-template <class R, class A0>
-char_array<1> arg_tuple_size_helper(R (A0::*)());
-
-template <class R, class A0, class A1>
-char_array<2> arg_tuple_size_helper(R (A0::*)(A1));
-
-template <class R, class A0, class A1, class A2>
-char_array<3> arg_tuple_size_helper(R (A0::*)(A1, A2));
-
-template <class R, class A0, class A1, class A2, class A3>
-char_array<4> arg_tuple_size_helper(R (A0::*)(A1, A2, A3));
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-char_array<5> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4));
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-char_array<6> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4, A5));
-
-
-template <class R, class A0>
-char_array<1> arg_tuple_size_helper(R (A0::*)() const);
-
-template <class R, class A0, class A1>
-char_array<2> arg_tuple_size_helper(R (A0::*)(A1) const);
-
-template <class R, class A0, class A1, class A2>
-char_array<3> arg_tuple_size_helper(R (A0::*)(A1, A2) const);
-
-template <class R, class A0, class A1, class A2, class A3>
-char_array<4> arg_tuple_size_helper(R (A0::*)(A1, A2, A3) const);
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-char_array<5> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4) const);
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-char_array<6> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4, A5) const);
-
-
-template <class R, class A0>
-char_array<1> arg_tuple_size_helper(R (A0::*)() volatile);
-
-template <class R, class A0, class A1>
-char_array<2> arg_tuple_size_helper(R (A0::*)(A1) volatile);
-
-template <class R, class A0, class A1, class A2>
-char_array<3> arg_tuple_size_helper(R (A0::*)(A1, A2) volatile);
-
-template <class R, class A0, class A1, class A2, class A3>
-char_array<4> arg_tuple_size_helper(R (A0::*)(A1, A2, A3) volatile);
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-char_array<5> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4) volatile);
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-char_array<6> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4, A5) volatile);
-
-
-template <class R, class A0>
-char_array<1> arg_tuple_size_helper(R (A0::*)() const volatile);
-
-template <class R, class A0, class A1>
-char_array<2> arg_tuple_size_helper(R (A0::*)(A1) const volatile);
-
-template <class R, class A0, class A1, class A2>
-char_array<3> arg_tuple_size_helper(R (A0::*)(A1, A2) const volatile);
-
-template <class R, class A0, class A1, class A2, class A3>
-char_array<4> arg_tuple_size_helper(R (A0::*)(A1, A2, A3) const volatile);
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-char_array<5> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4) const volatile);
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-char_array<6> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4, A5) const volatile);
-
-
-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
-

include/boost/python/detail/base_object.hpp

@@ -1,64 +0,0 @@
-//  (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/signatures.hpp> // really just for type<>
-# 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;
-#if !defined(_MSC_VER) || defined(__STLPORT)
-    std::
-#endif
-        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/caller.hpp

@@ -1,27 +0,0 @@
-// 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 CALLER_DWA20011214_HPP
-# define CALLER_DWA20011214_HPP
-
-# include <boost/python/call.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-
-namespace boost { namespace python { namespace detail { 
-
-struct caller
-{
-    typedef PyObject* result_type;
-    
-    template <class F>
-    PyObject* operator()(F f, PyObject* args, PyObject* keywords)
-    {
-        return call(f, args, keywords);
-    }
-};
-
-}}} // namespace boost::python::detail
-
-#endif // CALLER_DWA20011214_HPP

include/boost/python/detail/cast.hpp

@@ -1,78 +0,0 @@
-//  (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_
-
-# 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 // CAST_DWA052500_H_

include/boost/python/detail/config.hpp

@@ -1,68 +0,0 @@
-//  (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:
-//  04 Mar 01  Some fixes so it will compile with Intel C++ (Dave Abrahams)
-
-#ifndef CONFIG_DWA052200_H_
-# define CONFIG_DWA052200_H_
-
-# include <boost/config.hpp>
-# include <cstddef>
-
-# ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
-   // A gcc bug forces some symbols into the global namespace
-#  define BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-#  define BOOST_PYTHON_END_CONVERSION_NAMESPACE
-#  define BOOST_PYTHON_CONVERSION
-#  define BOOST_PYTHON_IMPORT_CONVERSION(x) using ::x
-# else
-#  define BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE namespace boost { namespace python {
-#  define BOOST_PYTHON_END_CONVERSION_NAMESPACE }} // namespace boost::python
-#  define BOOST_PYTHON_CONVERSION boost::python
-#  define BOOST_PYTHON_IMPORT_CONVERSION(x) void never_defined() // so we can follow the macro with a ';'
-# endif
-
-# if defined(BOOST_MSVC)
-#  if _MSC_VER <= 1200
-#   define BOOST_MSVC6_OR_EARLIER 1
-#  endif
-
-# pragma warning (disable : 4786)
-
-# endif
-
-// Work around the broken library implementation/strict ansi checking on some
-// EDG-based compilers (e.g. alpha), which incorrectly warn that the result of
-// offsetof() is not an integer constant expression.
-# if defined(__DECCXX_VER) && __DECCXX_VER <= 60290024
-#  define BOOST_OFFSETOF(s_name, s_member) \
-        ((size_t)__INTADDR__(&(((s_name *)0)->s_member)))
-# else
-#  define BOOST_OFFSETOF(s_name, s_member) \
-        offsetof(s_name, s_member)
-# endif
-
-// The STLport puts all of the standard 'C' library names in std (as far as the
-// user is concerned), but without it you need a fix if you're using MSVC or
-// Intel C++
-# if defined(BOOST_MSVC_STD_ITERATOR)
-#  define BOOST_CSTD_
-# else
-#  define BOOST_CSTD_ std
-# endif
-
-# ifndef BOOST_PYTHON_MODULE_INIT
-#  if defined(_WIN32) || defined(__CYGWIN__)
-#   define BOOST_PYTHON_MODULE_INIT(name) void init_module_##name(); extern "C" __declspec(dllexport) void init##name() { boost::python::handle_exception(init_module_##name); } void init_module_##name()
-#  else
-#   define BOOST_PYTHON_MODULE_INIT(name) void init_module_##name(); extern "C" void init##name() { boost::python::handle_exception(init_module_##name); } void init_module_##name()
-#  endif
-# endif 
-
-#endif // CONFIG_DWA052200_H_

include/boost/python/detail/extension_class.hpp

@@ -1,942 +0,0 @@
-//  (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 automatically generated for 10-argument constructors by
-//  gen_extclass.python
-
-//  Revision History:
-//  17 Apr 01  Comment added with reference to cross_module.hpp (R.W. Grosse-Kunstleve)
-//  05 Mar 01  Fixed a bug which prevented auto_ptr values from being converted
-//             to_python (Dave Abrahams)
-
-#ifndef EXTENSION_CLASS_DWA052000_H_
-# define EXTENSION_CLASS_DWA052000_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/classes.hpp>
-# include <vector>
-# include <boost/python/detail/none.hpp>
-# include <boost/python/objects.hpp>
-# include <boost/python/detail/functions.hpp>
-# include <memory>
-# include <boost/python/detail/init_function.hpp>
-# include <typeinfo>
-# include <boost/smart_ptr.hpp>
-# include <boost/type_traits.hpp>
-
-namespace boost { namespace python {
-
-// forward declarations
-template <long which, class operand> struct operators;
-template <class T> struct left_operand;
-template <class T> struct right_operand;
-
-enum without_downcast_t { without_downcast };
-
-namespace detail {
-
-// forward declarations
-class extension_instance;
-class extension_class_base;
-template <class T> class instance_holder;
-template <class T, class U> class instance_value_holder;
-template <class ref, class T> class instance_ptr_holder;
-template <class Specified> struct operand_select;
-  template <long> struct choose_op;
-  template <long> struct choose_rop;
-  template <long> struct choose_unary_op;
-  template <long> struct define_operator;
-
-meta_class<extension_instance>* extension_meta_class();
-extension_instance* get_extension_instance(PyObject* p);
-void report_missing_instance_data(extension_instance*, class_t<extension_instance>*, const std::type_info&);
-void report_missing_ptr_data(extension_instance*, class_t<extension_instance>*, const std::type_info&);
-void report_missing_class_object(const std::type_info&);
-void report_released_smart_pointer(const std::type_info&);
-    
-template <class T>
-T* check_non_null(T* p)
-{
-    if (p == 0)
-        report_released_smart_pointer(typeid(T));
-    return p;
-}
-
-template <class Held> class held_instance;
-
-typedef void* (*conversion_function_ptr)(void*);
-
-struct base_class_info
-{
-    base_class_info(extension_class_base* t, conversion_function_ptr f)
-        :class_object(t), convert(f)
-        {}
-    
-    extension_class_base* class_object;
-    conversion_function_ptr convert;
-};
-
-typedef base_class_info derived_class_info;
-
-struct add_operator_base;
-
-class extension_class_base : public class_t<extension_instance>
-{
- public:
-    extension_class_base(const char* name);
-    
- public:
-    // the purpose of try_class_conversions() and its related functions 
-    // is explained in extclass.cpp
-    void* try_class_conversions(instance_holder_base*) const;
-    void* try_base_class_conversions(instance_holder_base*) const;
-    void* try_derived_class_conversions(instance_holder_base*) const;
-
-    void set_attribute(const char* name, PyObject* x);
-    void set_attribute(const char* name, ref x);
-    
- private:
-    virtual void* extract_object_from_holder(instance_holder_base* v) const = 0;
-    virtual std::vector<base_class_info> const& base_classes() const = 0;
-    virtual std::vector<derived_class_info> const& derived_classes() const = 0;
-
- protected:
-    friend struct add_operator_base;
-    void add_method(reference<function> method, const char* name);
-    void add_method(function* method, const char* name);
-    
-    void add_constructor_object(function*);
-    void add_setter_method(function*, const char* name);
-    void add_getter_method(function*, const char* name);
-};
-
-template <class T>
-class class_registry
-{
- public:
-    static extension_class_base* class_object()
-        { return static_class_object; }
-
-    // Register/unregister the Python class object corresponding to T
-    static void register_class(extension_class_base*);
-    static void unregister_class(extension_class_base*);
-
-    // Establish C++ inheritance relationships
-    static void register_base_class(base_class_info const&);
-    static void register_derived_class(derived_class_info const&);
-
-    // Query the C++ inheritance relationships
-    static std::vector<base_class_info> const& base_classes();
-    static std::vector<derived_class_info> const& derived_classes();
- private:
-    static extension_class_base* static_class_object;
-    static std::vector<base_class_info> static_base_class_info;
-    static std::vector<derived_class_info> static_derived_class_info;
-};
-
-template <bool is_pointer>
-struct is_null_helper
-{
-    template <class Ptr>
-    static bool test(Ptr x) { return x == 0; }
-};
-
-template <>
-struct is_null_helper<false>
-{
-    template <class Ptr>
-    static bool test(const Ptr& x) { return x.get() == 0; }
-};
-
-template <class Ptr>
-bool is_null(const Ptr& x)
-{
-    return is_null_helper<(is_pointer<Ptr>::value)>::test(x);
-}
-
-}}} // namespace boost::python::detail
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-// This class' only job is to define from_python and to_python converters for T
-// and U. T is the class the user really intends to wrap. U is a class derived
-// from T with some virtual function overriding boilerplate, or if there are no
-// virtual functions, U = held_instance<T>.
-//
-// A look-alike of this class in root/boost/python/cross_module.hpp
-// is used for the implementation of the cross-module support
-// (export_converters and import_converters). If from_python
-// and to_python converters are added or removed from the class
-// below, the class python_import_extension_class_converters has
-// to be modified accordingly.
-//
-template <class T, class U = boost::python::detail::held_instance<T> >
-class python_extension_class_converters
-{
- public:
-    // Get an object which can be used to convert T to/from python. This is used
-    // as a kind of concept check by the global template
-    //
-    //     PyObject* to_python(const T& x)
-    //
-    // below this class, to prevent the confusing messages that would otherwise
-    // pop up. Now, if T hasn't been wrapped as an extension class, the user
-    // will see an error message about the lack of an eligible
-    // py_extension_class_converters() function.
-    friend python_extension_class_converters py_extension_class_converters(boost::python::type<T>)
-    { 
-        return python_extension_class_converters();
-    }
-
-    // This is a member function because in a conforming implementation, friend
-    // funcitons defined inline in the class body are all instantiated as soon
-    // as the enclosing class is instantiated. If T is not copyable, that causes
-    // a compiler error. Instead, we access this function through the global
-    // template 
-    //
-    //     PyObject* to_python(const T& x)
-    //
-    // defined below this class. Since template functions are instantiated only
-    // on demand, errors will be avoided unless T is noncopyable and the user
-    // writes code which causes us to try to copy a T.
-    PyObject* to_python(const T& x) const
-    {
-        boost::python::reference<boost::python::detail::extension_instance> result(create_instance());
-        result->add_implementation(
-            std::auto_ptr<boost::python::detail::instance_holder_base>(
-                new boost::python::detail::instance_value_holder<T,U>(result.get(), x)));
-        return result.release();
-    }
-
-    friend
-    T* non_null_from_python(PyObject* obj, boost::python::type<T*>)
-    {
-        // downcast to an extension_instance, then find the actual T
-        boost::python::detail::extension_instance* self = boost::python::detail::get_extension_instance(obj);
-        typedef std::vector<boost::python::detail::instance_holder_base*>::const_iterator iterator;
-        for (iterator p = self->wrapped_objects().begin();
-             p != self->wrapped_objects().end(); ++p)
-        {
-            boost::python::detail::instance_holder<T>* held = dynamic_cast<boost::python::detail::instance_holder<T>*>(*p);
-            if (held != 0)
-                return held->target();
-
-            // see extclass.cpp for an explanation of try_class_conversions()
-            void* target = boost::python::detail::class_registry<T>::class_object()->try_class_conversions(*p);
-            if(target) 
-                return static_cast<T*>(target);
-        }
-        boost::python::detail::report_missing_instance_data(self, boost::python::detail::class_registry<T>::class_object(), typeid(T));
-        throw boost::python::argument_error();
-#if defined(__MWERKS__) && __MWERKS__ <= 0x2406
-        return 0;
-#endif
-    }
-
-    // Convert to T*
-    friend T* from_python(PyObject* obj, boost::python::type<T*>)
-    {
-        if (obj == Py_None)
-            return 0;
-        else
-            return non_null_from_python(obj, boost::python::type<T*>());
-    }
-
-    // Extract from obj a mutable reference to the PtrType object which is holding a T.
-    template <class PtrType>
-    static PtrType& smart_ptr_reference(PyObject* obj, boost::python::type<PtrType>)
-    {
-        // downcast to an extension_instance, then find the actual T
-        boost::python::detail::extension_instance* self = boost::python::detail::get_extension_instance(obj);
-        typedef std::vector<boost::python::detail::instance_holder_base*>::const_iterator iterator;
-        for (iterator p = self->wrapped_objects().begin();
-             p != self->wrapped_objects().end(); ++p)
-        {
-            boost::python::detail::instance_ptr_holder<PtrType, T>* held =
-                dynamic_cast<boost::python::detail::instance_ptr_holder<PtrType, T>*>(*p);
-            if (held != 0)
-                return held->ptr();
-        }
-        boost::python::detail::report_missing_ptr_data(self, boost::python::detail::class_registry<T>::class_object(), typeid(T));
-        throw boost::python::argument_error();
-#if defined(__MWERKS__) && __MWERKS__ <= 0x2406
-        return *(PtrType*)0;
-#endif
-    }
-
-    // Extract from obj a reference to the PtrType object which is holding a
-    // T. If it weren't for auto_ptr, it would be a constant reference. Do not
-    // modify the referent except by copying an auto_ptr! If obj is None, the
-    // reference denotes a default-constructed PtrType
-    template <class PtrType>
-    static PtrType& smart_ptr_value(PyObject* obj, boost::python::type<PtrType>)
-    {
-        if (obj == Py_None)
-        {
-            static PtrType null_ptr;
-            return null_ptr;
-        }
-        return smart_ptr_reference(obj, boost::python::type<PtrType>());
-    }
-        
-    template <class PtrType>
-    static PyObject* smart_ptr_to_python(PtrType x)
-    {
-        if (boost::python::detail::is_null(x))
-        {
-            return boost::python::detail::none();
-        }
-        
-        boost::python::reference<boost::python::detail::extension_instance> result(create_instance());
-        result->add_implementation(
-            std::auto_ptr<boost::python::detail::instance_holder_base>(
-                new boost::python::detail::instance_ptr_holder<PtrType,T>(x)));
-        return result.release();
-    }
-
-    static boost::python::reference<boost::python::detail::extension_instance> create_instance()
-    {
-        PyTypeObject* class_object = boost::python::detail::class_registry<T>::class_object();
-        if (class_object == 0)
-            boost::python::detail::report_missing_class_object(typeid(T));
-            
-        return boost::python::reference<boost::python::detail::extension_instance>(
-            new boost::python::detail::extension_instance(class_object));
-    }
-
-    // Convert to const T*
-    friend const T* from_python(PyObject* p, boost::python::type<const T*>)
-        { return from_python(p, boost::python::type<T*>()); }
-
-    // Convert to const T* const&
-    friend const T* from_python(PyObject* p, boost::python::type<const T*const&>)
-         { return from_python(p, boost::python::type<const T*>()); }
-  
-    // Convert to T* const&
-    friend T* from_python(PyObject* p, boost::python::type<T* const&>)
-         { return from_python(p, boost::python::type<T*>()); }
- 
-    // Convert to T&
-    friend T& from_python(PyObject* p, boost::python::type<T&>)
-        { return *boost::python::detail::check_non_null(non_null_from_python(p, boost::python::type<T*>())); }
-
-    // Convert to const T&
-    friend const T& from_python(PyObject* p, boost::python::type<const T&>)
-        { return from_python(p, boost::python::type<T&>()); }
-
-    // Convert to T
-    friend const T& from_python(PyObject* p, boost::python::type<T>)
-        { return from_python(p, boost::python::type<T&>()); }
-
-    friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T>&>)
-        { return smart_ptr_reference(p, boost::python::type<std::auto_ptr<T> >()); }
-    
-    friend std::auto_ptr<T> from_python(PyObject* p, boost::python::type<std::auto_ptr<T> >)
-        { return smart_ptr_value(p, boost::python::type<std::auto_ptr<T> >()); }
-    
-    friend const std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<const std::auto_ptr<T>&>)
-        { return smart_ptr_value(p, boost::python::type<std::auto_ptr<T> >()); }
-
-    friend PyObject* to_python(std::auto_ptr<T> x)
-        { return smart_ptr_to_python(x); }
-
-    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T>&>)
-        { return smart_ptr_reference(p, boost::python::type<boost::shared_ptr<T> >()); }
-    
-    friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T> >)
-        { return smart_ptr_value(p, boost::python::type<boost::shared_ptr<T> >()); }
-    
-    friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<const boost::shared_ptr<T>&>)
-        { return smart_ptr_value(p, boost::python::type<boost::shared_ptr<T> >()); }
-
-    friend PyObject* to_python(boost::shared_ptr<T> x)
-        { return smart_ptr_to_python(x); }
-};
-
-// Convert T to_python, instantiated on demand and only if there isn't a
-// non-template overload for this function. This version is the one invoked when
-// T is a wrapped class. See the first 2 functions declared in
-// python_extension_class_converters above for more info.
-template <class T>
-PyObject* to_python(const T& x)
-{
-    return py_extension_class_converters(boost::python::type<T>()).to_python(x);
-}
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-namespace boost { namespace python {
-
-BOOST_PYTHON_IMPORT_CONVERSION(python_extension_class_converters);
-
-namespace detail {
-
-template <class T> class instance_holder;
-
-class read_only_setattr_function : public function
-{
- public:
-    read_only_setattr_function(const char* name);
-    PyObject* do_call(PyObject* args, PyObject* keywords) const;
-    const char* description() const;
- private:
-    string m_name;
-};
-
-  template <class From, class To>
-  struct define_conversion
-  {
-      static void* upcast_ptr(void* v)
-      {
-          return static_cast<To*>(static_cast<From*>(v));
-      }
-
-      static void* downcast_ptr(void* v)
-      {
-          return dynamic_cast<To*>(static_cast<From*>(v));
-      }
-  };
-
-// An easy way to make an extension base class which wraps T. Note that Python
-// subclasses of this class will simply be class_t<extension_instance> objects.
-//
-// U should be a class derived from T which overrides virtual functions with
-// boilerplate code to call back into Python. See extclass_demo.h for examples.
-// 
-// U is optional, but you won't be able to override any member functions in
-// Python which are called from C++ if you don't supply it. If you just want to
-// be able to use T in python without overriding member functions, you can omit
-// U.
-template <class T, class U = held_instance<T> >
-class extension_class
-    : public python_extension_class_converters<T, U>, // This generates the to_python/from_python functions
-      public extension_class_base
-{
- public:
-    typedef T wrapped_type;
-    typedef U callback_type;
-    
-    // Construct with a name that comes from typeid(T).name(). The name only
-    // affects the objects of this class are represented through repr()
-    extension_class();
-    
-    // Construct with the given name. The name only affects the objects of this
-    // class are represented through repr()
-    extension_class(const char* name);
-    
-    ~extension_class();
-
-    // define constructors
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    inline void def(constructor<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>)
-    // The following incantation builds a signature1, signature2,... object. It
-    // should _all_ get optimized away.
-    { add_constructor(
-        prepend(type<A1>::id(),
-        prepend(type<A2>::id(),
-        prepend(type<A3>::id(),
-        prepend(type<A4>::id(),
-        prepend(type<A5>::id(),
-        prepend(type<A6>::id(),
-        prepend(type<A7>::id(),
-        prepend(type<A8>::id(),
-        prepend(type<A9>::id(),
-        prepend(type<A10>::id(),
-                signature0())))))))))));
-    }
-
-
-    // export homogeneous operators (type of both lhs and rhs is 'operator')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub), Foo>());
-    
-    // export homogeneous operators (type of both lhs and rhs is 'T const&')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>());
-    template <long which, class Operand>
-    inline void def(operators<which,Operand>)
-    {
-        typedef typename operand_select<Operand>::template wrapped<T>::type true_operand;
-        def_operators(operators<which,true_operand>());
-    }
-
-    // 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&>());
-
-    // export heterogeneous operators (type of lhs: 'T const&', of rhs: 'right')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>(),
-    //                       boost::python::right_operand<int const&>());
-    template <long which, class Left, class Right>
-    inline void def(operators<which,Left>, right_operand<Right> r)
-    {
-        typedef typename operand_select<Left>::template wrapped<T>::type true_left;
-        def_operators(operators<which,true_left>(), r);
-    }
-
-    // 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&>());
-    
-    // export heterogeneous reverse-argument operators 
-    // (type of lhs: 'left', of rhs: 'T const&')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>(),
-    //                       boost::python::left_operand<int const&>());
-    template <long which, class Left, class Right>
-    inline void def(operators<which,Right>, left_operand<Left> l)
-    {
-        typedef typename operand_select<Right>::template wrapped<T>::type true_right;
-        def_operators(operators<which,true_right>(), l);
-    }
-
-    // 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>
-    inline void def_raw(Fn fn, const char* name)
-    {
-        this->add_method(new_raw_arguments_function(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), they can be used just like
-    // ordinary member functions -- just like Python!
-    template <class Fn>
-    inline void def(Fn fn, const char* name)
-    {
-        this->add_method(new_wrapped_function(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>
-    inline void def(Fn fn, const char* name, DefaultFn default_fn)
-    {
-        this->add_method(new_virtual_function(type<T>(), fn, default_fn), name);
-    }
-
-    // Provide a function which implements x.<name>, reading from the given
-    // member (pm) of the T obj
-    template <class MemberType>
-    inline void def_getter(MemberType T::*pm, const char* name)
-    {
-        this->add_getter_method(new getter_function<T, MemberType>(pm), name);
-    }
-    
-    // Provide a function which implements assignment to x.<name>, writing to
-    // the given member (pm) of the T obj
-    template <class MemberType>
-    inline void def_setter(MemberType T::*pm, const char* name)
-    {
-        this->add_setter_method(new setter_function<T, MemberType>(pm), name);
-    }
-    
-    // Expose the given member (pm) of the T obj as a read-only attribute
-    template <class MemberType>
-    inline void def_readonly(MemberType T::*pm, const char* name)
-    {
-        this->add_setter_method(new read_only_setattr_function(name), name);
-        this->def_getter(pm, name);
-    }
-    
-    // Expose the given member (pm) of the T obj as a read/write attribute
-    template <class MemberType>
-    inline void def_read_write(MemberType T::*pm, const char* name)
-    {
-        this->def_getter(pm, name);
-        this->def_setter(pm, name);
-    }
-    
-    // define the standard coercion needed for operator overloading
-    void def_standard_coerce();
-
-    // declare the given class a base class of this one and register 
-    // up and down conversion functions
-    template <class S, class V>
-    void declare_base(extension_class<S, V>* base)
-    {
-        // see extclass.cpp for an explanation of why we need to register
-        // conversion functions
-        base_class_info baseInfo(base, 
-                            &define_conversion<S, T>::downcast_ptr);
-        class_registry<T>::register_base_class(baseInfo);
-        add_base(ref(as_object(base), ref::increment_count));
-        
-        derived_class_info derivedInfo(this, 
-                            &define_conversion<T, S>::upcast_ptr);
-        class_registry<S>::register_derived_class(derivedInfo);
-    }
-        
-    // declare the given class a base class of this one and register 
-    // only up conversion function
-    template <class S, class V>
-    void declare_base(extension_class<S, V>* base, without_downcast_t)
-    {
-        // see extclass.cpp for an explanation of why we need to register
-        // conversion functions
-        base_class_info baseInfo(base, 0);
-        class_registry<T>::register_base_class(baseInfo);
-        add_base(ref(as_object(base), ref::increment_count));
-        
-        derived_class_info derivedInfo(this, 
-                           &define_conversion<T, S>::upcast_ptr);
-        class_registry<S>::register_derived_class(derivedInfo);
-    }
-    
- private: // types
-    typedef instance_value_holder<T,U> holder;
-
- private: // extension_class_base virtual function implementations
-    std::vector<base_class_info> const& base_classes() const;
-    std::vector<derived_class_info> const& derived_classes() const;
-    void* extract_object_from_holder(instance_holder_base* v) const;
-
- private: // Utility functions
-    template <long which, class Operand>
-    inline void def_operators(operators<which,Operand>)
-    {
-        def_standard_coerce();
-
-        // for some strange reason, this prevents MSVC from having an
-        // "unrecoverable block scoping error"!
-        typedef choose_op<(which & op_add)> choose_add;
-
-        choose_op<(which & op_add)>::template args<Operand>::add(this);
-        choose_op<(which & op_sub)>::template args<Operand>::add(this);
-        choose_op<(which & op_mul)>::template args<Operand>::add(this);
-        choose_op<(which & op_div)>::template args<Operand>::add(this);
-        choose_op<(which & op_mod)>::template args<Operand>::add(this);
-        choose_op<(which & op_divmod)>::template args<Operand>::add(this);
-        choose_op<(which & op_pow)>::template args<Operand>::add(this);
-        choose_op<(which & op_lshift)>::template args<Operand>::add(this);
-        choose_op<(which & op_rshift)>::template args<Operand>::add(this);
-        choose_op<(which & op_and)>::template args<Operand>::add(this);
-        choose_op<(which & op_xor)>::template args<Operand>::add(this);
-        choose_op<(which & op_or)>::template args<Operand>::add(this);
-        choose_op<(which & op_gt)>::template args<Operand>::add(this);
-        choose_op<(which & op_ge)>::template args<Operand>::add(this);
-        choose_op<(which & op_lt)>::template args<Operand>::add(this);
-        choose_op<(which & op_le)>::template args<Operand>::add(this);
-        choose_op<(which & op_eq)>::template args<Operand>::add(this);
-        choose_op<(which & op_ne)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_neg)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_pos)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_abs)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_invert)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_int)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_long)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_float)>::template args<Operand>::add(this);
-        choose_op<(which & op_cmp)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_str)>::template args<Operand>::add(this);
-    }
-
-    template <long which, class Left, class Right>
-    inline void def_operators(operators<which,Left>, right_operand<Right>)
-    {
-        def_standard_coerce();
-        
-        choose_op<(which & op_add)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_sub)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_mul)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_div)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_mod)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_divmod)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_pow)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_lshift)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_rshift)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_and)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_xor)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_or)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_cmp)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_gt)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_ge)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_lt)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_le)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_eq)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_ne)>::template args<Left,Right>::add(this);
-    }
-    
-    template <long which, class Left, class Right>
-    inline void def_operators(operators<which,Right>, left_operand<Left>)
-    {
-        def_standard_coerce();
-        
-        choose_rop<(which & op_add)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_sub)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_mul)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_div)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_mod)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_divmod)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_pow)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_lshift)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_rshift)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_and)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_xor)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_or)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_cmp)>::template args<Left,Right>::add(this);
-    }
-    
-    template <class signature>
-    void add_constructor(signature sig)
-    {
-        this->add_constructor_object(init_function<holder>::create(sig));
-    }
-};
-
-// A simple wrapper over a T which allows us to use extension_class<T> with a
-// single template parameter only. See extension_class<T>, above.
-template <class Held>
-class held_instance : public Held
-{
-    // There are no member functions: we want to avoid inadvertently overriding
-    // any virtual functions in Held.
-public:
-    held_instance(PyObject*) : Held() {}
-    template <class A1>
-    held_instance(PyObject*, A1 a1) : Held(a1) {}
-    template <class A1, class A2>
-    held_instance(PyObject*, A1 a1, A2 a2) : Held(a1, a2) {}
-    template <class A1, class A2, class A3>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3) : Held(a1, a2, a3) {}
-    template <class A1, class A2, class A3, class A4>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4) : Held(a1, a2, a3, a4) {}
-    template <class A1, class A2, class A3, class A4, class A5>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) : Held(a1, a2, a3, a4, a5) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) : Held(a1, a2, a3, a4, a5, a6) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) : Held(a1, a2, a3, a4, a5, a6, a7) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) : Held(a1, a2, a3, a4, a5, a6, a7, a8) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) : Held(a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) : Held(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
-};
-
-// Abstract base class for all obj holders. Base for template class
-// instance_holder<>, below.
-class instance_holder_base
-{
-public:
-    virtual ~instance_holder_base() {}
-    virtual bool held_by_value() = 0;
-};
-
-// Abstract base class which holds a Held, somehow. Provides a uniform way to
-// get a pointer to the held object
-template <class Held>
-class instance_holder : public instance_holder_base
-{
-public:
-    virtual Held*target() = 0;
-};
-
-// Concrete class which holds a Held by way of a wrapper class Wrapper. If Held
-// can be constructed with arguments (A1...An), Wrapper must have a
-// corresponding constructor for arguments (PyObject*, A1...An). Wrapper is
-// neccessary to implement virtual function callbacks (there must be a
-// back-pointer to the actual Python object so that we can call any
-// overrides). held_instance (above) is used as a default Wrapper class when
-// there are no virtual functions.
-template <class Held, class Wrapper>
-class instance_value_holder : public instance_holder<Held>
-{
-public:
-    Held* target() { return &m_held; }
-    Wrapper* value_target() { return &m_held; }
-
-    instance_value_holder(extension_instance* p) :
-        m_held(p) {}
-    template <class A1>
-    instance_value_holder(extension_instance* p, A1 a1) :
-        m_held(p, a1) {}
-    template <class A1, class A2>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2) :
-        m_held(p, a1, a2) {}
-    template <class A1, class A2, class A3>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3) :
-        m_held(p, a1, a2, a3) {}
-    template <class A1, class A2, class A3, class A4>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4) :
-        m_held(p, a1, a2, a3, a4) {}
-    template <class A1, class A2, class A3, class A4, class A5>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) :
-        m_held(p, a1, a2, a3, a4, a5) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) :
-        m_held(p, a1, a2, a3, a4, a5, a6) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) :
-        m_held(p, a1, a2, a3, a4, a5, a6, a7) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) :
-        m_held(p, a1, a2, a3, a4, a5, a6, a7, a8) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) :
-        m_held(p, a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) :
-        m_held(p, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
-
- public: // implementation of instance_holder_base required interface
-    bool held_by_value() { return true; }
-
- private:
-    Wrapper m_held;
-};
-
-// Concrete class which holds a HeldType by way of a (possibly smart) pointer
-// PtrType. By default, these are only generated for PtrType ==
-// std::auto_ptr<HeldType> and PtrType == boost::shared_ptr<HeldType>.
-template <class PtrType, class HeldType>
-class instance_ptr_holder : public instance_holder<HeldType>
-{
- public:
-    HeldType* target() { return &*m_ptr; }
-    PtrType& ptr() { return m_ptr; }
-
-    instance_ptr_holder(PtrType ptr) : m_ptr(ptr) {}
-    
- public: // implementation of instance_holder_base required interface
-    bool held_by_value() { return false; }
- private:
-    PtrType m_ptr;
-};
-
-class extension_instance : public instance
-{
- public:
-    extension_instance(PyTypeObject* class_);
-    ~extension_instance();
-    
-    void add_implementation(std::auto_ptr<instance_holder_base> holder);
-
-    typedef std::vector<instance_holder_base*> held_objects;
-    const held_objects& wrapped_objects() const
-        { return m_wrapped_objects; }
- private:
-    held_objects m_wrapped_objects;
-};
-
-//
-// Template function implementations
-//
-
-template <class T, class U>
-extension_class<T, U>::extension_class()
-    : extension_class_base(typeid(T).name())
-{
-    class_registry<T>::register_class(this);
-}
-
-template <class T, class U>
-extension_class<T, U>::extension_class(const char* name)
-    : extension_class_base(name)
-{
-    class_registry<T>::register_class(this);
-}
-
-template <class T, class U>
-void extension_class<T, U>::def_standard_coerce()
-{
-    ref coerce_fct = dict().get_item(string("__coerce__"));
-    
-    if(coerce_fct.get() == 0) // not yet defined
-        this->def(&standard_coerce, "__coerce__");
-}
-
-template <class T, class U>
-inline
-std::vector<base_class_info> const& 
-extension_class<T, U>::base_classes() const
-{
-    return class_registry<T>::base_classes();
-}
-
-template <class T, class U>
-inline
-std::vector<derived_class_info> const& 
-extension_class<T, U>::derived_classes() const
-{
-    return class_registry<T>::derived_classes();
-}
-       
-template <class T, class U>
-void* extension_class<T, U>::extract_object_from_holder(instance_holder_base* v) const
-{
-    instance_holder<T>* held = dynamic_cast<instance_holder<T>*>(v);
-    if(held)
-        return held->target();
-    return 0;
-}
-
-template <class T, class U>
-extension_class<T, U>::~extension_class()
-{
-    class_registry<T>::unregister_class(this);
-}
-
-template <class T>
-inline void class_registry<T>::register_class(extension_class_base* p)
-{
-    // You're not expected to create more than one of these!
-    assert(static_class_object == 0);
-    static_class_object = p;
-}
-
-template <class T>
-inline void class_registry<T>::unregister_class(extension_class_base* p)
-{
-    // The user should be destroying the same object they created.
-    assert(static_class_object == p);
-    (void)p; // unused in shipping version
-    static_class_object = 0;
-}
-
-template <class T>
-void class_registry<T>::register_base_class(base_class_info const& i)
-{
-    static_base_class_info.push_back(i);
-}
-
-template <class T>
-void class_registry<T>::register_derived_class(derived_class_info const& i)
-{
-    static_derived_class_info.push_back(i);
-}
-
-template <class T>
-std::vector<base_class_info> const& class_registry<T>::base_classes()
-{
-    return static_base_class_info;
-}
-
-template <class T>
-std::vector<derived_class_info> const& class_registry<T>::derived_classes()
-{
-    return static_derived_class_info;
-}
-
-//
-// Static data member declaration.
-//
-template <class T>
-extension_class_base* class_registry<T>::static_class_object;
-template <class T>
-std::vector<base_class_info> class_registry<T>::static_base_class_info;
-template <class T>
-std::vector<derived_class_info> class_registry<T>::static_derived_class_info;
-
-}}} // namespace boost::python::detail
-
-#endif // EXTENSION_CLASS_DWA052000_H_

include/boost/python/detail/functions.hpp

@@ -1,311 +0,0 @@
-//  (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 FUNCTIONS_DWA051400_H_
-# define FUNCTIONS_DWA051400_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/reference.hpp>
-# include <boost/python/detail/signatures.hpp>
-# include <boost/python/caller.hpp>
-# include <boost/call_traits.hpp>
-# include <boost/python/objects.hpp>
-# include <boost/python/detail/base_object.hpp>
-# include <typeinfo>
-# include <vector>
-
-namespace boost { namespace python { namespace detail {
-
-// forward declaration
-class extension_instance;
-
-
-// function --
-//      the common base class for all overloadable function and method objects
-//      supplied by the library.
-class function : public python_object
-{
- public:
-    function();
-    // function objects are reasonably rare, so we guess we can afford a virtual table.
-    // This cuts down on the number of distinct type objects which need to be defined.
-    virtual ~function() {}
-
-    PyObject* call(PyObject* args, PyObject* keywords) const;
-    static void add_to_namespace(reference<function> f, const char* name, PyObject* dict);
-    
- private:
-    virtual PyObject* do_call(PyObject* args, PyObject* keywords) const = 0;
-    virtual const char* description() const = 0;
- private:
-    struct type_object;
- private:
-    reference<function> m_overloads; // A linked list of the function overloads
-};
-
-// wrapped_function_pointer<> --
-//      A single function or member function pointer wrapped and presented to
-//      Python as a callable object.
-//
-//   Template parameters:
-//      R - the return type of the function pointer
-//      F - the complete type of the wrapped function pointer
-template <class R, class F>
-struct wrapped_function_pointer : function
-{
-    typedef F ptr_fun; // pointer-to--function or pointer-to-member-function
-    
-    wrapped_function_pointer(ptr_fun pf)
-        : m_pf(pf) {}
-
- private:
-    PyObject* do_call(PyObject* args, PyObject* keywords) const
-        {
-            // This is where the boundary between the uniform Python function
-            // interface and the statically-checked C++ function interface is
-            // crossed.
-            return caller<R>::call(m_pf, args, keywords);
-        }
-    
-    const char* description() const
-        { return typeid(F).name(); }
-    
- private:
-    const ptr_fun m_pf;
-};
-
-// raw_arguments_function
-//      A function that passes the Python argument tuple and keyword dictionary 
-//      verbatim to C++ (useful for customized argument parsing and variable
-//      argument lists)
-template <class Ret, class Args, class Keywords>
-struct raw_arguments_function : function
-{
-    typedef Ret (*ptr_fun)(Args, Keywords); 
-    
-    raw_arguments_function(ptr_fun pf)
-        : m_pf(pf) {}
-
- private:
-    PyObject* do_call(PyObject* args, PyObject* keywords) const
-    { 
-        ref dict(keywords ? 
-                 ref(keywords, ref::increment_count) :
-                 ref(PyDict_New()));
-            
-        return to_python(
-            (*m_pf)(from_python(args, boost::python::type<Args>()),
-                    from_python(dict.get(), boost::python::type<Keywords>()))); 
-    }
-    
-    const char* description() const
-        { return typeid(ptr_fun).name(); }
-    
- private:
-    const ptr_fun m_pf;
-};
-
-// virtual_function<> --
-//      A virtual function with a default implementation wrapped and presented
-//      to Python as a callable object.
-//
-//   Template parameters:
-//      T - the type of the target class
-//      R - the return type of the function pointer
-//      V - the virtual function pointer being wrapped
-//          (should be of the form R(T::*)(<args>), or R (*)(T, <args>))
-//      D - a function which takes a T&, const T&, T*, or const T* first
-//          parameter and calls T::f on it /non-virtually/, where V
-//          approximates &T::f.
-template <class T, class R, class V, class D>
-class virtual_function : public function
-{
- public:
-    virtual_function(V virtual_function_ptr, D default_implementation)
-        : m_virtual_function_ptr(virtual_function_ptr),
-          m_default_implementation(default_implementation)
-        {}
-
- private:
-    PyObject* do_call(PyObject* args, PyObject* keywords) const;
-    
-    const char* description() const
-        { return typeid(V).name(); }
-    
- private:
-    const V m_virtual_function_ptr;
-    const D m_default_implementation;
-};
-
-// A helper function for new_member_function(), below.  Implements the core
-// functionality once the return type has already been deduced. R is expected to
-// be type<X>, where X is the actual return type of pmf.
-template <class F, class R>
-function* new_wrapped_function_aux(R, F pmf)
-{
-    // We can't just use "typename R::Type" below because MSVC (incorrectly) pukes.
-    typedef typename R::type return_type;
-    return new wrapped_function_pointer<return_type, F>(pmf);
-}
-
-// Create and return a new member function object wrapping the given
-// pointer-to-member function
-template <class F>
-inline function* new_wrapped_function(F pmf)
-{
-    // Deduce the return type and pass it off to the helper function above
-    return new_wrapped_function_aux(return_value(pmf), pmf);
-}
-
-template <class R, class Args, class keywords>
-function* new_raw_arguments_function(R (*pmf)(Args, keywords))
-{
-    return new raw_arguments_function<R, Args, keywords>(pmf);
-}
-
-
-// A helper function for new_virtual_function(), below.  Implements the core
-// functionality once the return type has already been deduced. R is expected to
-// be type<X>, where X is the actual return type of V.
-template <class T, class R, class V, class D>
-inline function* new_virtual_function_aux(
-    type<T>, R, V virtual_function_ptr, D default_implementation
-    )
-{
-    // We can't just use "typename R::Type" below because MSVC (incorrectly) pukes.
-    typedef typename R::type return_type;
-    return new virtual_function<T, return_type, V, D>(
-        virtual_function_ptr, default_implementation);
-}
-
-// Create and return a new virtual_function object wrapping the given
-// virtual_function_ptr and default_implementation
-template <class T, class V, class D>
-inline function* new_virtual_function(
-    type<T>, V virtual_function_ptr, D default_implementation
-    )
-{
-    // Deduce the return type and pass it off to the helper function above
-    return new_virtual_function_aux(
-        type<T>(), return_value(virtual_function_ptr),
-        virtual_function_ptr, default_implementation);
-}
-
-// A function with a bundled "bound target" object. This is what is produced by
-// the expression a.b where a is an instance or extension_instance object and b
-// is a callable object not found in the obj namespace but on its class or
-// a base class.
-class bound_function : public python_object
-{
- public:
-    static bound_function* create(const ref& target, const ref& fn);
-    
-    bound_function(const ref& target, const ref& fn);
-    PyObject* call(PyObject*args, PyObject* keywords) const;
-    PyObject* getattr(const char* name) const;
-    
- private:
-    struct type_object;
-    friend struct type_object;
-    
-    ref m_target;
-    ref m_unbound_function;
-    
- private: // data members for allocation/deallocation optimization
-    bound_function* m_free_list_link;
-
-    static bound_function* free_list;
-};
-
-// Special functions designed to access data members of a wrapped C++ object.
-template <class ClassType, class MemberType>
-class getter_function : public function
-{
- public:
-    typedef MemberType ClassType::* pointer_to_member;
-    
-    getter_function(pointer_to_member pm)
-        : m_pm(pm) {}
-
- private:
-    PyObject* do_call(PyObject* args, PyObject* keywords) const;
-    
-    const char* description() const
-        { return typeid(MemberType (*)(const ClassType&)).name(); }
- private:
-    pointer_to_member m_pm;
-};
-
-template <class ClassType, class MemberType>
-class setter_function : public function
-{
- public:
-    typedef MemberType ClassType::* pointer_to_member;
-    
-    setter_function(pointer_to_member pm)
-        : m_pm(pm) {}
-
- private:
-    PyObject* do_call(PyObject* args, PyObject* keywords) const;
-    
-    const char* description() const
-        { return typeid(void (*)(const ClassType&, const MemberType&)).name(); }
- private:
-    pointer_to_member m_pm;
-};
-
-template <class ClassType, class MemberType>
-PyObject* getter_function<ClassType, MemberType>::do_call(
-    PyObject* args, PyObject* /* keywords */) const
-{
-    PyObject* self;
-    if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
-        return 0;
-
-    return to_python(
-        from_python(self, type<const ClassType*>())->*m_pm);
-}
-
-template <class ClassType, class MemberType>
-PyObject* setter_function<ClassType, MemberType>::do_call(
-    PyObject* args, PyObject* /* keywords */) const
-{
-    PyObject* self;
-    PyObject* value;
-    if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &self, &value))
-        return 0;
-    
-    typedef typename boost::call_traits<MemberType>::const_reference extract_type;
-    from_python(self, type<ClassType*>())->*m_pm
-        = from_python(value, type<extract_type>());
-    
-    return none();
-}
-
-template <class T, class R, class V, class D>
-PyObject* virtual_function<T,R,V,D>::do_call(PyObject* args, PyObject* keywords) const
-{
-    // If the target object is held by pointer, we must call through the virtual
-    // function pointer to the most-derived override.
-    PyObject* target = PyTuple_GetItem(args, 0);
-    if (target != 0)
-    {
-        extension_instance* self = get_extension_instance(target);
-        if (self->wrapped_objects().size() == 1
-            && !self->wrapped_objects()[0]->held_by_value())
-        {
-            return caller<R>::call(m_virtual_function_ptr, args, keywords);
-        }
-    }
-    return caller<R>::call(m_default_implementation, args, keywords);
-}
-    
-}}} // namespace boost::python::detail
-
-#endif // FUNCTIONS_DWA051400_H_

include/boost/python/detail/init_function.hpp

@@ -1,508 +0,0 @@
-//  (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 %d-argument constructors by gen_init_function.python
-
-#ifndef INIT_FUNCTION_DWA052000_H_
-# define INIT_FUNCTION_DWA052000_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/functions.hpp>
-# include <boost/python/detail/signatures.hpp>
-# include <typeinfo>
-
-namespace boost { namespace python {
-
-namespace detail {
-
-  // parameter_traits - so far, this is a way to pass a const T& when we can be
-  // sure T is not a reference type, and a raw T otherwise. This should be
-  // rolled into boost::call_traits. Ordinarily, parameter_traits would be
-  // written:
-  //
-  //    template <class T> struct parameter_traits
-  //    {
-  //        typedef const T& const_reference;
-  //    };
-  //
-  //    template <class T> struct parameter_traits<T&>
-  //    {
-  //        typedef T& const_reference;
-  //    };
-  //
-  //    template <> struct parameter_traits<void>
-  //    {
-  //        typedef void const_reference;
-  //    };
-  //
-  // ...but since we can't partially specialize on reference types, we need this
-  // long-winded but equivalent incantation.
-
-  // const_ref_selector -- an implementation detail of parameter_traits (below). This uses
-  // the usual "poor man's partial specialization" hack for MSVC. 
-  template <bool is_ref>
-  struct const_ref_selector
-  {
-      template <class T>
-      struct const_ref
-      {
-          typedef const T& type;
-      };
-  };
-
-  template <>
-  struct const_ref_selector<true>
-  {
-      template <class T>
-      struct const_ref
-      {
-          typedef T type;
-      };
-  };
-
-# ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable: 4181)
-# endif // BOOST_MSVC
-  template <class T>
-  struct parameter_traits
-  {
-   private:
-      enum { is_ref = boost::is_reference<T>::value };
-      typedef const_ref_selector<is_ref> selector;
-   public:
-      typedef typename selector::template const_ref<T>::type const_reference;
-  };
-# ifdef BOOST_MSVC
-#  pragma warning(pop)
-# endif // BOOST_MSVC
-
-  // Full spcialization for void
-  template <>
-  struct parameter_traits<void>
-  {
-      typedef void const_reference;
-  };
-
-  template <class T>
-  class reference_parameter
-  {
-      typedef typename parameter_traits<T>::const_reference const_reference;
-   public:
-      reference_parameter(const_reference value)
-          : value(value) {}
-      operator const_reference() { return value; }
-   private:
-      const_reference value;
-  };
-
-class extension_instance;
-class instance_holder_base;
-
-class init;
-template <class T> struct init0;
-template <class T, class A1> struct init1;
-template <class T, class A1, class A2> struct init2;
-template <class T, class A1, class A2, class A3> struct init3;
-template <class T, class A1, class A2, class A3, class A4> struct init4;
-template <class T, class A1, class A2, class A3, class A4, class A5> struct init5;
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6> struct init6;
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct init7;
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct init8;
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct init9;
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> struct init10;
-
-template <class T>
-struct init_function
-{
-    static init* create(signature0) {
-        return new init0<T>;
-    }
-
-    template <class A1>
-    static init* create(signature1<A1>) {
-        return new init1<T,
-                       detail::parameter_traits<A1>::const_reference>;
-    }
-
-    template <class A1, class A2>
-    static init* create(signature2<A1, A2>) {
-        return new init2<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3>
-    static init* create(signature3<A1, A2, A3>) {
-        return new init3<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4>
-    static init* create(signature4<A1, A2, A3, A4>) {
-        return new init4<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5>
-    static init* create(signature5<A1, A2, A3, A4, A5>) {
-        return new init5<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       detail::parameter_traits<A5>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    static init* create(signature6<A1, A2, A3, A4, A5, A6>) {
-        return new init6<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       detail::parameter_traits<A5>::const_reference,
-                       detail::parameter_traits<A6>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static init* create(signature7<A1, A2, A3, A4, A5, A6, A7>) {
-        return new init7<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       detail::parameter_traits<A5>::const_reference,
-                       detail::parameter_traits<A6>::const_reference,
-                       detail::parameter_traits<A7>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static init* create(signature8<A1, A2, A3, A4, A5, A6, A7, A8>) {
-        return new init8<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       detail::parameter_traits<A5>::const_reference,
-                       detail::parameter_traits<A6>::const_reference,
-                       detail::parameter_traits<A7>::const_reference,
-                       detail::parameter_traits<A8>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static init* create(signature9<A1, A2, A3, A4, A5, A6, A7, A8, A9>) {
-        return new init9<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       detail::parameter_traits<A5>::const_reference,
-                       detail::parameter_traits<A6>::const_reference,
-                       detail::parameter_traits<A7>::const_reference,
-                       detail::parameter_traits<A8>::const_reference,
-                       detail::parameter_traits<A9>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static init* create(signature10<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>) {
-        return new init10<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       detail::parameter_traits<A5>::const_reference,
-                       detail::parameter_traits<A6>::const_reference,
-                       detail::parameter_traits<A7>::const_reference,
-                       detail::parameter_traits<A8>::const_reference,
-                       detail::parameter_traits<A9>::const_reference,
-                       detail::parameter_traits<A10>::const_reference>;
-    }
-};
-
-class init : public function
-{
-private: // override function hook
-    PyObject* do_call(PyObject* args, PyObject* keywords) const;
-private:
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* tail_args, PyObject* keywords) const = 0;
-};
-
-
-template <class T>
-struct init0 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        if (!PyArg_ParseTuple(args, const_cast<char*>("")))
-            throw argument_error();
-        return new T(self
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&)).name(); }
-};
-
-template <class T, class A1>
-struct init1 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &a1))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1)).name(); }
-};
-
-template <class T, class A1, class A2>
-struct init2 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &a1, &a2))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2)).name(); }
-};
-
-template <class T, class A1, class A2, class A3>
-struct init3 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &a1, &a2, &a3))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4>
-struct init4 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &a1, &a2, &a3, &a4))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5>
-struct init5 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &a1, &a2, &a3, &a4, &a5))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
-struct init6 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
-            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-struct init7 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
-            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
-            boost::python::detail::reference_parameter<A7>(from_python(a7, type<A7>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-struct init8 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        PyObject* a8;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
-            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
-            boost::python::detail::reference_parameter<A7>(from_python(a7, type<A7>())),
-            boost::python::detail::reference_parameter<A8>(from_python(a8, type<A8>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7, A8)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-struct init9 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        PyObject* a8;
-        PyObject* a9;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
-            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
-            boost::python::detail::reference_parameter<A7>(from_python(a7, type<A7>())),
-            boost::python::detail::reference_parameter<A8>(from_python(a8, type<A8>())),
-            boost::python::detail::reference_parameter<A9>(from_python(a9, type<A9>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7, A8, A9)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-struct init10 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        PyObject* a8;
-        PyObject* a9;
-        PyObject* a10;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
-            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
-            boost::python::detail::reference_parameter<A7>(from_python(a7, type<A7>())),
-            boost::python::detail::reference_parameter<A8>(from_python(a8, type<A8>())),
-            boost::python::detail::reference_parameter<A9>(from_python(a9, type<A9>())),
-            boost::python::detail::reference_parameter<A10>(from_python(a10, type<A10>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)).name(); }
-};
-
-}}} // namespace boost::python::detail
-
-#endif // INIT_FUNCTION_DWA052000_H_

include/boost/python/detail/none.hpp

@@ -1,21 +0,0 @@
-//  (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 NONE_DWA_052000_H_
-# define NONE_DWA_052000_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-
-namespace boost { namespace python { namespace detail {
-
-inline PyObject* none() { Py_INCREF(Py_None); return Py_None; }
-    
-}}} // namespace boost::python::detail
-
-#endif // NONE_DWA_052000_H_

include/boost/python/detail/returning.hpp

@@ -1,846 +0,0 @@
-//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  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_returning.py
-
-#ifndef RETURNING_DWA20011201_HPP
-# define RETURNING_DWA20011201_HPP
-
-//# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/config.hpp>
-# include <boost/python/convert.hpp>
-# include <boost/python/detail/none.hpp>
-
-namespace boost { namespace python { namespace detail {
-
-// Calling C++ from Python
-template <class R>
-struct returning
-{
-    template <class A0>
-    static PyObject* call(R (A0::*pmf)(), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-
-        // find the result converter
-        wrap_more<R> r(c0);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)() );
-    };
-    template <class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-
-        // find the result converter
-        wrap_more<R> r(c1);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1) );
-    };
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-
-        // find the result converter
-        wrap_more<R> r(c2);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2) );
-    };
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-
-        // find the result converter
-        wrap_more<R> r(c3);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3) );
-    };
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-
-        // find the result converter
-        wrap_more<R> r(c4);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4) );
-    };
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
-
-        // find the result converter
-        wrap_more<R> r(c5);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5) );
-    };
-
-    template <class A0>
-    static PyObject* call(R (A0::*pmf)() const, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-
-        // find the result converter
-        wrap_more<R> r(c0);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)() );
-    };
-    template <class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) const, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-
-        // find the result converter
-        wrap_more<R> r(c1);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1) );
-    };
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) const, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-
-        // find the result converter
-        wrap_more<R> r(c2);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2) );
-    };
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-
-        // find the result converter
-        wrap_more<R> r(c3);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3) );
-    };
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-
-        // find the result converter
-        wrap_more<R> r(c4);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4) );
-    };
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
-
-        // find the result converter
-        wrap_more<R> r(c5);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5) );
-    };
-
-    template <class A0>
-    static PyObject* call(R (A0::*pmf)() volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-
-        // find the result converter
-        wrap_more<R> r(c0);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)() );
-    };
-    template <class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-
-        // find the result converter
-        wrap_more<R> r(c1);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1) );
-    };
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-
-        // find the result converter
-        wrap_more<R> r(c2);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2) );
-    };
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-
-        // find the result converter
-        wrap_more<R> r(c3);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3) );
-    };
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-
-        // find the result converter
-        wrap_more<R> r(c4);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4) );
-    };
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
-
-        // find the result converter
-        wrap_more<R> r(c5);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5) );
-    };
-
-
-// missing const volatile type traits
-#  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    template <class A0>
-    static PyObject* call(R (A0::*pmf)() const volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-
-        // find the result converter
-        wrap_more<R> r(c0);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)() );
-    };
-    template <class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) const volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-
-        // find the result converter
-        wrap_more<R> r(c1);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1) );
-    };
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) const volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-
-        // find the result converter
-        wrap_more<R> r(c2);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2) );
-    };
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-
-        // find the result converter
-        wrap_more<R> r(c3);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3) );
-    };
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-
-        // find the result converter
-        wrap_more<R> r(c4);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4) );
-    };
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
-
-        // find the result converter
-        wrap_more<R> r(c5);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5) );
-    };
-
-#  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-            
-    static PyObject* call(R (*pf)(), PyObject*, PyObject* /* keywords */ )
-    {
-        // find the result converter
-        wrap<R> r;
-        return r( (*pf)() );
-    };
-    template <class A0>
-    static PyObject* call(R (*pf)(A0), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-
-        // find the result converter
-        wrap_more<R> r(c0);
-        if (!c0) return 0;
-        return r( (*pf)(*c0) );
-    };
-    template <class A0, class A1>
-    static PyObject* call(R (*pf)(A0, A1), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-
-        // find the result converter
-        wrap_more<R> r(c1);
-        if (!c0) return 0;
-        return r( (*pf)(*c0, *c1) );
-    };
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (*pf)(A0, A1, A2), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-
-        // find the result converter
-        wrap_more<R> r(c2);
-        if (!c0) return 0;
-        return r( (*pf)(*c0, *c1, *c2) );
-    };
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-
-        // find the result converter
-        wrap_more<R> r(c3);
-        if (!c0) return 0;
-        return r( (*pf)(*c0, *c1, *c2, *c3) );
-    };
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-
-        // find the result converter
-        wrap_more<R> r(c4);
-        if (!c0) return 0;
-        return r( (*pf)(*c0, *c1, *c2, *c3, *c4) );
-    };
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
-
-        // find the result converter
-        wrap_more<R> r(c5);
-        if (!c0) return 0;
-        return r( (*pf)(*c0, *c1, *c2, *c3, *c4, *c5) );
-    };
-};
-                           
-template <>
-struct returning<void>
-{
-    typedef void R;
-    template <class A0>
-    static PyObject* call(R (A0::*pmf)(), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-
-        if (!c0) return 0;
-        ((*c0).*pmf)();
-        return detail::none();
-    };
-    template <class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3, *c4);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5);
-        return detail::none();
-    };
-
-    template <class A0>
-    static PyObject* call(R (A0::*pmf)() const, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-
-        if (!c0) return 0;
-        ((*c0).*pmf)();
-        return detail::none();
-    };
-    template <class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) const, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) const, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3, *c4);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5);
-        return detail::none();
-    };
-
-    template <class A0>
-    static PyObject* call(R (A0::*pmf)() volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-
-        if (!c0) return 0;
-        ((*c0).*pmf)();
-        return detail::none();
-    };
-    template <class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3, *c4);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5);
-        return detail::none();
-    };
-
-
-// missing const volatile type traits
-#  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    template <class A0>
-    static PyObject* call(R (A0::*pmf)() const volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-
-        if (!c0) return 0;
-        ((*c0).*pmf)();
-        return detail::none();
-    };
-    template <class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) const volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) const volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3, *c4);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
-
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5);
-        return detail::none();
-    };
-
-#  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-            
-    static PyObject* call(R (*pf)(), PyObject*, PyObject* /* keywords */ )
-    {
-        (*pf)();
-        return detail::none();
-    };
-    template <class A0>
-    static PyObject* call(R (*pf)(A0), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-
-        if (!c0) return 0;
-        (*pf)(*c0);
-        return detail::none();
-    };
-    template <class A0, class A1>
-    static PyObject* call(R (*pf)(A0, A1), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-
-        if (!c0) return 0;
-        (*pf)(*c0, *c1);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (*pf)(A0, A1, A2), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-
-        if (!c0) return 0;
-        (*pf)(*c0, *c1, *c2);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-
-        if (!c0) return 0;
-        (*pf)(*c0, *c1, *c2, *c3);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-
-        if (!c0) return 0;
-        (*pf)(*c0, *c1, *c2, *c3, *c4);
-        return detail::none();
-    };
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
-    {
-        // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
-
-        if (!c0) return 0;
-        (*pf)(*c0, *c1, *c2, *c3, *c4, *c5);
-        return detail::none();
-    };
-};
-
-}}} // namespace boost::python::detail
-
-#endif // RETURNING_DWA20011201_HPP
-

include/boost/python/detail/signatures.hpp

@@ -1,251 +0,0 @@
-//  (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 automatically generated by gen_signatures.python for 10 arguments.
-#ifndef SIGNATURES_DWA050900_H_
-# define SIGNATURES_DWA050900_H_
-
-# include <boost/python/detail/config.hpp>
-
-namespace boost { namespace python {
-
-namespace detail {
-// A stand-in for the built-in void. This one can be passed to functions and
-// (under MSVC, which has a bug, be used as a default template type parameter).
-struct void_t {};
-}
-
-// An envelope in which type information can be delivered for the purposes
-// of selecting an overloaded from_python() function. This is needed to work
-// around MSVC's lack of partial specialiation/ordering. Where normally we'd
-// want to form a function call like void f<const T&>(), We instead pass
-// type<const T&> as one of the function parameters to select a particular
-// overload.
-//
-// The id typedef helps us deal with the lack of partial ordering by generating
-// unique types for constructor signatures. In general, type<T>::id is type<T>,
-// but type<void_t>::id is just void_t.
-template <class T>
-struct type
-{
-    typedef type id;
-};
-
-template <>
-struct type<boost::python::detail::void_t>
-{
-    typedef boost::python::detail::void_t id;
-};
-
-namespace detail {
-// These basically encapsulate a chain of types, , used to make the syntax of
-// add(constructor<T1, ...>()) work. We need to produce a unique type for each number
-// of non-default parameters to constructor<>.  Q: why not use a recursive
-// formulation for infinite extensibility? A: MSVC6 seems to choke on constructs
-// that involve recursive template nesting.
-//
-// signature chaining
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
-struct signature10 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
-struct signature9 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class X>
-inline signature10<X, T1, T2, T3, T4, T5, T6, T7, T8, T9> prepend(type<X>, signature9<T1, T2, T3, T4, T5, T6, T7, T8, T9>)
-    { return signature10<X, T1, T2, T3, T4, T5, T6, T7, T8, T9>(); }
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
-struct signature8 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class X>
-inline signature9<X, T1, T2, T3, T4, T5, T6, T7, T8> prepend(type<X>, signature8<T1, T2, T3, T4, T5, T6, T7, T8>)
-    { return signature9<X, T1, T2, T3, T4, T5, T6, T7, T8>(); }
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-struct signature7 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class X>
-inline signature8<X, T1, T2, T3, T4, T5, T6, T7> prepend(type<X>, signature7<T1, T2, T3, T4, T5, T6, T7>)
-    { return signature8<X, T1, T2, T3, T4, T5, T6, T7>(); }
-
-template <class T1, class T2, class T3, class T4, class T5, class T6>
-struct signature6 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class X>
-inline signature7<X, T1, T2, T3, T4, T5, T6> prepend(type<X>, signature6<T1, T2, T3, T4, T5, T6>)
-    { return signature7<X, T1, T2, T3, T4, T5, T6>(); }
-
-template <class T1, class T2, class T3, class T4, class T5>
-struct signature5 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class X>
-inline signature6<X, T1, T2, T3, T4, T5> prepend(type<X>, signature5<T1, T2, T3, T4, T5>)
-    { return signature6<X, T1, T2, T3, T4, T5>(); }
-
-template <class T1, class T2, class T3, class T4>
-struct signature4 {};
-
-template <class T1, class T2, class T3, class T4, class X>
-inline signature5<X, T1, T2, T3, T4> prepend(type<X>, signature4<T1, T2, T3, T4>)
-    { return signature5<X, T1, T2, T3, T4>(); }
-
-template <class T1, class T2, class T3>
-struct signature3 {};
-
-template <class T1, class T2, class T3, class X>
-inline signature4<X, T1, T2, T3> prepend(type<X>, signature3<T1, T2, T3>)
-    { return signature4<X, T1, T2, T3>(); }
-
-template <class T1, class T2>
-struct signature2 {};
-
-template <class T1, class T2, class X>
-inline signature3<X, T1, T2> prepend(type<X>, signature2<T1, T2>)
-    { return signature3<X, T1, T2>(); }
-
-template <class T1>
-struct signature1 {};
-
-template <class T1, class X>
-inline signature2<X, T1> prepend(type<X>, signature1<T1>)
-    { return signature2<X, T1>(); }
-
-struct signature0 {};
-
-template <class X>
-inline signature1<X> prepend(type<X>, signature0)
-    { return signature1<X>(); }
-
-
-// This one terminates the chain. Prepending void_t to the head of a void_t
-// signature results in a void_t signature again.
-inline signature0 prepend(void_t, signature0) { return signature0(); }
-
-} // namespace detail
-
-template <class A1 = detail::void_t, class A2 = detail::void_t, class A3 = detail::void_t, class A4 = detail::void_t, class A5 = detail::void_t, class A6 = detail::void_t, class A7 = detail::void_t, class A8 = detail::void_t, class A9 = detail::void_t, class A10 = detail::void_t>
-struct constructor
-{
-};
-
-namespace detail {
-// Return value extraction:
-
-// This is just another little envelope for carrying a typedef (see type,
-// above). I could have re-used type, but that has a very specific purpose. I
-// thought this would be clearer.
-template <class T>
-struct return_value_select { typedef T type; };
-
-// free functions
-template <class R>
-return_value_select<R> return_value(R (*)()) { return return_value_select<R>(); }
-
-template <class R, class A1>
-return_value_select<R> return_value(R (*)(A1)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2>
-return_value_select<R> return_value(R (*)(A1, A2)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3>
-return_value_select<R> return_value(R (*)(A1, A2, A3)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) { return return_value_select<R>(); }
-
-// TODO(?): handle 'const void'
-
-// member functions
-template <class R, class T>
-return_value_select<R> return_value(R (T::*)()) { return return_value_select<R>(); }
-
-template <class R, class T, class A1>
-return_value_select<R> return_value(R (T::*)(A1)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2>
-return_value_select<R> return_value(R (T::*)(A1, A2)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) { return return_value_select<R>(); }
-
-template <class R, class T>
-return_value_select<R> return_value(R (T::*)() const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1>
-return_value_select<R> return_value(R (T::*)(A1) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2>
-return_value_select<R> return_value(R (T::*)(A1, A2) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const) { return return_value_select<R>(); }
-
-}}} // namespace boost::python::detail
-
-#endif

include/boost/python/detail/singleton.hpp

@@ -1,68 +0,0 @@
-//  (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 SINGLETON_DWA051900_H_
-# define SINGLETON_DWA051900_H_
-
-# include <boost/python/detail/config.hpp>
-
-namespace boost { namespace python { namespace detail {
-
-struct empty {};
-template <class Derived, class Base = empty>
-struct singleton : Base
-{
-    typedef singleton singleton_base; // Convenience type for derived class constructors
-    
-    static Derived* instance();
-
-    // Pass-through constructors
-    singleton() : Base() {}
-
-    template <class A1>
-    singleton(const A1& a1) : Base(a1) {}
-
-    template <class A1, class A2>
-    singleton(const A1& a1, const A2& a2) : Base(a1, a2) {}
-
-    template <class A1, class A2, class A3>
-    singleton(const A1& a1, const A2& a2, const A3& a3) : Base(a1, a2, a3) {}
-
-    template <class A1, class A2, class A3, class A4>
-    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4) : Base(a1, a2, a3, a4) {}
-
-    template <class A1, class A2, class A3, class A4, class A5>
-    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) : Base(a1, a2, a3, a4, a5) {}
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6) : Base(a1, a2, a3, a4, a5, a6) {}
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7) : Base(a1, a2, a3, a4, a5, a6, a7) {}
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8) : Base(a1, a2, a3, a4, a5, a6, a7, a8) {}
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    singleton(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) : Base(a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    singleton(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) : Base(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
-
-};
-
-template <class Derived, class Base>
-Derived* singleton<Derived,Base>::instance()
-{
-    static Derived x;
-    return &x;
-}
-
-}}} // namespace boost::python::detail
-
-#endif

include/boost/python/detail/types.hpp

@@ -1,417 +0,0 @@
-//  (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 TYPES_DWA051800_H_
-# define TYPES_DWA051800_H_
-
-//  Usage:
-//  class X : public
-//          boost::python::callable<
-//          boost::python::getattrable <
-//          boost::python::setattrable<python_object, X> > >
-//  {
-//  public:
-//      ref call(args, kw);
-//      ref getattr(args, kw);
-//      ref setattr(args, kw);
-//  };
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/signatures.hpp> // really just for type<>
-# include <boost/python/detail/cast.hpp>
-# include <boost/python/detail/base_object.hpp>
-# include <typeinfo>
-# include <vector>
-# include <cassert>
-
-namespace boost { namespace python {
-
-class string;
-
-namespace detail {
-
-class instance_holder_base;
-
-class type_object_base : public python_type
-{
- public:
-    explicit type_object_base(PyTypeObject* type_type);
-    virtual ~type_object_base();
-
- public:
-    enum capability {
-        hash, call, str, getattr, setattr, compare, repr, richcompare,
-
-        mapping_length, mapping_subscript, mapping_ass_subscript,
-        
-        sequence_length, sequence_item, sequence_ass_item,
-        sequence_concat, sequence_repeat, sequence_slice, sequence_ass_slice,
-        
-        number_add, number_subtract, number_multiply, number_divide,
-        number_remainder, number_divmod, number_power, number_negative,
-        number_positive, number_absolute, number_nonzero, number_invert,
-        number_lshift, number_rshift, number_and, number_xor, number_or,
-        number_coerce, number_int, number_long, number_float, number_oct,
-        number_hex, number_inplace_add, number_inplace_subtract,
-        number_inplace_multiply, number_inplace_divide,
-        number_inplace_remainder, number_inplace_power,
-        number_inplace_lshift, number_inplace_rshift,
-        number_inplace_and, number_inplace_or, number_inplace_xor
-    };
-    
-    void enable(capability);
-    
-    //
-    // type behaviors
-    //
- public: // Callbacks for basic type functionality.
-    virtual PyObject* instance_repr(PyObject*) const;
-    virtual int instance_compare(PyObject*, PyObject* other) const;
-    virtual PyObject* instance_str(PyObject*) const;
-    virtual long instance_hash(PyObject*) const;
-    virtual PyObject* instance_call(PyObject* obj, PyObject* args, PyObject* kw) const;
-    virtual PyObject* instance_getattr(PyObject* obj, const char* name) const;
-    virtual int instance_setattr(PyObject* obj, const char* name, PyObject* value) const;
-
-    // Dealloc is a special case, since every type needs a nonzero tp_dealloc slot.
-    virtual void instance_dealloc(PyObject*) const = 0;
-
- public: // Callbacks for mapping methods
-    virtual int instance_mapping_length(PyObject*) const;
-    virtual PyObject* instance_mapping_subscript(PyObject*, PyObject*) const ;
-    virtual int instance_mapping_ass_subscript(PyObject*, PyObject*, PyObject*) const;
-
- public: // Callbacks for sequence methods
-    virtual int instance_sequence_length(PyObject* obj) const;
-    virtual PyObject* instance_sequence_concat(PyObject* obj, PyObject* other) const;
-    virtual PyObject* instance_sequence_repeat(PyObject* obj, int n) const;
-    virtual PyObject* instance_sequence_item(PyObject* obj, int n) const;
-    virtual PyObject* instance_sequence_slice(PyObject* obj, int start, int finish) const;
-    virtual int instance_sequence_ass_item(PyObject* obj, int n, PyObject* value) const;
-    virtual int instance_sequence_ass_slice(PyObject* obj, int start, int finish, PyObject* value) const;
-    
- public: // Callbacks for number methods
-    virtual PyObject* instance_number_add(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_subtract(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_multiply(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_divide(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_remainder(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_divmod(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_power(PyObject*, PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_negative(PyObject*) const;
-    virtual PyObject* instance_number_positive(PyObject*) const;
-    virtual PyObject* instance_number_absolute(PyObject*) const;
-    virtual int instance_number_nonzero(PyObject*) const;
-    virtual PyObject* instance_number_invert(PyObject*) const;
-    virtual PyObject* instance_number_lshift(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_rshift(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_and(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_xor(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_or(PyObject*, PyObject*) const;
-    virtual int instance_number_coerce(PyObject*, PyObject**, PyObject**) const;
-    virtual PyObject* instance_number_int(PyObject*) const;
-    virtual PyObject* instance_number_long(PyObject*) const;
-    virtual PyObject* instance_number_float(PyObject*) const;
-    virtual PyObject* instance_number_oct(PyObject*) const;
-    virtual PyObject* instance_number_hex(PyObject*) const;
-
-    virtual PyObject* instance_number_inplace_add(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_inplace_subtract(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_inplace_multiply(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_inplace_divide(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_inplace_remainder(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_inplace_power(PyObject*, PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_inplace_lshift(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_inplace_rshift(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_inplace_and(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_inplace_or(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_inplace_xor(PyObject*, PyObject*) const;
-
- public: // Callbacks for rich comparisons
-    virtual PyObject* instance_lt(PyObject*, PyObject*) const;
-    virtual PyObject* instance_le(PyObject*, PyObject*) const;
-    virtual PyObject* instance_eq(PyObject*, PyObject*) const;
-    virtual PyObject* instance_ne(PyObject*, PyObject*) const;
-    virtual PyObject* instance_gt(PyObject*, PyObject*) const;
-    virtual PyObject* instance_ge(PyObject*, PyObject*) const;
-};
-
-template <class T>
-class type_object : public type_object_base
-{
- public:
-    typedef T instance;
-
-    type_object(PyTypeObject* type_type, const char* name)
-        : type_object_base(type_type)
-    {
-        assert(name != 0);
-        this->tp_name = const_cast<char*>(name);
-    }
-
-    type_object(PyTypeObject* type_type)
-        : type_object_base(type_type)
-    {
-        this->tp_name = const_cast<char*>(typeid(instance).name());
-    }
-
- private: // Overridable behaviors.
-    // Called when the reference count goes to zero. The default implementation
-    // is "delete p". If you have not allocated your object with operator new or
-    // you have other constraints, you'll need to override this
-    virtual void dealloc(T* p) const;
-    
- private: // Implementation of type_object_base hooks. Do not reimplement in derived classes.
-    void instance_dealloc(PyObject*) const;
-};
-
-//
-// type objects
-//
-template <class Base>
-class callable : public Base
-{
- public:
-    typedef callable properties; // Convenience for derived class construction
-    typedef typename Base::instance instance;
-    callable(PyTypeObject* type_type, const char* name);
-    callable(PyTypeObject* type_type);
- private:
-    PyObject* instance_call(PyObject* obj, PyObject* args, PyObject* kw) const;
-};
-
-template <class Base>
-class getattrable : public Base
-{
- public:
-    typedef getattrable properties; // Convenience for derived class construction
-    typedef typename Base::instance instance;
-    getattrable(PyTypeObject* type_type, const char* name);
-    getattrable(PyTypeObject* type_type);
- private:
-    PyObject* instance_getattr(PyObject* obj, const char* name) const;
-};
-
-template <class Base>
-class setattrable : public Base
-{
- public:
-    typedef setattrable properties; // Convenience for derived class construction
-    typedef typename Base::instance instance;
-    setattrable(PyTypeObject* type_type, const char* name);
-    setattrable(PyTypeObject* type_type);
- private:
-    int instance_setattr(PyObject* obj, const char* name, PyObject* value) const;
-};
-
-template <class Base>
-class reprable : public Base
-{
- public:
-    typedef reprable properties; // Convenience for derived class construction
-    typedef typename Base::instance instance;
-    reprable(PyTypeObject* type_type, const char* name);
-    reprable(PyTypeObject* type_type);
- private:
-    PyObject* instance_repr(PyObject* obj) const;
-};
-
-//
-// Member function definitions
-//
-
-// type_object<>
-template <class T>
-void type_object<T>::instance_dealloc(PyObject* obj) const
-{
-    this->dealloc(downcast<instance>(obj).get());
-}
-
-template <class T>
-void type_object<T>::dealloc(T* obj) const
-{
-    delete obj;
-}
-
-// callable
-template <class Base>
-callable<Base>::callable(PyTypeObject* type_type, const char* name)
-    : Base(type_type, name)
-{
-    this->enable(call);
-}
-        
-template <class Base>
-callable<Base>::callable(PyTypeObject* type_type)
-    : Base(type_type)
-{
-    this->enable(call);
-}
-        
-template <class Base>
-PyObject* callable<Base>::instance_call(PyObject* obj, PyObject* args, PyObject* kw) const
-{
-    return downcast<instance>(obj)->call(args, kw);
-}
-
-// getattrable
-template <class Base>
-getattrable<Base>::getattrable(PyTypeObject* type_type, const char* name)
-    : Base(type_type, name)
-{
-    this->enable(getattr);
-}
-        
-template <class Base>
-getattrable<Base>::getattrable(PyTypeObject* type_type)
-    : Base(type_type)
-{
-    this->enable(getattr);
-}
-        
-template <class Base>
-PyObject* getattrable<Base>::instance_getattr(PyObject* obj, const char* name) const
-{
-    return downcast<instance>(obj)->getattr(name);
-}
-
-// setattrable
-template <class Base>
-setattrable<Base>::setattrable(PyTypeObject* type_type, const char* name)
-    : Base(type_type, name)
-{
-    this->enable(setattr);
-}
-        
-template <class Base>
-setattrable<Base>::setattrable(PyTypeObject* type_type)
-    : Base(type_type)
-{
-    this->enable(setattr);
-}
-        
-template <class Base>
-int setattrable<Base>::instance_setattr(PyObject* obj, const char* name, PyObject* value) const
-{
-    return downcast<instance>(obj)->setattr(name, value);
-}
-
-// reprable
-template <class Base>
-reprable<Base>::reprable(PyTypeObject* type_type, const char* name)
-    : Base(type_type, name)
-{
-    this->enable(repr);
-}
-        
-template <class Base>
-reprable<Base>::reprable(PyTypeObject* type_type)
-    : Base(type_type)
-{
-    this->enable(repr);
-}
-        
-template <class Base>
-PyObject* reprable<Base>::instance_repr(PyObject* obj) const
-{
-    return downcast<instance>(obj)->repr();
-}
-
-  // Helper class for optimized allocation of PODs: If two PODs
-  // happen to contain identical byte patterns, they may share their
-  // memory. Reference counting is used to free unused memory. 
-  // This is useful because method tables of related extension classes tend
-  // to be identical, so less memory is needed for them.
-  class shared_pod_manager
-  {
-      typedef std::pair<char*, std::size_t> holder;
-      typedef std::vector<holder> storage;
-        
-   public:
-      static shared_pod_manager& obj();
-      ~shared_pod_manager();
-
-      // Allocate memory for POD T and fill it with zeros.
-      // This memory is initially not shared.
-      template <class T>
-      static void create(T*& t)
-      {
-          t = reinterpret_cast<T*>(obj().create(sizeof(T)));
-      }
-
-      // Decrement the refcount for the memory t points to. If the count 
-      // goes to zero, the memory is freed.
-      template <class T>
-      static void dispose(T* t)
-      {
-          obj().dec_ref(t, sizeof(T));
-      }
-
-      // Attempt to share the memory t points to. If memory with the same 
-      // contents already exists, t is replaced by a pointer to this memory,
-      // and t's old memory is disposed. Otherwise, t will be registered for
-      // potential future sharing.
-      template <class T>
-      static void replace_if_equal(T*& t)
-      {
-          t = reinterpret_cast<T*>(obj().replace_if_equal(t, sizeof(T)));
-      }
-
-      // Create a copy of t's memory that is guaranteed to be private to t.
-      // Afterwards t points to the new memory, unless it was already private, in
-      // which case there is no change (except that t's memory will no longer
-      // be considered for future sharing - see raplade_if_equal())
-      // This function *must* be called before the contents of (*t) can
-      // be overwritten. Otherwise, inconsistencies and crashes may result.
-      template <class T>
-      static void make_unique_copy(T*& t)
-      {
-          t = reinterpret_cast<T*>(obj().make_unique_copy(t, sizeof(T)));
-      }
-
-   private:
-      void* replace_if_equal(void* pod, std::size_t size);
-      void* make_unique_copy(void* pod, std::size_t size);
-      void* create(std::size_t size);
-      void dec_ref(void* pod, std::size_t size);
-      void erase_from_list(void* pod);
-        
-      struct compare;
-      struct identical;
-
-   private:
-      shared_pod_manager() {} // instance
-
-#ifdef TYPE_OBJECT_BASE_STANDALONE_TEST
-   public:
-#endif
-      storage m_storage;
-  };
-
-
-  void add_capability(type_object_base::capability capability, 
-                      PyTypeObject* dest);
-
-// This macro gets the length of an array as a compile-time constant, and will
-// fail to compile if the parameter is a pointer.
-#ifdef __BORLANDC__ // smart implementation doesn't work for borland; maybe someone knows a workaround?
-# define PY_ARRAY_LENGTH(a) (sizeof(a) / sizeof((a)[0]))
-#else
-# define PY_ARRAY_LENGTH(a) \
-        (sizeof(::boost::python::detail::countof_validate(a, &(a))) ? sizeof(a) / sizeof((a)[0]) : 0)
-#endif
-
-  template<typename T>
-  inline void countof_validate(T* const, T* const*);
-
-  template<typename T>
-  inline int countof_validate(const void*, T);
-
-}}} // namespace boost::python::detail
-
-#endif // TYPES_DWA051800_H_

include/boost/python/detail/void_adaptor.hpp

@@ -1,39 +0,0 @@
-//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-
-#ifndef VOID_ADAPTOR_DWA20011112_HPP
-# define VOID_ADAPTOR_DWA20011112_HPP
-
-namespace boost { namespace python { namespace detail {
-
-  extern PyObject arbitrary_object;
-
-  template <class T>
-  struct void_adaptor
-  {
-      typedef PyObject* result_type;
-      
-      void_adaptor(T const& f)
-          : m_f(f)
-      {}
-          
-      PyObject* operator()() const
-      {
-          m_f();
-          return &arbitrary_object;
-      }
-   private:
-      T m_f;
-  };
-
-  template <class T>
-  void_adaptor<T> make_void_adaptor(T const& f)
-  {
-      return void_adaptor<T>(f);
-  }
-}}} // namespace boost::python::detail
-
-#endif // VOID_ADAPTOR_DWA20011112_HPP
-

include/boost/python/detail/wrap_python.hpp

@@ -1,118 +0,0 @@
-//  (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 serves as a wrapper around <Python.h> which allows it to be
-//  compiled with GCC 2.95.2 under Win32 and which disables the default MSVC
-//  behavior so that a program may be compiled in debug mode without requiring a
-//  special debugging build of the Python library.
-
-
-//  To use the Python debugging library, #define BOOST_DEBUG_PYTHON on the
-//  compiler command-line.
-
-// Revision History:
-// 05 Mar 01  Suppress warnings under Cygwin with Python 2.0 (Dave Abrahams)
-// 04 Mar 01  Rolled in some changes from the Dragon fork (Dave Abrahams)
-// 01 Mar 01  define PyObject_INIT() for Python 1.x (Dave Abrahams)
-
-
-#include <patchlevel.h>
-
-#ifdef _DEBUG
-# ifndef BOOST_DEBUG_PYTHON
-#  undef _DEBUG // Don't let Python force the debug library just because we're debugging.
-#  define DEBUG_UNDEFINED_FROM_WRAP_PYTHON_H
-# endif
-#endif
-
-//
-// Some things we need in order to get Python.h to work with compilers other
-// than MSVC on Win32
-//
-#if defined(_WIN32)
-# if defined(__GNUC__) && defined(__CYGWIN__)
-#  if PY_MAJOR_VERSION < 2 || PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION <= 2
-typedef int pid_t;
-#   define WORD_BIT 32
-#   define hypot _hypot
-#   include <stdio.h>
-#  endif 
-#  if !defined(PY_MAJOR_VERSION) || PY_MAJOR_VERSION < 2
-#   define HAVE_CLOCK
-#   define HAVE_STRFTIME
-#   define HAVE_STRERROR
-#  endif
-#  define NT_THREADS
-#  define WITH_THREAD
-#  ifndef NETSCAPE_PI
-#   define USE_SOCKET
-#  endif
-
-#  ifdef USE_DL_IMPORT
-#   define DL_IMPORT(RTYPE) __declspec(dllimport) RTYPE
-#  endif
-
-#  ifdef USE_DL_EXPORT
-#   define DL_IMPORT(RTYPE) __declspec(dllexport) RTYPE
-#   define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE
-#  endif
-
-#  define HAVE_LONG_LONG 1
-#  define LONG_LONG long long
-
-# elif defined(__MWERKS__)
-
-#  ifndef _MSC_VER
-#   define PY_MSC_VER_DEFINED_FROM_WRAP_PYTHON_H 1
-#   define _MSC_VER 900
-#  endif
-
-#  if PY_MAJOR_VERSION < 2 || PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 2
-#   include <config.h>
-#  else
-#   include <pyconfig.h>
-#  endif
-#  undef hypot // undo the evil #define left by Python.
-
-# elif defined(__BORLANDC__)
-#  if PY_MAJOR_VERSION < 2 || PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 2
-#   include <config.h>
-#  else
-#   include <pyconfig.h>
-#  endif
-#  undef HAVE_HYPOT
-#  define HAVE_HYPOT 1
-# elif defined(_MSC_VER)
-#  ifdef __cplusplus
-#   include <limits> // prevents Python.h from defining LONGLONG_MAX, LONGLONG_MIN, and ULONGLONG_MAX
-#  endif 
-# endif
-
-#endif // _WIN32
-
-#include <Python.h>
-
-#ifdef PY_MSC_VER_DEFINED_FROM_WRAP_PYTHON_H
-# undef _MSC_VER
-#endif
-
-#ifdef DEBUG_UNDEFINED_FROM_WRAP_PYTHON_H
-# undef DEBUG_UNDEFINED_FROM_WRAP_PYTHON_H
-# define _DEBUG
-#endif
-
-#if !defined(PY_MAJOR_VERSION) || PY_MAJOR_VERSION < 2
-# define PyObject_INIT(op, typeobj) \
-        ( (op)->ob_type = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )
-#endif
-
-#ifdef __MWERKS__
-# pragma warn_possunwant off
-#elif _MSC_VER
-# pragma warning(disable:4786)
-#endif

include/boost/python/object/select_holder.hpp

@@ -0,0 +1,73 @@
+// 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 SELECT_HOLDER_DWA2002322_HPP
+# define SELECT_HOLDER_DWA2002322_HPP
+
+# include <boost/python/has_back_reference.hpp>
+# include <boost/python/detail/not_specified.hpp>
+# include <boost/python/detail/pointee.hpp>
+# include <boost/python/detail/if_else.hpp>
+# include <boost/python/object/value_holder.hpp>
+# include <boost/python/object/pointer_holder.hpp>
+# include <boost/type.hpp>
+# include <boost/mpl/select_if.hpp>
+
+namespace boost { namespace python { namespace objects {
+
+namespace detail
+{
+  template <class T, class Held>
+  struct select_value_holder
+  {
+      BOOST_STATIC_CONSTANT(bool, selector = (!is_same<T,Held>::value) | has_back_reference<T>::value);
+  
+      typedef typename mpl::select_if_c<
+          selector
+          , value_holder_back_reference<T,Held>
+          , value_holder<T>
+      >::type holder;
+
+      static holder* get() { return 0; }
+  };
+
+  template <class T,class Ptr>
+  struct select_pointer_holder
+  {
+      typedef typename python::detail::pointee<Ptr>::type pointee;
+      BOOST_STATIC_CONSTANT(bool, selector = (!is_same<T,pointee>::value) | has_back_reference<T>::value);
+      
+      typedef typename mpl::select_if_c<
+          selector
+          , pointer_holder_back_reference<Ptr,T>
+          , pointer_holder<Ptr,T>
+      >::type holder;
+      
+      static holder* get() { return 0; }
+  };
+}
+
+template <class T, class NotSpecified>
+inline detail::select_value_holder<T,T> select_holder(python::detail::not_specified*, T* = 0, NotSpecified* = 0)
+{
+    return detail::select_value_holder<T,T>();
+}
+
+template <class T, class Held>
+inline detail::select_value_holder<T, Held> select_holder(T*, Held* = 0)
+{
+    return detail::select_value_holder<T, Held>();
+}
+
+
+template <class T, class Ptr>
+detail::select_pointer_holder<T,Ptr> select_holder(void*, Ptr* = 0, T* = 0)
+{
+    return detail::select_pointer_holder<T,Ptr>();
+}
+
+}}} // namespace boost::python::objects
+
+#endif // SELECT_HOLDER_DWA2002322_HPP

src/conversions.cpp

@@ -1,287 +0,0 @@
-//  (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:
-// 05 Apr 01  added: from_python std::string type checking (rwgk)
-// 12 Mar 01  Python 1.5.2 fixes (Ralf W. Grosse-Kunstleve)
-// 11 Mar 01  std::string *MAY* include nulls (Alex Martelli)
-// 04 Mar 01  std::complex<> fixes for MSVC (Dave Abrahams)
-// 03 Mar 01  added: converters for [plain] char (Ralf W. Grosse-Kunstleve)
-
-#include <boost/python/conversions.hpp>
-#include <boost/python/detail/void_adaptor.hpp>
-#include <typeinfo>
-#include <exception>
-#ifndef BOOST_NO_LIMITS
-# include <boost/cast.hpp>
-#endif
-
-namespace boost { namespace python {
-
-// IMPORTANT: this function may only be called from within a catch block!
-PyObject* handle_exception_impl(object_functor_base const& f)
-{
-    try
-    {
-        return f();
-    }
-    catch(const boost::python::error_already_set&)
-    {
-        // The python error reporting has already been handled.
-    }
-    catch(const std::bad_alloc&)
-    {
-        PyErr_NoMemory();
-    }
-    catch(const std::exception& x)
-    {
-        PyErr_SetString(PyExc_RuntimeError, x.what());
-    }
-    catch(...)
-    {
-        PyErr_SetString(PyExc_RuntimeError, "unidentifiable C++ exception");
-    }
-    return 0;
-}
-
-void handle_exception(void (*f)())
-{
-    handle_exception(
-        boost::python::detail::make_void_adaptor(f));
-}
-
-namespace detail {
-
-  void expect_complex(PyObject* p)
-  {
-      if (!PyComplex_Check(p))
-      {
-          PyErr_SetString(PyExc_TypeError, "expected a complex number");
-          throw boost::python::argument_error();
-      }
-  }
-
-} // namespace boost::python::detail
-
-}} // namespace boost::python
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-long from_python(PyObject* p, boost::python::type<long>)
-{
-    // Why am I clearing the error here before trying to convert? I know there's a reason...
-    long result;
-    {
-        result = PyInt_AsLong(p);
-        if (PyErr_Occurred())
-            throw boost::python::argument_error();
-    }
-    return result;
-}
-
-double from_python(PyObject* p, boost::python::type<double>)
-{
-    double result;
-    {
-        result = PyFloat_AsDouble(p);
-        if (PyErr_Occurred())
-            throw boost::python::argument_error();
-    }
-    return result;
-}
-
-template <class T>
-T integer_from_python(PyObject* p, boost::python::type<T>)
-{
-    const long long_result = from_python(p, boost::python::type<long>());
-
-#ifndef BOOST_NO_LIMITS
-    try
-    {
-        return boost::numeric_cast<T>(long_result);
-    }
-    catch(const boost::bad_numeric_cast&)
-#else
-    if (static_cast<T>(long_result) == long_result)
-    {
-        return static_cast<T>(long_result);
-    }
-    else
-#endif
-    {
-        char buffer[256];
-        const char message[] = "%ld out of range for %s";
-        sprintf(buffer, message, long_result, typeid(T).name());
-        PyErr_SetString(PyExc_ValueError, buffer);
-        throw boost::python::argument_error();
-    }
-#if defined(__MWERKS__) && __MWERKS__ <= 0x2406
-    return 0; // Not smart enough to know that the catch clause always rethrows
-#endif
-}
-
-template <class T>
-PyObject* integer_to_python(T value)
-{
-    long value_as_long;
-
-#ifndef BOOST_NO_LIMITS
-    try
-    {
-        value_as_long = boost::numeric_cast<long>(value);
-    }
-    catch(const boost::bad_numeric_cast&)
-#else
-    value_as_long = static_cast<long>(value);
-    if (value_as_long != value)
-#endif
-    {
-        const char message[] = "value out of range for Python int";
-        PyErr_SetString(PyExc_ValueError, message);
-        throw boost::python::error_already_set();
-    }
-    
-    return to_python(value_as_long);
-}
-
-int from_python(PyObject* p, boost::python::type<int> type)
-{
-    return integer_from_python(p, type);
-}
-
-PyObject* to_python(unsigned int i)
-{
-    return integer_to_python(i);
-}
-
-unsigned int from_python(PyObject* p, boost::python::type<unsigned int> type)
-{
-    return integer_from_python(p, type);
-}
-
-short from_python(PyObject* p, boost::python::type<short> type)
-{
-    return integer_from_python(p, type);
-}
-
-float from_python(PyObject* p, boost::python::type<float>)
-{
-    return static_cast<float>(from_python(p, boost::python::type<double>()));
-}
-
-PyObject* to_python(unsigned short i)
-{
-    return integer_to_python(i);
-}
-
-unsigned short from_python(PyObject* p, boost::python::type<unsigned short> type)
-{
-    return integer_from_python(p, type);
-}
-
-PyObject* to_python(char c)
-{
-    if (c == '\0') return PyString_FromString("");
-    return PyString_FromStringAndSize(&c, 1);
-}
-
-char from_python(PyObject* p, boost::python::type<char>)
-{
-    int l = -1;
-    if (PyString_Check(p)) l = PyString_Size(p);
-    if (l < 0 || l > 1) {
-        PyErr_SetString(PyExc_TypeError, "expected string of length 0 or 1");
-        throw boost::python::argument_error();
-    }
-    if (l == 0) return '\0';
-    return PyString_AsString(p)[0];
-}
-
-PyObject* to_python(unsigned char i)
-{
-    return integer_to_python(i);
-}
-
-unsigned char from_python(PyObject* p, boost::python::type<unsigned char> type)
-{
-    return integer_from_python(p, type);
-}
-
-PyObject* to_python(signed char i)
-{
-    return integer_to_python(i);
-}
-
-signed char from_python(PyObject* p, boost::python::type<signed char> type)
-{
-    return integer_from_python(p, type);
-}
-
-PyObject* to_python(unsigned long x)
-{
-    return integer_to_python(x);
-}
-
-unsigned long from_python(PyObject* p, boost::python::type<unsigned long> type)
-{
-    return integer_from_python(p, type);
-}
-
-void from_python(PyObject* p, boost::python::type<void>)
-{
-    if (p != Py_None) {
-        PyErr_SetString(PyExc_TypeError, "expected argument of type None");
-        throw boost::python::argument_error();
-    }
-}
-
-const char* from_python(PyObject* p, boost::python::type<const char*>)
-{
-    const char* s = PyString_AsString(p);
-    if (!s)
-        throw boost::python::argument_error();
-    return s;
-}
-
-PyObject* to_python(const std::string& s)
-{
-    return PyString_FromStringAndSize(s.data(), s.size());
-}
-
-std::string from_python(PyObject* p, boost::python::type<std::string>)
-{
-    if (! PyString_Check(p)) {
-        PyErr_SetString(PyExc_TypeError, "expected a string");
-        throw boost::python::argument_error();
-    }
-    return std::string(PyString_AsString(p), PyString_Size(p));
-}
-
-bool from_python(PyObject* p, boost::python::type<bool>)
-{
-    int value = from_python(p, boost::python::type<int>());
-    if (value == 0)
-        return false;
-    return true;
-}
-
-#ifdef BOOST_MSVC6_OR_EARLIER
-// An optimizer bug prevents these from being inlined.
-PyObject* to_python(double d)
-{
-    return PyFloat_FromDouble(d);
-}
-
-PyObject* to_python(float f)
-{
-    return PyFloat_FromDouble(f);
-}
-#endif // BOOST_MSVC6_OR_EARLIER
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-

src/cross_module.cpp

@@ -1,87 +0,0 @@
-/* (C) Copyright Ralf W. Grosse-Kunstleve 2001. Permission to copy, use,
-   modify, sell and distribute this software is granted provided this
-   copyright notice appears in all copies. This software is provided
-   "as is" without express or implied warranty, and with no claim as to
-   its suitability for any purpose.
-
-   Revision History:
-     17 Apr 01 merged into boost CVS trunk (Ralf W. Grosse-Kunstleve)
-*/
-
-# include <boost/python/cross_module.hpp>
-namespace python = boost::python;
-# include <stdio.h> // MSVC6.0SP4 does not know std::fprintf
-# include <string.h> // MSVC6.0SP4 does not know std::strcmp
-
-namespace {
-
-  PyObject* get_module_dict(const char* module_name)
-  {
-      python::ref module_obj(PyImport_ImportModule((char*) module_name));
-      PyObject* module_dict = PyModule_GetDict(module_obj.get());
-      if (module_dict == 0) throw python::import_error();
-      return module_dict;
-  }
-}
-
-namespace boost { namespace python { namespace detail {
-
-const char* converters_attribute_name = "__converters__";
-
-void* import_converter_object(const std::string& module_name,
-                              const std::string& py_class_name,
-                              const std::string& attribute_name)
-{
-    static std::string err;
-    PyObject* module_dict = get_module_dict(const_cast<char*>(module_name.c_str()));
-    PyObject* py_class = PyDict_GetItemString(module_dict, const_cast<char*>(py_class_name.c_str()));
-    if (py_class == 0) {
-        err = std::string("module ") + module_name + " has no attribute " + py_class_name;
-        PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
-        throw python::import_error();
-    }
-    python::ref c_obj(PyObject_GetAttrString(py_class, const_cast<char*>(attribute_name.c_str())), ref::null_ok);
-    if (c_obj.get() == 0) {
-        err = std::string("object ") + module_name + "." + py_class_name
-              + " has no attribute " + attribute_name;
-        PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
-        throw python::import_error();
-    }
-    if (! PyCObject_Check(c_obj.get())) {
-        err = std::string("object ") + module_name + "." + py_class_name + "."
-              + attribute_name + " is not a PyCObject";
-        PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
-        throw python::import_error();
-    }
-    return PyCObject_AsVoidPtr(c_obj.get());
-}
-
-void check_export_converters_api(const int importing_major,
-                                 const int importing_minor,
-                                 const int imported_major,
-                                 const int imported_minor)
-{
-    if (importing_major != imported_major) {
-        // Python uses fprintf(stderr, ...) for API warnings.
-        fprintf(stderr,
-          "Fatal: export_converters_api mismatch:"
-          " Importing module = %d.%d"
-          " Imported module = %d.%d\n",
-          importing_major, importing_minor,
-          imported_major, imported_minor);
-        PyErr_SetString(PyExc_RuntimeError,
-          "Fatal: export_converters_api mismatch");
-        throw import_error();
-    }
-    if (importing_minor != imported_minor) {
-        // Python uses fprintf(stderr, ...) for API warnings.
-        fprintf(stderr,
-          "Warning: export_converters_api mismatch:"
-          " Importing module = %d.%d"
-          " Imported module = %d.%d\n",
-          importing_major, importing_minor,
-          imported_major, imported_minor);
-    }
-}
-
-}}} // namespace boost::python::detail

src/extension_class.cpp

@@ -1,687 +0,0 @@
-//  (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:
-// 04 Mar 01  Use PyObject_INIT() instead of trying to hand-initialize (David Abrahams)
-
-#include <boost/python/detail/extension_class.hpp>
-#include <boost/utility.hpp>
-#include <boost/bind.hpp>
-#include <cstring>
-
-namespace boost { namespace python {
-namespace detail {
-
-  struct operator_dispatcher
-      : public PyObject
-  {
-      static PyTypeObject type_obj;
-      static PyNumberMethods number_methods;
-
-      static operator_dispatcher* create(const ref& o, const ref& s);     
-      
-      ref m_object;
-      ref m_self;
-
-      // data members for allocation/deallocation optimization
-      operator_dispatcher* m_free_list_link;
-      static operator_dispatcher* free_list;
-
-  private: 
-      // only accessible through create()
-      operator_dispatcher(const ref& o, const ref& s);
-  };
-  
-  operator_dispatcher* operator_dispatcher::free_list = 0;
-
-}}} // namespace boost::python::detail
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-inline PyObject* to_python(boost::python::detail::operator_dispatcher* n) { return n; }
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-
-namespace boost { namespace python { 
-
-tuple standard_coerce(ref l, ref r)
-{
-    // Introduced sequence points for exception-safety.
-    ref first(detail::operator_dispatcher::create(l, l));
-    
-    ref second(r->ob_type == &detail::operator_dispatcher::type_obj
-               ? r
-               : ref(detail::operator_dispatcher::create(r, ref())));
-
-    return tuple(first, second);
-}
-
-namespace detail {
-
-  enum { unwrap_exception_code = -1000 };
-
-  int unwrap_args(PyObject* left, PyObject* right, PyObject*& self, PyObject*& other)
-  {
-      if (left->ob_type != &operator_dispatcher::type_obj ||
-          right->ob_type != &operator_dispatcher::type_obj)
-      {
-          PyErr_SetString(PyExc_RuntimeError, "operator_dispatcher::unwrap_args(): expecting operator_dispatcher arguments only!");
-          return unwrap_exception_code;
-      }
-
-      typedef reference<operator_dispatcher> DPtr;
-      DPtr lwrapper(static_cast<operator_dispatcher*>(left), DPtr::increment_count);
-      DPtr rwrapper(static_cast<operator_dispatcher*>(right), DPtr::increment_count);
-      
-      if (lwrapper->m_self.get() != 0)
-      {
-          self = lwrapper->m_self.get();
-          other = rwrapper->m_object.get();
-          return 0;
-      }
-      else
-      {
-          self = rwrapper->m_self.get();
-          other = lwrapper->m_object.get();
-          return 1;
-      }
-  }
-
-  int unwrap_pow_args(PyObject* left, PyObject* right, PyObject* m,
-                                  PyObject*& self, PyObject*& first, PyObject*& second)
-  {
-      if (left->ob_type != &operator_dispatcher::type_obj ||
-          right->ob_type != &operator_dispatcher::type_obj ||
-          m->ob_type != &operator_dispatcher::type_obj)
-      {
-          PyErr_SetString(PyExc_RuntimeError, "operator_dispatcher::unwrap_pow_args(): expecting operator_dispatcher arguments only!");
-          return unwrap_exception_code;
-      }
-      
-      typedef reference<operator_dispatcher> DPtr;
-      DPtr lwrapper(static_cast<operator_dispatcher*>(left), DPtr::increment_count);
-      DPtr rwrapper(static_cast<operator_dispatcher*>(right), DPtr::increment_count);
-      DPtr mwrapper(static_cast<operator_dispatcher*>(m), DPtr::increment_count);
-      
-      if (lwrapper->m_self.get() != 0)
-      {
-          self = lwrapper->m_self.get();
-          first = rwrapper->m_object.get();
-          second = mwrapper->m_object.get();
-          return 0;
-      }
-      else if (rwrapper->m_self.get() != 0)
-      {
-          self = rwrapper->m_self.get();
-          first = lwrapper->m_object.get();
-          second = mwrapper->m_object.get();
-          return 1;
-      }
-      else
-      {
-          self = mwrapper->m_self.get();
-          first = lwrapper->m_object.get();
-          second = rwrapper->m_object.get();
-          return 2;
-      }
-  }
-
-extension_instance* get_extension_instance(PyObject* p)
-{
-    // The object's type will just be some class_t<extension_instance> object,
-    // but if its meta-type is right, then it is an extension_instance.
-    if (p->ob_type->ob_type != extension_meta_class())
-    {
-        PyErr_SetString(PyExc_TypeError, p->ob_type->tp_name);
-        throw boost::python::argument_error();
-    }
-    return static_cast<extension_instance*>(p);
-}
-
-void
-extension_instance::add_implementation(std::auto_ptr<instance_holder_base> holder)
-{
-    for (held_objects::const_iterator p = m_wrapped_objects.begin();
-         p != m_wrapped_objects.end(); ++p)
-    {
-        if (typeid(*holder) == typeid(**p))
-        {
-            PyErr_SetString(PyExc_RuntimeError, "Base class already initialized");
-            throw error_already_set();
-        }
-    }
-    m_wrapped_objects.push_back(holder.release());
-}
-
-extension_instance::extension_instance(PyTypeObject* class_)
-    : instance(class_)
-{
-}
-
-extension_instance::~extension_instance()
-{
-    for (held_objects::const_iterator p = m_wrapped_objects.begin(),
-             finish = m_wrapped_objects.end();
-         p != finish; ++p)
-    {
-        delete *p;
-    }
-}
-    
-meta_class<extension_instance>* extension_meta_class()
-{
-    static meta_class<extension_instance> result;
-    return &result;
-}
-
-typedef class_t<extension_instance> extension_class_t;
-
-bool is_subclass(const extension_class_t* derived,
-                 const PyObject* possible_base)
-{
-
-    tuple bases = derived->bases();
-    
-    for (std::size_t i = 0, size = bases.size(); i < size; ++i)
-    {
-        const PyObject* base = bases[i].get();
-        
-        if (base == possible_base)
-            return true;
-        
-        if (base->ob_type == extension_meta_class())
-        {
-            const extension_class_t* base_class = downcast<const extension_class_t>(base);
-            if (is_subclass(base_class, possible_base))
-                return true;
-        }
-    }
-    return false;
-}
-
-// Return true iff obj is an obj of target_class
-bool is_instance(extension_instance* obj,
-                 class_t<extension_instance>* target_class)
-{
-    if (obj->ob_type == target_class)
-        return true;
-    else
-    {
-        return is_subclass(
-            downcast<class_t<extension_instance> >(obj->ob_type).get(),
-            as_object(target_class));
-    }
-}
-
-void two_string_error(PyObject* exception_object, const char* format, const char* s1, const char* s2)
-{
-    char buffer[256];
-    std::size_t format_length = BOOST_CSTD_::strlen(format);
-    std::size_t length1 = BOOST_CSTD_::strlen(s1);
-    std::size_t length2 = BOOST_CSTD_::strlen(s2);
-
-    std::size_t additional_length = length1 + length2;
-    if (additional_length + format_length > format_length - 1)
-    {
-        std::size_t difference = sizeof(buffer) - 1 - additional_length;
-        length1 -= difference / 2;
-        additional_length -= difference / 2;
-    }
-        
-    sprintf(buffer, format, length1, s1, length2, s2);
-                
-    PyErr_SetString(exception_object, buffer);
-    if (exception_object == PyExc_TypeError)
-        throw argument_error();
-    else
-        throw error_already_set();
-}
-
-// This is called when an attempt has been made to convert the given obj to
-// a C++ type for which it doesn't have any obj data. In that case, either
-// the obj was not derived from the target_class, or the appropriate
-// __init__ function wasn't called to initialize the obj data of the target class.
-void report_missing_instance_data(
-    extension_instance* obj,                // The object being converted
-    class_t<extension_instance>* target_class,     // the extension class of the C++ type
-    const std::type_info& target_typeid,        // The typeid of the C++ type
-    bool target_is_ptr)
-{
-    char buffer[256];
-    if (is_instance(obj, target_class))
-    {
-        if (target_is_ptr)
-        {
-            two_string_error(PyExc_RuntimeError,
-                             "Object of extension class '%.*s' does not wrap <%.*s>.",
-                             obj->ob_type->tp_name, target_typeid.name());
-        }
-        else
-        {
-            const char message[] = "__init__ function for extension class '%.*s' was never called.";
-            sprintf(buffer, message, sizeof(buffer) - sizeof(message) - 1,
-                    target_class->tp_name);
-        }
-        PyErr_SetString(PyExc_RuntimeError, buffer);
-    }
-    else if (target_class == 0)
-    {
-        const char message[] = "Cannot convert to <%.*s>; its Python class was never created or has been deleted.";
-        sprintf(buffer, message, sizeof(buffer) - sizeof(message) - 1, target_typeid.name());
-        PyErr_SetString(PyExc_RuntimeError, buffer);
-    }
-    else    
-    {
-        two_string_error(PyExc_TypeError, "extension class '%.*s' is not convertible into '%.*s'.",
-                         obj->ob_type->tp_name, target_class->tp_name);
-    }
-}
-
-void report_missing_instance_data(
-    extension_instance* obj,                // The object being converted
-    class_t<extension_instance>* target_class,     // the extension class of the C++ type
-    const std::type_info& target_typeid)        // The typeid of the C++ type
-{
-    report_missing_instance_data(obj, target_class, target_typeid, false);
-}
-
-void report_missing_ptr_data(
-    extension_instance* obj,                // The object being converted
-    class_t<extension_instance>* target_class,     // the extension class of the C++ type
-    const std::type_info& target_typeid)        // The typeid of the C++ type
-{
-    report_missing_instance_data(obj, target_class, target_typeid, true);
-}
-
-void report_missing_class_object(const std::type_info& info)
-{
-    char buffer[256];
-    const char message[] = "Cannot convert <%.*s> to python; its Python class was never created or has been deleted.";
-    sprintf(buffer, message, sizeof(buffer) - sizeof(message) - 1, info.name());
-    PyErr_SetString(PyExc_RuntimeError, buffer);
-    throw error_already_set();
-}
-
-void report_released_smart_pointer(const std::type_info& info)
-{
-    char buffer[256];
-    const char message[] = "Converting from python, pointer or smart pointer to <%.*s> is NULL.";
-    sprintf(buffer, message, sizeof(buffer) - sizeof(message) - 1, info.name());
-    PyErr_SetString(PyExc_RuntimeError, buffer);
-    throw argument_error();
-}
-
-read_only_setattr_function::read_only_setattr_function(const char* name)
-    : m_name(name)
-{
-}
-
-PyObject* read_only_setattr_function::do_call(PyObject* /*args*/, PyObject* /*keywords*/) const
-{
-    PyErr_SetObject(PyExc_AttributeError, ("'" + m_name + "' attribute is read-only").get());
-    return 0;
-}
-
-const char* read_only_setattr_function::description() const
-{
-    return "uncallable";
-}
-
-extension_class_base::extension_class_base(const char* name)
-    : class_t<extension_instance>(
-        extension_meta_class(), string(name), tuple(), dictionary())
-{
-}
-
-//  This function is used in from_python() to convert wrapped classes that are 
-//  related by inheritance. The problem is this: although C++ provides all necessary 
-//  conversion operators, source and target of a conversion must be known at compile
-//  time. However, in Python we want to convert classes at runtime. The solution is to
-//  generate conversion functions at compile time, register them within the appropriate 
-//  class objects and call them when a particular runtime conversion is required.
-
-//  If functions for any possible conversion have to be stored, their number will grow 
-//  qudratically. To reduce this number, we actually store only conversion functions
-//  between adjacent levels in the inheritance tree. By traversing the tree recursively,
-//  we can build any allowed conversion as a concatenation of simple conversions. This
-//  traversal is done in the functions try_base_class_conversions() and 
-//  try_derived_class_conversions(). If a particular conversion is impossible, all
-//  conversion functions will return a NULL pointer.
-
-//  The function extract_object_from_holder() attempts to actually extract the pointer 
-//  to the contained object from an instance_holder_base (a wrapper class). A conversion
-//  of the held object to 'T *' is allowed when the conversion 
-//  'dynamic_cast<instance_holder<T> *>(an_instance_holder_base)' succeeds.
-void* extension_class_base::try_class_conversions(instance_holder_base* object) const
-{
-    void* result = try_derived_class_conversions(object);
-    if (result) 
-        return result;
-        
-    if (!object->held_by_value())
-        return try_base_class_conversions(object);
-    else
-        return 0;
-}
-
-void* extension_class_base::try_base_class_conversions(instance_holder_base* object) const
-{
-    for (std::size_t i = 0; i < base_classes().size(); ++i)
-    {
-        if (base_classes()[i].convert == 0) 
-            continue;
-        void* result1 = base_classes()[i].class_object->extract_object_from_holder(object);
-        if (result1)
-            return (*base_classes()[i].convert)(result1);
-        
-        void* result2 = base_classes()[i].class_object->try_base_class_conversions(object);
-        if (result2)
-            return (*base_classes()[i].convert)(result2);
-    }
-    return 0;
-}
-
-void* extension_class_base::try_derived_class_conversions(instance_holder_base* object) const
-{
-    for (std::size_t i = 0; i < derived_classes().size(); ++i)
-    {
-        void* result1 = derived_classes()[i].class_object->extract_object_from_holder(object);
-        if (result1) 
-            return (*derived_classes()[i].convert)(result1);
-        
-        void* result2 = derived_classes()[i].class_object->try_derived_class_conversions(object);
-        if (result2) 
-            return (*derived_classes()[i].convert)(result2);
-    }
-    return 0;
-}
-
-void extension_class_base::add_method(function* method, const char* name)
-{
-    add_method(reference<function>(method), name);
-}
-    
-void extension_class_base::add_method(reference<function> method, const char* name)
-{
-    // Add the attribute to the computed target
-    function::add_to_namespace(method, name, this->dict().get());
-
-    // If it is a special member function it should be enabled both here and there.
-    detail::enable_named_method(this, name);
-}
-
-void extension_class_base::add_constructor_object(function* init_fn)
-{
-    add_method(init_fn, "__init__");
-}
-
-void extension_class_base::add_setter_method(function* setter_, const char* name)
-{
-    reference<function> setter(setter_);
-    add_method(setter, (detail::setattr_string() + name + "__").c_str());
-}
-
-void extension_class_base::add_getter_method(function* getter_, const char* name)
-{
-    reference<function> getter(getter_);
-    add_method(getter, (detail::getattr_string() + name + "__").c_str());
-}
-
-void extension_class_base::set_attribute(const char* name, PyObject* x_)
-{
-    ref x(x_);
-    set_attribute(name, x);
-}
-
-void extension_class_base::set_attribute(const char* name, ref x)
-{
-    dict().set_item(string(name), x);
-    if (PyCallable_Check(x.get()))
-        detail::enable_named_method(this, name);
-}
-
-operator_dispatcher::operator_dispatcher(const ref& o, const ref& s)
-    : m_object(o), m_self(s), m_free_list_link(0)
-
-{
-    PyObject* self = this;
-    PyObject_INIT(self, &type_obj);
-}
-
-operator_dispatcher* 
-operator_dispatcher::create(const ref& object, const ref& self)
-{
-    operator_dispatcher* const result = free_list;
-    if (result == 0)
-        return new operator_dispatcher(object, self);
-    
-    free_list = result->m_free_list_link;
-    result->m_object = object;
-    result->m_self = self;
-
-    PyObject* result_as_pyobject = result;
-    PyObject_INIT(result_as_pyobject, &type_obj);
-    return result;
-}
-
-extern "C"
-{
-
-void operator_dispatcher_dealloc(PyObject* self) 
-{ 
-    operator_dispatcher* obj = static_cast<operator_dispatcher*>(self);
-    obj->m_free_list_link = operator_dispatcher::free_list;
-    operator_dispatcher::free_list = obj;
-    obj->m_object.reset();
-    obj->m_self.reset();
-} 
-
-int operator_dispatcher_coerce(PyObject** l, PyObject** r)
-{
-    Py_INCREF(*l);
-    PyObject* new_r = handle_exception(
-        bind(operator_dispatcher::create,
-                    ref(*r, ref::increment_count),
-                    ref()));
-    if (new_r)
-    {
-        *r = new_r;
-        return 0;
-    }
-    else
-    {
-        return -1;
-    }
-}
-
-
-#define PY_DEFINE_OPERATOR(id, symbol) \
-    PyObject* operator_dispatcher_call_##id(PyObject* left, PyObject* right)                   \
-    {                                                                                           \
-        /* unwrap the arguments from their OperatorDispatcher */                                \
-        PyObject* self;                                                                         \
-        PyObject* other;                                                                        \
-        int reverse = unwrap_args(left, right, self, other);                                    \
-        if (reverse == unwrap_exception_code)                                                   \
-            return 0;                                                                           \
-                                                                                                \
-        /* call the function */                                                                 \
-        PyObject* result =                                                                      \
-           PyEval_CallMethod(self,                                                              \
-                             const_cast<char*>(reverse ? "__r" #id "__" : "__" #id "__"),       \
-                             const_cast<char*>("(O)"),                                          \
-                             other);                                                            \
-        if (result == 0 && PyErr_GivenExceptionMatches(PyErr_Occurred(), PyExc_AttributeError)) \
-        {                                                                                       \
-            PyErr_Clear();                                                                      \
-            PyErr_SetString(PyExc_TypeError, "bad operand type(s) for " #symbol);               \
-        }                                                                                       \
-        return result;                                                                          \
-    }
-
-PY_DEFINE_OPERATOR(add, +)
-PY_DEFINE_OPERATOR(sub, -)
-PY_DEFINE_OPERATOR(mul, *)
-PY_DEFINE_OPERATOR(div, /)
-PY_DEFINE_OPERATOR(mod, %)
-PY_DEFINE_OPERATOR(divmod, divmod)
-PY_DEFINE_OPERATOR(lshift, <<)
-PY_DEFINE_OPERATOR(rshift, >>)
-PY_DEFINE_OPERATOR(and, &)
-PY_DEFINE_OPERATOR(xor, ^)
-PY_DEFINE_OPERATOR(or, |)
-
-/* coercion rules for heterogeneous pow():
-    pow(Foo, int): left, right coerced; m: None => reverse = 0
-    pow(int, Foo): left, right coerced; m: None => reverse = 1
-    pow(Foo, int, int): left, right, m coerced => reverse = 0
-    pow(int, Foo, int): left, right, m coerced => reverse = 1
-    pow(int, int, Foo): left, right, m coerced => reverse = 2
-    pow(Foo, Foo, int): left, right coerced; m coerced twice => reverse = 0
-    pow(Foo, int, Foo): left, right, m coerced => reverse = 0
-    pow(int, Foo, Foo): left, right, m coerced => reverse = 1 
-*/
-PyObject* operator_dispatcher_call_pow(PyObject* left, PyObject* right, PyObject* m)
-{
-    int reverse;
-    PyObject* self;
-    PyObject* first;
-    PyObject* second;
-    
-    if (m->ob_type == Py_None->ob_type)
-    {
-        reverse = unwrap_args(left, right, self, first);
-        second = m; 
-    }
-    else
-    {
-        reverse = unwrap_pow_args(left, right, m, self, first, second);
-    }
-    
-    if (reverse == unwrap_exception_code) 
-        return 0;                         
-                                              
-    // call the function
-    PyObject* result = 
-        PyEval_CallMethod(self,
-                          const_cast<char*>((reverse == 0)
-                                            ? "__pow__"
-                                            : (reverse == 1)
-                                              ? "__rpow__"
-                                              : "__rrpow__"),
-                          const_cast<char*>("(OO)"),
-                          first, second);
-    if (result == 0 && 
-        (PyErr_GivenExceptionMatches(PyErr_Occurred(), PyExc_TypeError) ||
-         PyErr_GivenExceptionMatches(PyErr_Occurred(), PyExc_AttributeError)))
-    {
-        PyErr_Clear();
-        PyErr_SetString(PyExc_TypeError, "bad operand type(s) for pow()");
-    }
-    return result;
-}
-
-int operator_dispatcher_call_cmp(PyObject* left, PyObject* right)
-{
-    // unwrap the arguments from their OperatorDispatcher
-    PyObject* self;
-    PyObject* other;
-    int reverse =  unwrap_args(left, right, self, other);
-    if (reverse == unwrap_exception_code)
-        return -1;
-    
-    // call the function
-    PyObject* result = 
-        PyEval_CallMethod(self,
-                          const_cast<char*>(reverse ? "__rcmp__" : "__cmp__"),
-                          const_cast<char*>("(O)"),
-                          other);
-    if (result == 0)
-    {
-        PyErr_Clear();
-        PyErr_SetString(PyExc_TypeError, "bad operand type(s) for cmp() or <");
-        return -1;
-    }
-    else
-    {
-        try
-        {
-            return BOOST_PYTHON_CONVERSION::from_python(result, type<int>());
-        }
-        catch(...)
-        {
-            PyErr_Clear();
-            PyErr_SetString(PyExc_TypeError, "cmp() didn't return int");
-            return -1;
-        }
-    }
-}
-
-} // extern "C"
-    
-PyTypeObject operator_dispatcher::type_obj = 
-{ 
-    PyObject_HEAD_INIT(&PyType_Type) 
-    0, 
-    const_cast<char*>("operator_dispatcher"), 
-    sizeof(operator_dispatcher), 
-    0, 
-    &operator_dispatcher_dealloc, 
-    0, 
-    0, 
-    0, 
-    &operator_dispatcher_call_cmp, 
-    0, 
-    &operator_dispatcher::number_methods, 
-    0, 
-    0, 
-    0, 
-    0, 
-    0, 
-    0, 
-    0, 
-    0, 
-    0, 
-    0,
-    0,
-    0,
-    0,
-    0
-}; 
-
-PyNumberMethods operator_dispatcher::number_methods = 
-{ 
-    &operator_dispatcher_call_add, 
-    &operator_dispatcher_call_sub, 
-    &operator_dispatcher_call_mul, 
-    &operator_dispatcher_call_div, 
-    &operator_dispatcher_call_mod, 
-    &operator_dispatcher_call_divmod, 
-    &operator_dispatcher_call_pow, 
-    0, 
-    0, 
-    0, 
-    0, 
-    0, 
-    &operator_dispatcher_call_lshift, 
-    &operator_dispatcher_call_rshift, 
-    &operator_dispatcher_call_and, 
-    &operator_dispatcher_call_xor, 
-    &operator_dispatcher_call_or, 
-    &operator_dispatcher_coerce,  
-    0, 
-    0, 
-    0, 
-    0, 
-    0 
-}; 
-
-} // namespace detail
-
-}} // namespace boost::python

src/functions.cpp

@@ -1,179 +0,0 @@
-//  (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)
-
-#include <boost/python/detail/functions.hpp>
-#include <boost/python/detail/types.hpp>
-#include <boost/python/detail/singleton.hpp>
-#include <boost/python/objects.hpp>
-#include <boost/python/errors.hpp>
-
-namespace boost { namespace python { namespace detail {
-
-struct function::type_object :
-        singleton<function::type_object, callable<boost::python::detail::type_object<function> > >
-{
-    type_object() : singleton_base(&PyType_Type) {}
-};
-
-
-void function::add_to_namespace(reference<function> new_function, const char* name, PyObject* dict)
-{
-    dictionary d(ref(dict, ref::increment_count));
-    string key(name);
-    
-    ref existing_object = d.get_item(key.reference());
-    if (existing_object.get() == 0)
-    {
-        d[key] = ref(new_function.get(), ref::increment_count);
-    }
-    else
-    {
-        if (existing_object->ob_type == type_object::instance())
-        {
-            function* f = static_cast<function*>(existing_object.get());
-            while (f->m_overloads.get() != 0)
-                f = f->m_overloads.get();
-            f->m_overloads = new_function;
-        }
-        else
-        {
-            PyErr_SetObject(PyExc_RuntimeError,
-                            (string("Attempt to overload ") + name
-                             + " failed. The existing attribute has type "
-                             + existing_object->ob_type->tp_name).get());
-            throw error_already_set();
-        }
-    }
-}
-
-function::function()
-    : python_object(type_object::instance())
-{
-}
-
-PyObject* function::call(PyObject* args, PyObject* keywords) const
-{
-    // Traverse the linked list of function overloads until we find one that
-    // matches.
-    for (const function* f = this; f != 0; f = f->m_overloads.get())
-    {
-        PyErr_Clear();
-        try
-        {
-            PyObject* const result = f->do_call(args, keywords);
-            if (result != 0)
-                return result;
-        }
-        catch(const argument_error&)
-        {
-        }
-    }
-
-    // If we get here, no overloads matched the arguments
-
-    // Allow the single-function error-reporting to take effect unless there was
-    // an overload
-    if (m_overloads.get() == 0)
-        return 0;
-
-    // Synthesize a more-explicit error message
-    PyErr_Clear();
-    string message("No overloaded functions match (");
-    tuple arguments(ref(args, ref::increment_count));
-    for (std::size_t i = 0; i < arguments.size(); ++i)
-    {
-        if (i != 0)
-            message += ", ";
-        message += arguments[i]->ob_type->tp_name;
-    }
-
-    message += "). Candidates are:\n";
-    for (const function* f1 = this; f1 != 0; f1 = f1->m_overloads.get())
-    {
-        if (f1 != this)
-            message += "\n";
-        message += f1->description();
-    }
-
-    PyErr_SetObject(PyExc_TypeError, message.get());
-    return 0;
-}
-
-// The instance class whose obj represents the type of bound_function
-// objects in Python. bound_functions must be GetAttrable so the __doc__
-// attribute of built-in Python functions can be accessed when bound.
-struct bound_function::type_object :
-    singleton<bound_function::type_object,
-              getattrable<callable<boost::python::detail::type_object<bound_function> > > >
-{
-    type_object() : singleton_base(&PyType_Type) {}
-    
-private: // type_object<bound_function> hook override
-    void dealloc(bound_function*) const;
-};
-
-bound_function* bound_function::create(const ref& target, const ref& fn)
-{
-    bound_function* const result = free_list;
-    if (result == 0)
-        return new bound_function(target, fn);
-    
-    free_list = result->m_free_list_link;
-    result->m_target = target;
-    result->m_unbound_function = fn;
-
-    PyObject* self = result;
-    PyObject_INIT(self, type_object::instance());
-    return result;
-}
-
-bound_function::bound_function(const ref& target, const ref& fn)
-    : python_object(type_object::instance()),
-      m_target(target),
-      m_unbound_function(fn),
-      m_free_list_link(0)
-{
-}
-
-PyObject*
-bound_function::call(PyObject* args, PyObject* keywords) const
-{
-    // Build a new tuple which prepends the target to the arguments
-    tuple tail_arguments(ref(args, ref::increment_count));
-    ref all_arguments(PyTuple_New(tail_arguments.size() + 1));
-
-    PyTuple_SET_ITEM(all_arguments.get(), 0, m_target.get());
-    Py_INCREF(m_target.get());
-    for (std::size_t i = 0; i < tail_arguments.size(); ++i)
-    {
-        PyTuple_SET_ITEM(all_arguments.get(), i + 1, tail_arguments[i].get());
-        Py_INCREF(tail_arguments[i].get());
-    }
-
-    return PyEval_CallObjectWithKeywords(m_unbound_function.get(), all_arguments.get(), keywords);
-}
-
-PyObject* bound_function::getattr(const char* name) const
-{
-    return PyObject_GetAttrString(m_unbound_function.get(), const_cast<char*>(name));
-}
-
-void bound_function::type_object::dealloc(bound_function* obj) const
-{
-    obj->m_free_list_link = free_list;
-    free_list = obj;
-    obj->m_target.reset();
-    obj->m_unbound_function.reset();
-}
-
-bound_function* bound_function::free_list;
-
-}}} // namespace boost::python::detail

src/gen_all.py

@@ -0,0 +1,26 @@
+from gen_callback import *
+from gen_caller import *
+from gen_init_function import *
+from gen_signatures import *
+from gen_singleton import *
+from gen_extclass import *
+
+def gen_all(args):
+    open('callback.hpp', 'w').write(gen_callback(args))
+    open('caller.hpp', 'w').write(gen_caller(args))
+    open('init_function.hpp', 'w').write(gen_init_function(args))
+    open('signatures.hpp', 'w').write(gen_signatures(args))
+    open('singleton.hpp', 'w').write(gen_singleton(args))
+    open('extension_class.hpp', 'w').write(gen_extclass(args))
+
+if __name__ == '__main__':
+    import sys
+
+    if len(sys.argv) == 1:
+        args = 10
+    else:
+        args = int(sys.argv[1])
+
+    print gen_all(args)
+
+    

src/init_function.cpp

@@ -1,36 +0,0 @@
-//  (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.
-
-#include <boost/python/detail/init_function.hpp>
-#include <boost/python/objects.hpp>
-#include <boost/python/detail/extension_class.hpp>
-#include <utility>
-
-namespace boost { namespace python { namespace detail {
-
-  PyObject* init::do_call(PyObject* args_, PyObject* keywords) const
-  {
-      tuple args(ref(args_, ref::increment_count));
-      if (args[0]->ob_type->ob_type != extension_meta_class())
-      {
-          PyErr_SetString(PyExc_TypeError, "argument 1 to __init__ must be an ExtensionInstance");
-          return 0;
-      }
-
-      extension_instance *self = static_cast<extension_instance*>(args[0].get());
-
-      tuple ctor_args = args.slice(1, args.size());
-
-      std::auto_ptr<instance_holder_base> result(
-          create_holder(self, ctor_args.get(), keywords));
-
-      self->add_implementation(result);
-      return none();
-  }
-
-}}} // namespace boost::python::detail

src/module_builder.cpp

@@ -1,62 +0,0 @@
-//  (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.
-
-#include <boost/python/module_builder.hpp>
-
-namespace boost { namespace python {
-
-namespace {
-  ref name_holder;
-}
-
-bool module_builder::initializing()
-{
-    return name_holder.get() != 0;
-}
-
-string module_builder::name()
-{
-    // If this fails, you haven't created a module_builder object
-    assert(initializing());
-    return string(name_holder);
-}
-
-module_builder::module_builder(const char* name)
-    : m_module(Py_InitModule(const_cast<char*>(name), initial_methods))
-{
-    // If this fails, you've created more than 1 module_builder object in your module    
-    assert(name_holder.get() == 0);
-    name_holder = ref(PyObject_GetAttrString(m_module, const_cast<char*>("__name__")));
-}
-
-module_builder::~module_builder()
-{
-    name_holder.reset();
-}
-
-void
-module_builder::add(detail::function* x, const char* name)
-{
-    reference<detail::function> f(x); // First take possession of the object.
-    detail::function::add_to_namespace(f, name, PyModule_GetDict(m_module));
-}
-
-void module_builder::add(ref x, const char* name)
-{
-	PyObject* dictionary = PyModule_GetDict(m_module);
-    PyDict_SetItemString(dictionary, const_cast<char*>(name), x.get());
-}
-
-void module_builder::add(PyTypeObject* x, const char* name /*= 0*/)
-{
-    this->add(ref(as_object(x)), name ? name : x->tp_name);
-}
-
-PyMethodDef module_builder::initial_methods[] = { { 0, 0, 0, 0 } };
-
-}} // namespace boost::python

src/objects.cpp

@@ -1,485 +0,0 @@
-//  (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.
-
-// TODO: Move inline implementations from objects.cpp here
-
-#include <boost/python/objects.hpp>
-#include <boost/python/detail/none.hpp>
-
-namespace boost { namespace python {
-
-template <class T>
-T object_from_python(PyObject* p, type<T>)
-{
-    ref x(p, ref::increment_count);
-    if (!T::accepts(x))
-    {
-        PyErr_SetString(PyExc_TypeError, p->ob_type->tp_name);
-        throw error_already_set();
-    }
-    return T(x);
-}
-
-inline PyObject* object_to_python(const object& x)
-{
-    return x.reference().release();
-}
-
-object::object(ref p)
-    : m_p(p) {}
-    
-// Return a reference to the held object
-ref object::reference() const
-{
-    return m_p;
-}
-
-// Return a raw pointer to the held object
-PyObject* object::get() const
-{
-    return m_p.get();
-}
-
-}} // namespace boost::python
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-PyObject* to_python(const boost::python::tuple& x)
-{
-    return object_to_python(x);
-}
-
-boost::python::tuple from_python(PyObject* p, boost::python::type<boost::python::tuple> type)
-{
-    return boost::python::object_from_python(p, type);
-}
-
-PyObject* to_python(const boost::python::list& x)
-{
-    return object_to_python(x);
-}
-
-boost::python::list from_python(PyObject* p, boost::python::type<boost::python::list> type)
-{
-    return boost::python::object_from_python(p, type);
-}
-
-PyObject* to_python(const boost::python::dictionary& x)
-{
-    return object_to_python(x);
-}
-
-boost::python::dictionary from_python(PyObject* p, boost::python::type<boost::python::dictionary> type)
-{
-    return boost::python::object_from_python(p, type);
-}
-
-PyObject* to_python(const boost::python::string& x)
-{
-    return object_to_python(x);
-}
-
-boost::python::string from_python(PyObject* p, boost::python::type<boost::python::string> type)
-{
-    return boost::python::object_from_python(p, type);
-}
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-namespace boost { namespace python {
-
-tuple::tuple(std::size_t n)
-    : object(ref(PyTuple_New(n)))
-{
-    for (std::size_t i = 0; i < n; ++i)
-        PyTuple_SET_ITEM(get(), i, detail::none());
-}
-    
-tuple::tuple(ref p)
-    : object(p)
-{
-    assert(accepts(p));
-    if (!accepts(p))
-    {
-        PyErr_SetString(PyExc_TypeError, p->ob_type->tp_name);
-        throw error_already_set();
-    }
-}
-
-PyTypeObject* tuple::type_obj()
-{
-    return &PyTuple_Type;
-}
-
-bool tuple::accepts(ref p)
-{
-    return PyTuple_Check(p.get());
-}
-
-std::size_t tuple::size() const
-{
-    return PyTuple_Size(get());
-}
-
-ref tuple::operator[](std::size_t pos) const
-{
-    return ref(PyTuple_GetItem(get(), static_cast<int>(pos)),
-               ref::increment_count);
-}
-
-void tuple::set_item(std::size_t pos, const ref& rhs)
-{
-    int failed = PyTuple_SetItem(
-        get(), static_cast<int>(pos), ref(rhs).release()); // A reference is stolen here.
-    (void)failed;
-    assert(failed == 0);
-}
-
-tuple tuple::slice(int low, int high) const
-{
-    return tuple(ref(PyTuple_GetSlice(get(), low, high)));
-}
-
-tuple& tuple::operator+=(const tuple& rhs)
-{
-    return *this = *this + rhs;
-}
-
-
-// Construct from an owned PyObject*.
-// Precondition: p must point to a python string.
-string::string(ref p)
-    : object(p)
-{
-    assert(accepts(p));
-    if (!accepts(p))
-    {
-        PyErr_SetString(PyExc_TypeError, p->ob_type->tp_name);
-        throw error_already_set();
-    }
-}
-    
-string::string(const char* s)
-    : object(ref(PyString_FromString(s))) {}
-
-string::string(const char* s, std::size_t length)
-    : object(ref(PyString_FromStringAndSize(s, length))) {}
-
-string::string(const char* s, interned_t)
-    : object(ref(PyString_InternFromString(s))) {}
-
-#if 0
-string::string(const char* s, std::size_t length, interned_t)
-    : object(ref(PyString_InternFromStringAndSize(s, length))) {}
-#endif
-
-string::string(const string& rhs)
-    : object(rhs.reference()) {}
-
-// Get the type object for Strings
-PyTypeObject* string::type_obj()
-{ return &PyString_Type; }
-
-// Return true if the given object is a python string
-bool string::accepts(ref o)
-{ return PyString_Check(o.get()); }
-
-// Return the length of the string.
-std::size_t string::size() const
-{
-    int size = PyString_GET_SIZE(get());
-    assert(size >= 0);
-    return static_cast<std::size_t>(size);
-}
-
-// Returns a null-terminated representation of the contents of string.
-// The pointer refers to the internal buffer of string, not a copy.
-// The data must not be modified in any way. It must not be de-allocated. 
-const char* string::c_str() const
-{ return PyString_AS_STRING(get()); }
-
-void string::intern()
-{ // UNTESTED!!
-    *this = string(ref(PyString_InternFromString(c_str()), ref::increment_count));
-}
-
-string& string::operator*=(unsigned int repeat_count)
-{
-    *this = string(ref(PySequence_Repeat(get(), repeat_count)));
-    return *this;
-}
-
-dictionary::dictionary(ref p)
-    : object(p)
-{
-    assert(accepts(p));
-    if (!accepts(p))
-    {
-        PyErr_SetString(PyExc_TypeError, p->ob_type->tp_name);
-        throw error_already_set();
-    }
-}
-
-dictionary::dictionary()
-    : object(ref(PyDict_New())) {}
-
-PyTypeObject* dictionary::type_obj()
-{ return &PyDict_Type; }
-
-bool dictionary::accepts(ref p)
-{ return PyDict_Check(p.get()); }
-
-void dictionary::clear()
-{ PyDict_Clear(get()); }
-
-const ref& dictionary::proxy::operator=(const ref& rhs)
-{
-    if (PyDict_SetItem(m_dict.get(), m_key.get(), rhs.get()) == -1)
-        throw error_already_set();
-    return rhs;
-}
-
-dictionary::proxy::operator ref() const
-{
-    return ref(m_dict->ob_type->tp_as_mapping->mp_subscript(m_dict.get(), m_key.get()),
-               ref::increment_count);
-}
-
-dictionary::proxy::proxy(const ref& dict, const ref& key)
-    : m_dict(dict), m_key(key) {}
-
-dictionary::proxy dictionary::operator[](ref key)
-{ return proxy(reference(), key); }
-    
-ref dictionary::operator[](ref key) const {
-    // An odd MSVC bug causes the ".operator Ptr()" to be needed
-    return proxy(reference(), key).operator ref();
-}
-
-    
-ref dictionary::get_item(const ref& key) const
-{
-    return get_item(key, ref());
-}
-
-ref dictionary::get_item(const ref& key, const ref& default_) const
-{
-    PyObject* value_or_null = PyDict_GetItem(get(), key.get());
-    if (value_or_null == 0 && !PyErr_Occurred())
-        return default_;
-    else
-        return ref(value_or_null, ref::increment_count); // Will throw if there was another error
-}
-        
-void dictionary::set_item(const ref& key, const ref& value)
-{
-    if (PyDict_SetItem(get(), key.get(), value.get()) == -1)
-        throw error_already_set();
-}
-
-void dictionary::erase(ref key) {
-    if (PyDict_DelItem(get(), key.get()) == -1)
-        throw error_already_set();
-}
-
-list dictionary::items() const { return list(ref(PyDict_Items(get()))); }
-list dictionary::keys() const { return list(ref(PyDict_Keys(get()))); }
-list dictionary::values() const { return list(ref(PyDict_Values(get()))); }
-
-std::size_t dictionary::size() const { return static_cast<std::size_t>(PyDict_Size(get())); }
-
-string operator+(string x, string y)
-{
-    PyObject* io_string = x.reference().release();
-    PyString_Concat(&io_string, y.get());
-    return string(ref(io_string));    
-}
-
-string& string::operator+=(const string& rhs)
-{
-    return *this = *this + rhs;
-}
-
-string& string::operator+=(const char* y)
-{
-    return *this += string(y);
-}
-
-string operator%(const string& format, const tuple& args)
-{
-    return string(ref(PyString_Format(format.get(), args.reference().get())));
-}
-
-string operator+(string x, const char* y)
-{
-    return x + string(y);
-}
-
-string operator+(const char* x, string y)
-{
-    return string(x) + y;
-}
-
-tuple operator+(const tuple& x, const tuple& y)
-{
-    tuple result(x.size() + y.size());
-    for (std::size_t xi = 0; xi < x.size(); ++xi)
-        result.set_item(xi, x[xi]);
-    for (std::size_t yi = 0; yi < y.size(); ++yi)
-        result.set_item(yi + x.size(), y[yi]);
-    return result;
-}
-
-
-list::list(ref p)
-    : object(p)
-{
-    assert(accepts(p));
-    if (!accepts(p))
-    {
-        PyErr_SetString(PyExc_TypeError, p->ob_type->tp_name);
-        throw error_already_set();
-    }
-}
-
-list::list(std::size_t sz)
-    : object(ref(PyList_New(sz)))
-{
-}
-
-PyTypeObject* list::type_obj()
-{
-    return &PyList_Type;
-}
-
-bool list::accepts(ref p)
-{
-    return PyList_Check(p.get());
-}
-
-std::size_t list::size() const
-{
-    return PyList_Size(get());
-}
-
-ref list::operator[](std::size_t pos) const
-{
-    return ref(PyList_GetItem(get(), pos), ref::increment_count);
-}
-
-list::proxy list::operator[](std::size_t pos)
-{
-    return proxy(reference(), pos);
-}
-
-void list::insert(std::size_t index, const ref& item)
-{
-    if (PyList_Insert(get(), index, item.get()) == -1)
-        throw error_already_set();
-}
-
-void list::push_back(const ref& item)
-{
-    if (PyList_Append(get(), item.get()) == -1)
-        throw error_already_set();
-}
-
-void list::append(const ref& item)
-{
-    this->push_back(item);
-}
-
-list list::slice(int low, int high) const
-{
-    return list(ref(PyList_GetSlice(get(), low, high)));
-}
-
-list::slice_proxy list::slice(int low, int high)
-{
-    return slice_proxy(reference(), low, high);
-}
-
-void list::sort()
-{
-    if (PyList_Sort(get()) == -1)
-        throw error_already_set();
-}
-
-void list::reverse()
-{
-    if (PyList_Reverse(get()) == -1)
-        throw error_already_set();
-}
-
-tuple list::as_tuple() const
-{
-    return tuple(ref(PyList_AsTuple(get())));
-}
-
-const ref& list::proxy::operator=(const ref& rhs)
-{
-    m_list.set_item(m_index, rhs);
-    return rhs;
-}
-
-list::proxy::operator ref() const
-{
-    return ref(PyList_GetItem(m_list.get(), m_index), ref::increment_count);
-}
-
-ref list::get_item(std::size_t pos) const
-{
-    return ref(PyList_GetItem(this->get(), pos), ref::increment_count);
-}
-
-void list::set_item(std::size_t pos, const ref& rhs)
-{
-    int result = PyList_SetItem(this->get(), pos, rhs.get());
-    if (result == -1)
-        throw error_already_set();
-    Py_INCREF(rhs.get());
-}
-
-list::proxy::proxy(const ref& list, std::size_t index)
-    : m_list(list), m_index(index)
-{
-}
-
-const list& list::slice_proxy::operator=(const list& rhs)
-{
-    if (PyList_SetSlice(m_list.get(), m_low, m_high, rhs.get()) == -1)
-        throw error_already_set();
-    return rhs;
-}
-
-list::slice_proxy::operator ref() const
-{
-    return ref(PyList_GetSlice(m_list.get(), m_low, m_high));
-}
-
-list::slice_proxy::operator list() const
-{
-    return list(this->operator ref());
-}
-
-std::size_t list::slice_proxy::size() const
-{
-    return this->operator list().size();
-}
-
-ref list::slice_proxy::operator[](std::size_t pos) const
-{
-    return this->operator list()[pos].operator ref();
-}
-
-list::slice_proxy::slice_proxy(const ref& list, int low, int high)
-    : m_list(list), m_low(low), m_high(high)
-{
-}
-
-}} // namespace boost::python