boost/python
2
0
Fork 0
mirror of https://github.com/boostorg/python.git synced 2026-01-27 19:12:16 +00:00
Code Issues Projects Releases Wiki Activity

Remove Boost.Python v1 from main trunk

Browse Source 
[SVN r15723]
This commit is contained in:
Dave Abrahams
2002-10-05 04:37:49 +00:00
parent 8207dc756a
commit 30d9331079
106 changed files with 88 additions and 20334 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
Jamfile
View File

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

177
build/Jamfile
View File

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

59
build/como.mak
View File

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

146
build/filemgr.py
View File

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

88
build/gcc.mak
View File

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

184
build/irix_CC.mak
View File

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

184
build/linux_gcc.mak
View File

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

222
build/mingw32.mak
View File

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

199
build/tru64_cxx.mak
View File

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

154
build/vc60.mak
View File

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

149
build/win32_mwcc.mak
View File

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

2
build/win32_mwcc_setup.bat
View File

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

BIN
example/Attic/project.zip
View File

Binary file not shown.

26
example/Jamfile
View File

@@ -22,6 +22,8 @@ subproject libs/python/example ;
SEARCH on python.jam = $(BOOST_BUILD_PATH) ;
include python.jam ;
# ----- getting_started1 -------
# Declare a Python extension called getting_started1
extension getting_started1
: # sources
@@ -32,8 +34,28 @@ extension getting_started1
;
# Declare a test for the extension module
boost-python-runtest my-test
boost-python-runtest test1
: # Python test driver
test_getting_started1.py
# extension modules to use
<pyd>getting_started1 ;
<pyd>getting_started1 ;
# ----- getting_started2 -------
# Declare a Python extension called getting_started2
extension getting_started2
: # sources
getting_started2.cpp
# dependencies
<dll>../build/boost_python
;
# Declare a test for the extension module
boost-python-runtest test2
: # Python test driver
test_getting_started2.py
# extension modules to use
<pyd>getting_started2 ;

19
example/README
View File

@@ -1,21 +1,6 @@
To get started with the Boost Python Library, use the examples
getting_started1.cpp and getting_started2.cpp.
Examples for providing pickle support can be found in:
pickle1.cpp
pickle2.cpp
pickle3.cpp
See also: libs/python/doc/pickle.html
Other advanced concepts are introduced by:
abstract.cpp
simple_vector.cpp
do_it_yourself_convts.cpp
Examples for the cross-module support are provided by:
noncopyable_export.cpp
noncopyable_import.cpp
dvect.cpp
ivect.cpp
See also: libs/python/doc/cross_module.html
bjam -sTOOLS=your-toolset test
in this directory will build and run the examples.

32
example/abstract.cpp
View File

@@ -1,32 +0,0 @@
// Example by Ullrich Koethe
#include "boost/python/class_builder.hpp"
#include <string>
struct Abstract
{
virtual std::string test() = 0;
};
struct Abstract_callback: Abstract
{
Abstract_callback(PyObject * self)
: m_self(self)
{}
std::string test()
{
return boost::python::callback<std::string>::call_method(m_self, "test");
}
PyObject * m_self;
};
BOOST_PYTHON_MODULE_INIT(abstract)
{
boost::python::module_builder a("abstract");
boost::python::class_builder<Abstract, Abstract_callback>
a_class(a, "Abstract");
a_class.def(boost::python::constructor<>()); // wrap a constructor
a_class.def(&Abstract::test, "test");
}

121
example/do_it_yourself_convts.cpp
View File

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

48
example/dvect.cpp
View File

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

32
example/dvect.h
View File

@@ -1,32 +0,0 @@
#ifndef DVECT_H
#define DVECT_H
#include <vector>
#include <boost/python/class_builder.hpp>
namespace vects {
struct dvect : public std::vector<double>
{
dvect() : std::vector<double>() {}
dvect(std::size_t n) : std::vector<double>(n) {}
dvect(boost::python::tuple tuple) : std::vector<double>(tuple.size())
{
std::vector<double>::iterator v_it = begin();
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

51
example/dvect_conversions.cpp
View File

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

13
example/dvect_defs.cpp
View File

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

17
example/getting_started1.cpp
View File

@@ -9,22 +9,15 @@ namespace { // Avoid cluttering the global namespace.
int square(int number) { return number * number; }
}
#include <boost/python/class_builder.hpp>
#include <boost/python/module.hpp>
#include <boost/python/def.hpp>
namespace python = boost::python;
// Python requires an exported function called init<module-name> in every
// extension module. This is where we build the module contents.
BOOST_PYTHON_MODULE_INIT(getting_started1)
BOOST_PYTHON_MODULE(getting_started1)
{
try {
// Create an object representing this extension module.
python::module_builder this_module("getting_started1");
// Add regular functions to the module.
this_module.def(greet, "greet");
this_module.def(square, "square");
}
catch(...) {
boost::python::handle_exception();
}
python::def("greet", greet);
python::def("square", square);
}

33
example/getting_started2.cpp
View File

@@ -21,25 +21,20 @@ namespace { // Avoid cluttering the global namespace.
}
}
#include <boost/python/class_builder.hpp>
namespace python = boost::python;
#include <boost/python/class.hpp>
#include <boost/python/module.hpp>
#include <boost/python/def.hpp>
BOOST_PYTHON_MODULE_INIT(getting_started2)
BOOST_PYTHON_MODULE(getting_started2)
{
// Create an object representing this extension module.
python::module_builder this_module("getting_started2");
// Create the Python type object for our extension class.
python::class_builder<hello> hello_class(this_module, "hello");
// Add the __init__ function.
hello_class.def(python::constructor<std::string>());
// Add a regular member function.
hello_class.def(&hello::greet, "greet");
// Add invite() as a regular function to the module.
this_module.def(invite, "invite");
// Even better, invite() can also be made a member of hello_class!!!
hello_class.def(invite, "invite");
using namespace boost::python;
class_<hello>("hello", init<std::string>())
// Add a regular member function.
.def("greet", &hello::greet)
// Add invite() as a member of hello!
.def("invite", invite)
;
// Also add invite() as a regular function to the module.
def("invite", invite);
}

49
example/ivect.cpp
View File

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

32
example/ivect.h
View File

@@ -1,32 +0,0 @@
#ifndef IVECT_H
#define IVECT_H
#include <vector>
#include <boost/python/class_builder.hpp>
namespace vects {
struct ivect : public std::vector<int>
{
ivect() : std::vector<int>() {}
ivect(std::size_t n) : std::vector<int>(n) {}
ivect(boost::python::tuple tuple) : std::vector<int>(tuple.size())
{
std::vector<int>::iterator v_it = begin();
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

51
example/ivect_conversions.cpp
View File

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

13
example/ivect_defs.cpp
View File

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

37
example/nested.cpp
View File

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

14
example/noncopyable.h
View File

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

28
example/noncopyable_export.cpp
View File

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

45
example/noncopyable_import.cpp
View File

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

57
example/pickle1.cpp
View File

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

93
example/pickle2.cpp
View File

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

143
example/pickle3.cpp
View File

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

BIN
example/project.zip
View File

Binary file not shown.

84
example/richcmp1.cpp
View File

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

62
example/richcmp2.cpp
View File

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

175
example/richcmp3.cpp
View File

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

104
example/simple_vector.cpp
View File

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

24
example/test_abstract.py
View File

@@ -1,24 +0,0 @@
# Example by Ullrich Koethe
r'''>>> from abstract import *
>>> class A(Abstract):
... def __init__(self, text):
... Abstract.__init__(self) # call the base class constructor
... self.text = text
... def test(self): # implement abstract function
... return self.text
...
>>> a = A("Hello")
>>> a.test()
'Hello'
'''
def run(args = None):
if args is not None:
import sys
sys.argv = args
import doctest, test_abstract
return doctest.testmod(test_abstract)
if __name__ == '__main__':
import sys
sys.exit(run()[0])

140
example/test_cross_module.py
View File

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

23
example/test_do_it_yourself_convts.py
View File

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

51
example/test_example1.py
View File

@@ -1,51 +0,0 @@
r'''
// (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.
That's it! If we build this shared library and put it on our PYTHONPATH we can
now access our C++ class and function from Python.
>>> import hello
>>> hi_world = hello.world(3)
>>> hi_world.get()
'hi, world'
>>> hello.length(hi_world)
9
We can even make a subclass of hello.world:
>>> class my_subclass(hello.world):
... def get(self):
... return 'hello, world'
...
>>> y = my_subclass(2)
>>> y.get()
'hello, world'
Pretty cool! You can't do that with an ordinary Python extension type!
>>> hello.length(y)
9
Of course, you may now have a slightly empty feeling in the pit of your little
pythonic stomach. Perhaps you feel your subclass deserves to have a length() of
12? If so, read on...
'''
from hello import *
def run(args = None):
if args is not None:
import sys
sys.argv = args
import doctest, test_example1
return doctest.testmod(test_example1)
if __name__ == '__main__':
import sys
sys.exit(run()[0])

18
example/test_getting_started1.py
View File

@@ -1,18 +0,0 @@
r'''>>> import getting_started1
>>> print getting_started1.greet()
hello, world
>>> number = 11
>>> print number, '*', number, '=', getting_started1.square(number)
11 * 11 = 121
'''
def run(args = None):
if args is not None:
import sys
sys.argv = args
import doctest, test_getting_started1
return doctest.testmod(test_getting_started1)
if __name__ == '__main__':
import sys
sys.exit(run()[0])

31
example/test_getting_started2.py
View File

@@ -1,31 +0,0 @@
r'''>>> from getting_started2 import *
>>> hi = hello('California')
>>> hi.greet()
'Hello from California'
>>> invite(hi)
'Hello from California! Please come soon!'
>>> hi.invite()
'Hello from California! Please come soon!'
>>> class wordy(hello):
... def greet(self):
... return hello.greet(self) + ', where the weather is fine'
...
>>> hi2 = wordy('Florida')
>>> hi2.greet()
'Hello from Florida, where the weather is fine'
>>> invite(hi2)
'Hello from Florida! Please come soon!'
'''
def run(args = None):
if args is not None:
import sys
sys.argv = args
import doctest, test_getting_started2
return doctest.testmod(test_getting_started2)
if __name__ == '__main__':
import sys
sys.exit(run()[0])

23
example/test_nested.py
View File

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

33
example/test_pickle1.py
View File

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

47
example/test_pickle2.py
View File

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

39
example/test_pickle3.py
View File

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

40
example/test_richcmp1.py
View File

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

41
example/test_richcmp2.py
View File

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

77
example/test_richcmp3.py
View File

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

19
example/test_rwgk1.py
View File

@@ -1,19 +0,0 @@
r'''>>> import rwgk1
>>> print rwgk1.greet()
hello, world
>>> number = 11
>>> print number, '*', number, '=', rwgk1.square(number)
11 * 11 = 121
'''
def run(args = None):
if args is not None:
import sys
sys.argv = args
import doctest, test_rwgk1
return doctest.testmod(test_rwgk1)
if __name__ == '__main__':
import sys
sys.exit(run()[0])

42
example/test_simple_vector.py
View File

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

20
example/tst_dvect1.py
View File

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

104
example/tst_dvect2.py
View File

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

20
example/tst_ivect1.py
View File

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

104
example/tst_ivect2.py
View File

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

16
example/tst_noncopyable.py
View File

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

117
example/vector_wrapper.h
View File

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

829
include/boost/python/callback.hpp
View File

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

1279
include/boost/python/caller.hpp
View File

File diff suppressed because it is too large Load Diff

182
include/boost/python/class_builder.hpp
View File

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

677
include/boost/python/classes.hpp
View File

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

415
include/boost/python/conversions.hpp
View File

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

329
include/boost/python/cross_module.hpp
View File

@@ -1,329 +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)
*/
/* Implementation of Boost.Python cross-module support.
See root/libs/python/doc/cross_module.html for details.
*/
#ifndef CROSS_MODULE_HPP
# define CROSS_MODULE_HPP
# include <boost/python/class_builder.hpp>
namespace boost { namespace python {
struct BOOST_PYTHON_DECL import_error: error_already_set {};
struct BOOST_PYTHON_DECL export_error : error_already_set {};
void BOOST_PYTHON_DECL throw_import_error();
void BOOST_PYTHON_DECL throw_export_error();
namespace detail
{
// Concept: throw exception if api_major is changed
// show warning on stderr if api_minor is changed
const int export_converters_api_major = 4;
const int export_converters_api_minor = 1;
extern BOOST_PYTHON_DECL const char* converters_attribute_name;
BOOST_PYTHON_DECL void* import_converter_object(const std::string& module_name,
const std::string& py_class_name,
const std::string& attribute_name);
BOOST_PYTHON_DECL void check_export_converters_api(const int importing_major,
const int importing_minor,
const int imported_major,
const int imported_minor);
}
}} // namespace boost::python
// forward declaration
namespace boost { namespace python { namespace detail {
template <class T> class import_extension_class;
}}}
BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
/* This class template is instantiated by import_converters<T>.
This class is a look-alike of class python_extension_class_converters.
The converters in this class are wrappers that call converters
imported from another module.
To ensure that the dynamic loader resolves all symbols in the
intended way, the signature of all friend functions is changed with
respect to the original functions in class
python_extension_class_converters by adding an arbitrary additional
parameter with a default value, in this case "bool sig = false".
See also: comments for class export_converter_object_base below.
*/
template <class T>
class python_import_extension_class_converters
{
public:
friend python_import_extension_class_converters py_extension_class_converters(boost::python::type<T>, bool sig = false) {
return python_import_extension_class_converters();
}
PyObject* to_python(const T& x) const {
return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
}
friend T* from_python(PyObject* p, boost::python::type<T*> t, bool sig = false) {
return boost::python::detail::import_extension_class<T>::get_converters()->from_python_Ts(p, t);
}
friend const T* from_python(PyObject* p, boost::python::type<const T*> t, bool sig = false) {
return boost::python::detail::import_extension_class<T>::get_converters()->from_python_cTs(p, t);
}
friend const T* from_python(PyObject* p, boost::python::type<const T*const&> t, bool sig = false) {
return boost::python::detail::import_extension_class<T>::get_converters()->from_python_cTscr(p, t);
}
friend T* from_python(PyObject* p, boost::python::type<T* const&> t, bool sig = false) {
return boost::python::detail::import_extension_class<T>::get_converters()->from_python_Tscr(p, t);
}
friend T& from_python(PyObject* p, boost::python::type<T&> t, bool sig = false) {
return boost::python::detail::import_extension_class<T>::get_converters()->from_python_Tr(p, t);
}
friend const T& from_python(PyObject* p, boost::python::type<const T&> t, bool sig = false) {
return boost::python::detail::import_extension_class<T>::get_converters()->from_python_cTr(p, t);
}
friend const T& from_python(PyObject* p, boost::python::type<T> t, bool sig = false) {
return boost::python::detail::import_extension_class<T>::get_converters()->from_python_T(p, t);
}
friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T>&> t, bool sig = false) {
return boost::python::detail::import_extension_class<T>::get_converters()->from_python_aTr(p, t);
}
friend std::auto_ptr<T> from_python(PyObject* p, boost::python::type<std::auto_ptr<T> > t, bool sig = false) {
return boost::python::detail::import_extension_class<T>::get_converters()->from_python_aT(p, t);
}
friend const std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<const std::auto_ptr<T>&> t, bool sig = false) {
return boost::python::detail::import_extension_class<T>::get_converters()->from_python_caTr(p, t);
}
friend PyObject* to_python(std::auto_ptr<T> x, bool sig = false) {
return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
}
friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T>&> t, bool sig = false) {
return boost::python::detail::import_extension_class<T>::get_converters()->from_python_sTr(p, t);
}
friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T> > t, bool sig = false) {
return boost::python::detail::import_extension_class<T>::get_converters()->from_python_sT(p, t);
}
friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<const boost::shared_ptr<T>&> t, bool sig = false) {
return boost::python::detail::import_extension_class<T>::get_converters()->from_python_csTr(p, t);
}
friend PyObject* to_python(boost::shared_ptr<T> x, bool sig = false) {
return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
}
};
BOOST_PYTHON_END_CONVERSION_NAMESPACE
namespace boost { namespace python {
BOOST_PYTHON_IMPORT_CONVERSION(python_import_extension_class_converters);
/* This class template is instantiated by export_converters().
A pointer to this class is exported/imported via the Python API.
Using the Python API ensures maximum portability.
All member functions are virtual. This is, what we export/import
is essentially just a pointer to a vtbl.
To work around a deficiency of Visual C++ 6.0, the name of each
from_python() member functions is made unique by appending a few
characters (derived in a ad-hoc manner from the corresponding type).
*/
template <class T>
struct export_converter_object_base
{
virtual int get_api_major() const { return detail::export_converters_api_major; }
virtual int get_api_minor() const { return detail::export_converters_api_minor; }
virtual PyObject* to_python(const T& x) = 0;
virtual T* from_python_Ts(PyObject* p, boost::python::type<T*> t) = 0;
virtual const T* from_python_cTs(PyObject* p, boost::python::type<const T*> t) = 0;
virtual const T* from_python_cTscr(PyObject* p, boost::python::type<const T*const&> t) = 0;
virtual T* from_python_Tscr(PyObject* p, boost::python::type<T* const&> t) = 0;
virtual T& from_python_Tr(PyObject* p, boost::python::type<T&> t) = 0;
virtual const T& from_python_cTr(PyObject* p, boost::python::type<const T&> t) = 0;
virtual const T& from_python_T(PyObject* p, boost::python::type<T> t) = 0;
virtual std::auto_ptr<T>& from_python_aTr(PyObject* p, boost::python::type<std::auto_ptr<T>&> t) = 0;
virtual std::auto_ptr<T> from_python_aT(PyObject* p, boost::python::type<std::auto_ptr<T> > t) = 0;
virtual const std::auto_ptr<T>& from_python_caTr(PyObject* p, boost::python::type<const std::auto_ptr<T>&> t) = 0;
virtual PyObject* to_python(std::auto_ptr<T> x) = 0;
virtual boost::shared_ptr<T>& from_python_sTr(PyObject* p, boost::python::type<boost::shared_ptr<T>&> t) = 0;
virtual const boost::shared_ptr<T>& from_python_sT(PyObject* p, boost::python::type<boost::shared_ptr<T> > t) = 0;
virtual const boost::shared_ptr<T>& from_python_csTr(PyObject* p, boost::python::type<const boost::shared_ptr<T>&> t) = 0;
virtual PyObject* to_python(boost::shared_ptr<T> x) = 0;
};
// Converters to be used if T is not copyable.
template <class T>
struct export_converter_object_noncopyable : export_converter_object_base<T>
{
virtual PyObject* to_python(const T& x) {
PyErr_SetString(PyExc_RuntimeError,
"to_python(const T&) converter not exported");
throw_import_error();
return 0;
}
virtual T* from_python_Ts(PyObject* p, boost::python::type<T*> t) {
return BOOST_PYTHON_CONVERSION::from_python(p, t);
}
virtual const T* from_python_cTs(PyObject* p, boost::python::type<const T*> t) {
return BOOST_PYTHON_CONVERSION::from_python(p, t);
}
virtual const T* from_python_cTscr(PyObject* p, boost::python::type<const T*const&> t) {
return BOOST_PYTHON_CONVERSION::from_python(p, t);
}
virtual T* from_python_Tscr(PyObject* p, boost::python::type<T* const&> t) {
return BOOST_PYTHON_CONVERSION::from_python(p, t);
}
virtual T& from_python_Tr(PyObject* p, boost::python::type<T&> t) {
return BOOST_PYTHON_CONVERSION::from_python(p, t);
}
virtual const T& from_python_cTr(PyObject* p, boost::python::type<const T&> t) {
return BOOST_PYTHON_CONVERSION::from_python(p, t);
}
virtual const T& from_python_T(PyObject* p, boost::python::type<T> t) {
return BOOST_PYTHON_CONVERSION::from_python(p, t);
}
virtual std::auto_ptr<T>& from_python_aTr(PyObject* p, boost::python::type<std::auto_ptr<T>&> t) {
return BOOST_PYTHON_CONVERSION::from_python(p, t);
}
virtual std::auto_ptr<T> from_python_aT(PyObject* p, boost::python::type<std::auto_ptr<T> > t) {
return BOOST_PYTHON_CONVERSION::from_python(p, t);
}
virtual const std::auto_ptr<T>& from_python_caTr(PyObject* p, boost::python::type<const std::auto_ptr<T>&> t) {
return BOOST_PYTHON_CONVERSION::from_python(p, t);
}
virtual PyObject* to_python(std::auto_ptr<T> x) {
return BOOST_PYTHON_CONVERSION::to_python(x);
}
virtual boost::shared_ptr<T>& from_python_sTr(PyObject* p, boost::python::type<boost::shared_ptr<T>&> t) {
return BOOST_PYTHON_CONVERSION::from_python(p, t);
}
virtual const boost::shared_ptr<T>& from_python_sT(PyObject* p, boost::python::type<boost::shared_ptr<T> > t) {
return BOOST_PYTHON_CONVERSION::from_python(p, t);
}
virtual const boost::shared_ptr<T>& from_python_csTr(PyObject* p, boost::python::type<const boost::shared_ptr<T>&> t) {
return BOOST_PYTHON_CONVERSION::from_python(p, t);
}
virtual PyObject* to_python(boost::shared_ptr<T> x) {
return BOOST_PYTHON_CONVERSION::to_python(x);
}
};
// The addditional to_python() converter that can be used if T is copyable.
template <class T>
struct export_converter_object : export_converter_object_noncopyable<T>
{
virtual PyObject* to_python(const T& x) {
return BOOST_PYTHON_CONVERSION::py_extension_class_converters(boost::python::type<T>()).to_python(x);
}
};
namespace detail
{
/* This class template is instantiated by import_converters<T>.
Its purpose is to import the converter_object via the Python API.
The actual import is only done once. The pointer to the
imported converter object is kept in the static data member
imported_converters.
*/
template <class T>
class import_extension_class
: public python_import_extension_class_converters<T>
{
public:
inline import_extension_class(const char* module, const char* py_class) {
m_module = module;
m_py_class = py_class;
}
static boost::python::export_converter_object_base<T>* get_converters();
private:
static std::string m_module;
static std::string m_py_class;
static boost::python::export_converter_object_base<T>* imported_converters;
};
template <class T> std::string import_extension_class<T>::m_module;
template <class T> std::string import_extension_class<T>::m_py_class;
template <class T>
boost::python::export_converter_object_base<T>*
import_extension_class<T>::imported_converters = 0;
template <class T>
boost::python::export_converter_object_base<T>*
import_extension_class<T>::get_converters() {
if (imported_converters == 0) {
void* cobject
= import_converter_object(m_module, m_py_class,
converters_attribute_name);
imported_converters
= static_cast<boost::python::export_converter_object_base<T>*>(cobject);
check_export_converters_api(
export_converters_api_major,
export_converters_api_minor,
imported_converters->get_api_major(),
imported_converters->get_api_minor());
}
return imported_converters;
}
}}} // namespace boost::python::detail
namespace boost { namespace python {
// Implementation of export_converters().
template <class T, class U>
void export_converters(class_builder<T, U>& cb)
{
static export_converter_object<T> export_cvts;
cb.add(
ref(PyCObject_FromVoidPtr(reinterpret_cast<void*>(&export_cvts), NULL)),
detail::converters_attribute_name);
}
// Implementation of export_converters_noncopyable().
template <class T, class U>
void export_converters_noncopyable(class_builder<T, U>& cb)
{
static export_converter_object_noncopyable<T> export_cvts;
cb.add(
ref(PyCObject_FromVoidPtr(reinterpret_cast<void*>(&export_cvts), NULL)),
detail::converters_attribute_name);
}
// Implementation of import_converters<T>.
template <class T>
class import_converters
: python_import_extension_class_converters<T> // Works around MSVC6.x/GCC2.95.2 bug described
// at the bottom of class_builder.hpp.
{
public:
import_converters(const char* module, const char* py_class)
: m_class(new detail::import_extension_class<T>(module, py_class))
{ }
private:
boost::shared_ptr<detail::import_extension_class<T> > m_class;
};
}} // namespace boost::python
#endif // CROSS_MODULE_HPP

60
include/boost/python/detail/base_object.hpp
View File

@@ -1,60 +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/wrap_python.hpp>
# include <cstring>
namespace boost { namespace python { namespace detail {
// base_object - adds a constructor and non-virtual destructor to a
// base Python type (e.g. PyObject, PyTypeObject).
template <class PythonType>
struct base_object : PythonType
{
typedef PythonType base_python_type;
// Initializes type and reference count. All other fields of base_python_type are 0
base_object(PyTypeObject* type_obj);
// Decrements reference count on the type
~base_object();
};
// Easy typedefs for common usage
typedef base_object<PyObject> python_object;
typedef base_object<PyTypeObject> python_type;
//
// base_object member function implementations
//
template <class PythonType>
base_object<PythonType>::base_object(PyTypeObject* type_obj)
{
base_python_type* bp = this;
BOOST_CSTD_::memset(bp, 0, sizeof(base_python_type));
Py_INCREF(type_obj);
PyObject_INIT(bp, type_obj);
}
template <class PythonType>
inline base_object<PythonType>::~base_object()
{
Py_DECREF(ob_type);
}
}}} // namespace boost::python::detail
#endif // BASE_OBJECT_DWA051600_H_

81
include/boost/python/detail/cast.hpp
View File

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

1002
include/boost/python/detail/extension_class.hpp
View File

File diff suppressed because it is too large Load Diff

311
include/boost/python/detail/functions.hpp
View File

@@ -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 BOOST_PYTHON_DECL 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 BOOST_PYTHON_DECL 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_

562
include/boost/python/detail/init_function.hpp
View File

@@ -1,562 +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.
//
// 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;
};
struct reference_parameter_base {};
template <class T>
class reference_parameter
: public reference_parameter_base
{
public:
typedef typename parameter_traits<T>::const_reference const_reference;
reference_parameter(const_reference value)
: value(value) {}
operator const_reference() { return value; }
private:
const_reference value;
};
# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template <class T>
struct unwrap_parameter
{
typedef typename boost::add_reference<T>::type type;
};
template <class T>
struct unwrap_parameter<reference_parameter<T> >
{
typedef typename reference_parameter<T>::const_reference type;
};
# else
template <bool is_wrapped>
struct unwrap_parameter_helper
{
template <class T>
struct apply
{
typedef typename T::const_reference type;
};
};
template <>
struct unwrap_parameter_helper<false>
{
template <class T>
struct apply
{
typedef typename add_reference<T>::type type;
};
};
template <class T>
struct unwrap_parameter
{
BOOST_STATIC_CONSTANT(
bool, is_wrapped = (is_base_and_derived<T,reference_parameter_base>::value));
typedef typename unwrap_parameter_helper<
is_wrapped
>::template apply<T>::type type;
};
# endif
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
{
# ifdef BOOST_MSVC6_OR_EARLIER
# define typename
# endif
static init* create(signature0) {
return new init0<T>;
}
template <class A1>
static init* create(signature1<A1>) {
return new init1<T,
typename detail::parameter_traits<A1>::const_reference>;
}
template <class A1, class A2>
static init* create(signature2<A1, A2>) {
return new init2<T,
typename detail::parameter_traits<A1>::const_reference,
typename detail::parameter_traits<A2>::const_reference>;
}
template <class A1, class A2, class A3>
static init* create(signature3<A1, A2, A3>) {
return new init3<T,
typename detail::parameter_traits<A1>::const_reference,
typename detail::parameter_traits<A2>::const_reference,
typename 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,
typename detail::parameter_traits<A1>::const_reference,
typename detail::parameter_traits<A2>::const_reference,
typename detail::parameter_traits<A3>::const_reference,
typename 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,
typename detail::parameter_traits<A1>::const_reference,
typename detail::parameter_traits<A2>::const_reference,
typename detail::parameter_traits<A3>::const_reference,
typename detail::parameter_traits<A4>::const_reference,
typename 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,
typename detail::parameter_traits<A1>::const_reference,
typename detail::parameter_traits<A2>::const_reference,
typename detail::parameter_traits<A3>::const_reference,
typename detail::parameter_traits<A4>::const_reference,
typename detail::parameter_traits<A5>::const_reference,
typename 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,
typename detail::parameter_traits<A1>::const_reference,
typename detail::parameter_traits<A2>::const_reference,
typename detail::parameter_traits<A3>::const_reference,
typename detail::parameter_traits<A4>::const_reference,
typename detail::parameter_traits<A5>::const_reference,
typename detail::parameter_traits<A6>::const_reference,
typename 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,
typename detail::parameter_traits<A1>::const_reference,
typename detail::parameter_traits<A2>::const_reference,
typename detail::parameter_traits<A3>::const_reference,
typename detail::parameter_traits<A4>::const_reference,
typename detail::parameter_traits<A5>::const_reference,
typename detail::parameter_traits<A6>::const_reference,
typename detail::parameter_traits<A7>::const_reference,
typename 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,
typename detail::parameter_traits<A1>::const_reference,
typename detail::parameter_traits<A2>::const_reference,
typename detail::parameter_traits<A3>::const_reference,
typename detail::parameter_traits<A4>::const_reference,
typename detail::parameter_traits<A5>::const_reference,
typename detail::parameter_traits<A6>::const_reference,
typename detail::parameter_traits<A7>::const_reference,
typename detail::parameter_traits<A8>::const_reference,
typename 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,
typename detail::parameter_traits<A1>::const_reference,
typename detail::parameter_traits<A2>::const_reference,
typename detail::parameter_traits<A3>::const_reference,
typename detail::parameter_traits<A4>::const_reference,
typename detail::parameter_traits<A5>::const_reference,
typename detail::parameter_traits<A6>::const_reference,
typename detail::parameter_traits<A7>::const_reference,
typename detail::parameter_traits<A8>::const_reference,
typename detail::parameter_traits<A9>::const_reference,
typename detail::parameter_traits<A10>::const_reference>;
}
#ifdef BOOST_MSVC6_OR_EARLIER
# undef typename
#endif
};
class BOOST_PYTHON_DECL 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_

1
include/boost/python/detail/module_base.hpp
View File

@@ -1,3 +1,4 @@
#error obsolete
// 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

51
include/boost/python/detail/module_info.hpp
View File

@@ -1,51 +0,0 @@
// Copyright David Hawkes 2002.
// Permission is hereby granted to copy, use and modify this software
// for any purpose, including commercial distribution, provided this
// copyright notice is not removed. No warranty WHATSOEVER is provided with this
// software. Any user(s) accepts this software "as is" and as such they will not
// bind the author(s) to any claim of suitabilty for any purpose.
#ifndef MODULE_INFO
# define MODULE_INFO
#include <boost/python/object.hpp>
namespace boost { namespace python { namespace detail {
class module_info
{
public:
module_info(const char *name)
{
m_module_name = name;
}
void set_module(object const& m)
{
if(!m_primary_module)
m_primary_module = m;
}
object const& get_module() const
{
return m_primary_module;
}
void set_prior_module(object const& m)
{
m_prior_module = m;
}
object const& get_prior_module() const
{
return m_prior_module;
}
const char* get_module_name() const
{
return m_module_name;
}
private:
object m_primary_module;
object m_prior_module;
const char* m_module_name;
};
}}}
#endif // MODULE_INFO

251
include/boost/python/detail/signatures.hpp
View File

@@ -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 BOOST_PYTHON_DECL 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

68
include/boost/python/detail/singleton.hpp
View File

@@ -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 BOOST_PYTHON_DECL 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

413
include/boost/python/detail/types.hpp
View File

@@ -1,413 +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 {
namespace detail {
class BOOST_PYTHON_DECL 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 BOOST_PYTHON_DECL 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;
};
BOOST_PYTHON_DECL 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_

39
include/boost/python/detail/void_adaptor.hpp
View File

@@ -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 BOOST_PYTHON_DECL 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

76
include/boost/python/module_builder.hpp
View File

@@ -1,76 +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 MODULE_DWA051000_H_
# define MODULE_DWA051000_H_
# include <boost/python/detail/config.hpp>
# include <boost/python/reference.hpp>
# include <boost/python/objects.hpp>
# include <boost/python/detail/functions.hpp>
# include <boost/python/detail/module_init.hpp>
namespace boost { namespace python {
class BOOST_PYTHON_DECL module_builder_base
{
public:
// Create a module. REQUIRES: only one module_builder is created per module.
module_builder_base(const char* name);
~module_builder_base();
// Add elements to the module
void add(detail::function* x, const char* name);
void add(PyTypeObject* x, const char* name = 0);
void add(ref x, const char*name);
// Return true iff a module is currently being built.
static bool initializing();
// Return the name of the module currently being built.
// REQUIRES: initializing() == true
static string name();
// Return a pointer to the Python module object being built
PyObject* module() const;
private:
PyObject* m_module;
static PyMethodDef initial_methods[1];
};
class module_builder : public module_builder_base
{
public:
module_builder(const char* name)
: module_builder_base(name) {}
template <class Fn>
void def_raw(Fn fn, const char* name)
{
add(detail::new_raw_arguments_function(fn), name);
}
template <class Fn>
void def(Fn fn, const char* name)
{
add(detail::new_wrapped_function(fn), name);
}
};
//
// inline implementations
//
inline PyObject* module_builder_base::module() const
{
return m_module;
}
}} // namespace boost::python
#endif

396
include/boost/python/objects.hpp
View File

@@ -1,396 +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 OBJECTS_DWA051100_H_
# define OBJECTS_DWA051100_H_
# ifdef BOOST_PYTHON_V2
# error obsolete
# else
# include <boost/python/detail/wrap_python.hpp>
# include <boost/python/detail/config.hpp>
# include <boost/python/reference.hpp>
# include "boost/operators.hpp"
# include <utility>
namespace boost { namespace python {
class BOOST_PYTHON_DECL object
{
public:
explicit object(ref p);
// Return a reference to the held object
ref reference() const;
// Return a raw pointer to the held object
PyObject* get() const;
private:
ref m_p;
};
class tuple;
class BOOST_PYTHON_DECL tuple_base : public object
{
public:
explicit tuple_base(std::size_t n = 0);
explicit tuple_base(ref p);
static PyTypeObject* type_obj();
static bool accepts(ref p);
std::size_t size() const;
ref operator[](std::size_t pos) const;
void set_item(std::size_t pos, const ref& rhs);
tuple slice(int low, int high) const;
friend BOOST_PYTHON_DECL tuple operator+(const tuple&, const tuple&);
friend BOOST_PYTHON_DECL tuple& operator+=(tuple&, const tuple&);
};
class tuple : public tuple_base
{
public:
explicit tuple(std::size_t n = 0) : tuple_base(n) {}
explicit tuple(ref p) : tuple_base(p) {}
template <class First, class Second>
tuple(const std::pair<First,Second>& x)
: tuple_base(ref(PyTuple_New(2)))
{
set_item(0, x.first);
set_item(1, x.second);
}
template <class First, class Second>
tuple(const First& first, const Second& second)
: tuple_base(ref(PyTuple_New(2)))
{
set_item(0, first);
set_item(1, second);
}
template <class First, class Second, class Third>
tuple(const First& first, const Second& second, const Third& third)
: tuple_base(ref(PyTuple_New(3)))
{
set_item(0, first);
set_item(1, second);
set_item(2, third);
}
template <class First, class Second, class Third, class Fourth>
tuple(const First& first, const Second& second, const Third& third, const Fourth& fourth)
: tuple_base(ref(PyTuple_New(4)))
{
set_item(0, first);
set_item(1, second);
set_item(2, third);
set_item(3, fourth);
}
template <class T>
void set_item(std::size_t pos, const T& rhs)
{
this->set_item(pos, make_ref(rhs));
}
void set_item(std::size_t pos, const ref& rhs)
{
tuple_base::set_item(pos, rhs);
}
};
class list;
struct BOOST_PYTHON_DECL list_proxy;
struct BOOST_PYTHON_DECL list_slice_proxy;
class BOOST_PYTHON_DECL list_base : public object
{
protected:
typedef list_proxy proxy;
typedef list_slice_proxy slice_proxy;
public:
explicit list_base(ref p);
explicit list_base(std::size_t sz = 0);
static PyTypeObject* type_obj();
static bool accepts(ref p);
std::size_t size() const;
ref operator[](std::size_t pos) const;
proxy operator[](std::size_t pos);
ref get_item(std::size_t pos) const;
void set_item(std::size_t pos, const ref& );
// void set_item(std::size_t pos, const object& );
void insert(std::size_t index, const ref& item);
void push_back(const ref& item);
void append(const ref& item);
list slice(int low, int high) const;
slice_proxy slice(int low, int high);
void sort();
void reverse();
tuple as_tuple() const;
};
class list : public list_base
{
public:
explicit list(ref p) : list_base(p) {}
explicit list(std::size_t sz = 0) : list_base(sz) {}
template <class T>
void set_item(std::size_t pos, const T& x)
{ this->set_item(pos, make_ref(x)); }
template <class T>
void insert(std::size_t index, const T& x)
{ this->insert(index, make_ref(x)); }
template <class T>
void push_back(const T& item)
{ this->push_back(make_ref(item)); }
template <class T>
void append(const T& item)
{ this->append(make_ref(item)); }
void set_item(std::size_t pos, const ref& x) { list_base::set_item(pos, x); }
void insert(std::size_t index, const ref& item) { list_base::insert(index, item); }
void push_back(const ref& item) { list_base::push_back(item); }
void append(const ref& item) { list_base::append(item); }
};
class BOOST_PYTHON_DECL string
: public object, public boost::multipliable2<string, unsigned int>
{
public:
// Construct from an owned PyObject*.
// Precondition: p must point to a python string.
explicit string(ref p);
explicit string(const char* s);
string(const char* s, std::size_t length);
string(const string& rhs);
enum interned_t { interned };
string(const char* s, interned_t);
// Get the type object for Strings
static PyTypeObject* type_obj();
// Return true if the given object is a python string
static bool accepts(ref o);
// Return the length of the string.
std::size_t size() const;
// 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* c_str() const;
string& operator*=(unsigned int repeat_count);
string& operator+=(const string& rhs);
friend string operator+(string x, string y);
string& operator+=(const char* rhs);
friend string operator+(string x, const char* y);
friend string operator+(const char* x, string y);
void intern();
friend string operator%(const string& format, const tuple& args);
};
class dictionary;
struct BOOST_PYTHON_DECL dictionary_proxy;
class BOOST_PYTHON_DECL dictionary_base : public object
{
protected:
typedef dictionary_proxy proxy;
public:
explicit dictionary_base(ref p);
dictionary_base();
void clear();
static PyTypeObject* type_obj();
static bool accepts(ref p);
public:
proxy operator[](ref key);
ref operator[](ref key) const;
ref get_item(const ref& key) const;
ref get_item(const ref& key, const ref& default_) const;
void set_item(const ref& key, const ref& value);
void erase(ref key);
// proxy operator[](const object& key);
// ref operator[](const object& key) const;
// ref get_item(const object& key, ref default_ = ref()) const;
// void set_item(const object& key, const ref& value);
// void erase(const object& key);
list items() const;
list keys() const;
list values() const;
std::size_t size() const;
// TODO: iterator support
};
struct BOOST_PYTHON_DECL dictionary_proxy
{
template <class T>
const ref& operator=(const T& rhs)
{ return (*this) = make_ref(rhs); }
const ref& operator=(const ref& rhs);
operator ref() const;
private:
friend class dictionary_base;
dictionary_proxy(const ref& dict, const ref& key);
// This is needed to work around the very strange MSVC error report that the
// return type of the built-in operator= differs from that of the ones
// defined above. Couldn't hurt to make these un-assignable anyway, though.
const ref& operator=(const dictionary_proxy&); // Not actually implemented
private:
ref m_dict;
ref m_key;
};
class dictionary : public dictionary_base
{
typedef dictionary_proxy proxy;
public:
explicit dictionary(ref p) : dictionary_base(p) {}
dictionary() : dictionary_base() {}
template <class Key>
proxy operator[](const Key& key)
{ return this->operator[](make_ref(key)); }
proxy operator[](ref key)
{ return dictionary_base::operator[](key); }
template <class Key>
ref operator[](const Key& key) const
{ return this->operator[](make_ref(key)); }
ref operator[](ref key) const
{ return dictionary_base::operator[](key); }
template <class Key>
ref get_item(const Key& key) const
{ return this->get_item(make_ref(key)); }
ref get_item(const ref& key) const
{ return dictionary_base::get_item(key); }
template <class Key, class Default>
ref get_item(const Key& key, const Default& default_) const
{ return this->get_item(make_ref(key), make_ref(default_)); }
ref get_item(const ref& key, const ref& default_) const
{ return dictionary_base::get_item(key, default_); }
template <class Key, class Value>
void set_item(const Key& key, const Value& value)
{ this->set_item(make_ref(key), make_ref(value)); }
void set_item(const ref& key, const ref& value)
{ dictionary_base::set_item(key, value); }
template <class Key>
void erase(const Key& key)
{ this->erase(make_ref(key)); }
void erase(ref key)
{ dictionary_base::erase(key); }
};
struct BOOST_PYTHON_DECL list_proxy
{
template <class T>
const ref& operator=(const T& rhs)
{ return (*this) = make_ref(rhs); }
const ref& operator=(const ref& rhs);
operator ref() const;
private:
friend class list_base;
list_proxy(const ref& list, std::size_t index);
// This is needed to work around the very strange MSVC error report that the
// return type of the built-in operator= differs from that of the ones
// defined above. Couldn't hurt to make these un-assignable anyway, though.
const ref& operator=(const list_proxy&); // Not actually implemented
private:
list m_list;
std::size_t m_index;
};
struct BOOST_PYTHON_DECL list_slice_proxy
{
const list& operator=(const list& rhs);
operator ref() const;
operator list() const;
std::size_t size() const;
ref operator[](std::size_t pos) const;
private:
friend class list_base;
list_slice_proxy(const ref& list, int low, int high);
private:
ref m_list;
int m_low, m_high;
};
}} // namespace boost::python
BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
BOOST_PYTHON_DECL PyObject* to_python(const boost::python::tuple&);
BOOST_PYTHON_DECL boost::python::tuple from_python(PyObject* p, boost::python::type<boost::python::tuple>);
inline boost::python::tuple from_python(PyObject* p, boost::python::type<const boost::python::tuple&>)
{
return from_python(p, boost::python::type<boost::python::tuple>());
}
BOOST_PYTHON_DECL PyObject* to_python(const boost::python::list&);
BOOST_PYTHON_DECL boost::python::list from_python(PyObject* p, boost::python::type<boost::python::list>);
inline boost::python::list from_python(PyObject* p, boost::python::type<const boost::python::list&>)
{
return from_python(p, boost::python::type<boost::python::list>());
}
BOOST_PYTHON_DECL PyObject* to_python(const boost::python::string&);
BOOST_PYTHON_DECL boost::python::string from_python(PyObject* p, boost::python::type<boost::python::string>);
inline boost::python::string from_python(PyObject* p, boost::python::type<const boost::python::string&>)
{
return from_python(p, boost::python::type<boost::python::string>());
}
BOOST_PYTHON_DECL PyObject* to_python(const boost::python::dictionary&);
BOOST_PYTHON_DECL boost::python::dictionary from_python(PyObject* p, boost::python::type<boost::python::dictionary>);
inline boost::python::dictionary from_python(PyObject* p, boost::python::type<const boost::python::dictionary&>)
{
return from_python(p, boost::python::type<boost::python::dictionary>());
}
BOOST_PYTHON_END_CONVERSION_NAMESPACE
# endif // !BOOST_PYTHON_V2
#endif // OBJECTS_DWA051100_H_

700
include/boost/python/py_interface.hpp
View File

@@ -1,700 +0,0 @@
// Automatically generated from py_api_gen.py
#ifndef PY_INTERFACE_HPP
#define PY_INTERFACE_HPP
#include <boost/python/object.hpp>
#include <boost/python/arg_from_python.hpp>
namespace boost { namespace python { namespace api {
enum call_dict_usage { use_new_dict, use_local_dict, use_global_dict };
namespace api_detail {
BOOST_PYTHON_DECL object get_func(const char* name);
BOOST_PYTHON_DECL object call_statement(const char *stmt, int n, ...);
BOOST_PYTHON_DECL object call_statement_du(const char *stmt, call_dict_usage cdu, int n, ...);
template<class A>
struct get_arg
{
get_arg(A const &a) : h(a) {}
object h;
operator object const& () { return h; }
operator object const* () { return &h; }
};
template<>
struct get_arg<object>
{
get_arg(object const &a) : h(a) {}
object const &h;
operator object const& () { return h; }
operator object const* () { return &h; }
};
template<>
struct get_arg<PyObject*>
{
get_arg(PyObject* a) : h((python::detail::borrowed_reference)a) {}
object h;
operator object const& () { return h; }
operator object const* () { return &h; }
};
}
BOOST_PYTHON_DECL object locals();
template<class A0>
object abs(A0 const& a0)
{
return api_detail::get_func("abs")(api_detail::get_arg<A0>(a0));
}
BOOST_PYTHON_DECL object abs(object const& a0);
BOOST_PYTHON_DECL object abs(short a0);
BOOST_PYTHON_DECL object abs(int a0);
BOOST_PYTHON_DECL object abs(long a0);
BOOST_PYTHON_DECL object abs(double const & a0);
BOOST_PYTHON_DECL object apply(object const& a0, object const& a1);
BOOST_PYTHON_DECL object apply(object const& a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL bool callable(object const& a0);
template<class A0>
object chr(A0 const& a0)
{
return api_detail::get_func("chr")(api_detail::get_arg<A0>(a0));
}
BOOST_PYTHON_DECL object chr(object const& a0);
BOOST_PYTHON_DECL object chr(short a0);
BOOST_PYTHON_DECL object chr(int a0);
BOOST_PYTHON_DECL object chr(long a0);
template<class A0, class A1>
int cmp(A0 const& a0, A1 const& a1)
{
int rslt;
int r = ::PyObject_Cmp(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), &rslt);
if(r == -1)
throw_error_already_set();
return rslt;
}
BOOST_PYTHON_DECL int cmp(object const& a0, object const& a1);
BOOST_PYTHON_DECL object coerce(object const& a0, object const& a1);
BOOST_PYTHON_DECL object compile(object const& a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL object compile(const char* a0, const char* a1, const char* a2);
BOOST_PYTHON_DECL object compile(object const& a0, object const& a1, object const& a2, object const& a3);
BOOST_PYTHON_DECL object compile(const char* a0, const char* a1, const char* a2, int a3);
BOOST_PYTHON_DECL object compile(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4);
BOOST_PYTHON_DECL object compile(const char* a0, const char* a1, const char* a2, int a3, int a4);
template<class A0>
object complex(A0 const& a0)
{
return api_detail::get_func("complex")(api_detail::get_arg<A0>(a0));
}
BOOST_PYTHON_DECL object complex(object const& a0);
BOOST_PYTHON_DECL object complex(double const& a0);
template<class A0, class A1>
object complex(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("complex")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1));
}
BOOST_PYTHON_DECL object complex(object const& a0, object const& a1);
BOOST_PYTHON_DECL object complex(double const& a0, double const& a1);
BOOST_PYTHON_DECL object dict();
BOOST_PYTHON_DECL object dict(object const& a0);
BOOST_PYTHON_DECL object dir();
BOOST_PYTHON_DECL object dir(object const& a0);
template<class A0, class A1>
object divmod(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("divmod")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1));
}
BOOST_PYTHON_DECL object divmod(object const& a0, object const& a1);
BOOST_PYTHON_DECL object divmod(int a0, int a1);
BOOST_PYTHON_DECL object divmod(long a0, long a1);
BOOST_PYTHON_DECL object divmod(double const& a0, double const& a1);
BOOST_PYTHON_DECL object eval(const char* a0);
BOOST_PYTHON_DECL object eval(const char* a0, object const& a2);
BOOST_PYTHON_DECL object eval(const char* a0, object const& a2, object const& a3);
BOOST_PYTHON_DECL object exec(const char* a0);
BOOST_PYTHON_DECL object exec(const char* a0, object const& a2);
BOOST_PYTHON_DECL object exec(const char* a0, object const& a2, object const& a3);
BOOST_PYTHON_DECL object execfile(object const& a0);
BOOST_PYTHON_DECL object execfile(object const& a0, object const& a1);
BOOST_PYTHON_DECL object execfile(object const& a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL object file(object const& a0);
BOOST_PYTHON_DECL object file(const char* a0);
BOOST_PYTHON_DECL object file(object const& a0, object const& a1);
BOOST_PYTHON_DECL object file(const char* a0, const char* a1);
BOOST_PYTHON_DECL object file(object const& a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL object file(const char* a0, const char* a1, int a2);
BOOST_PYTHON_DECL object filter(object const& a0, object const& a1);
BOOST_PYTHON_DECL object float_(object const& a0);
BOOST_PYTHON_DECL object float_(const char* a0);
BOOST_PYTHON_DECL object float_(double const& a0);
BOOST_PYTHON_DECL object getattr(object const& a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL object getattr(object const& a0, const char * a1, object const& a2);
BOOST_PYTHON_DECL object globals();
BOOST_PYTHON_DECL bool hasattr(object const& a0, object const& a1);
BOOST_PYTHON_DECL bool hasattr(object const& a0, const char* a1);
BOOST_PYTHON_DECL long hash(object const& a0);
template<class A0>
object hex(A0 const& a0)
{
return api_detail::get_func("hex")(api_detail::get_arg<A0>(a0));
}
BOOST_PYTHON_DECL object hex(object const& a0);
BOOST_PYTHON_DECL object hex(char a0);
BOOST_PYTHON_DECL object hex(short a0);
BOOST_PYTHON_DECL object hex(int a0);
BOOST_PYTHON_DECL object hex(long a0);
BOOST_PYTHON_DECL long id(object const& a0);
BOOST_PYTHON_DECL object input();
BOOST_PYTHON_DECL object input(object const& a0);
BOOST_PYTHON_DECL object input(const char* a0);
BOOST_PYTHON_DECL object int_(object const& a0);
BOOST_PYTHON_DECL object int_(long a0);
BOOST_PYTHON_DECL object int_(const char* a0);
BOOST_PYTHON_DECL object intern(object const& a0);
BOOST_PYTHON_DECL object intern(const char* a0);
BOOST_PYTHON_DECL bool isinstance(object const& a0, object const& a1);
BOOST_PYTHON_DECL bool issubclass(object const& a0, object const& a1);
BOOST_PYTHON_DECL object iter(object const& a0);
BOOST_PYTHON_DECL object iter(object const& a0, object const& a1);
BOOST_PYTHON_DECL long len(object const& a0);
BOOST_PYTHON_DECL object list();
BOOST_PYTHON_DECL object list(object const& a0);
BOOST_PYTHON_DECL object long_(object const& a0);
BOOST_PYTHON_DECL object long_(long a0);
BOOST_PYTHON_DECL object long_(const char* a0);
BOOST_PYTHON_DECL object map(object const& a0);
BOOST_PYTHON_DECL object map(object const& a0, object const& a1);
BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3);
BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4);
BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5);
BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6);
BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7);
BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8);
BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9);
template<class A0>
object max(A0 const& a0)
{
return api_detail::get_func("max")(api_detail::get_arg<A0>(a0));
}
template<class A0, class A1>
object max(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("max")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1));
}
template<class A0, class A1, class A2>
object max(A0 const& a0, A1 const& a1, A2 const& a2)
{
return api_detail::get_func("max")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2));
}
template<class A0, class A1, class A2, class A3>
object max(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3)
{
return api_detail::get_func("max")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3));
}
template<class A0, class A1, class A2, class A3, class A4>
object max(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4)
{
return api_detail::get_func("max")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4));
}
template<class A0, class A1, class A2, class A3, class A4, class A5>
object max(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5)
{
return api_detail::get_func("max")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6>
object max(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6)
{
return api_detail::get_func("max")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5), api_detail::get_arg<A6>(a6));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
object max(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7)
{
return api_detail::get_func("max")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5), api_detail::get_arg<A6>(a6), api_detail::get_arg<A7>(a7));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
object max(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8)
{
return api_detail::get_func("max")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5), api_detail::get_arg<A6>(a6), api_detail::get_arg<A7>(a7), api_detail::get_arg<A8>(a8));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
object max(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9)
{
return api_detail::get_func("max")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5), api_detail::get_arg<A6>(a6), api_detail::get_arg<A7>(a7), api_detail::get_arg<A8>(a8), api_detail::get_arg<A9>(a9));
}
BOOST_PYTHON_DECL object max(object const& a0);
BOOST_PYTHON_DECL object max(object const& a0, object const& a1);
BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3);
BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4);
BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5);
BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6);
BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7);
BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8);
BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9);
template<class A0>
object min(A0 const& a0)
{
return api_detail::get_func("min")(api_detail::get_arg<A0>(a0));
}
template<class A0, class A1>
object min(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("min")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1));
}
template<class A0, class A1, class A2>
object min(A0 const& a0, A1 const& a1, A2 const& a2)
{
return api_detail::get_func("min")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2));
}
template<class A0, class A1, class A2, class A3>
object min(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3)
{
return api_detail::get_func("min")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3));
}
template<class A0, class A1, class A2, class A3, class A4>
object min(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4)
{
return api_detail::get_func("min")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4));
}
template<class A0, class A1, class A2, class A3, class A4, class A5>
object min(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5)
{
return api_detail::get_func("min")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6>
object min(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6)
{
return api_detail::get_func("min")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5), api_detail::get_arg<A6>(a6));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
object min(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7)
{
return api_detail::get_func("min")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5), api_detail::get_arg<A6>(a6), api_detail::get_arg<A7>(a7));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
object min(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8)
{
return api_detail::get_func("min")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5), api_detail::get_arg<A6>(a6), api_detail::get_arg<A7>(a7), api_detail::get_arg<A8>(a8));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
object min(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9)
{
return api_detail::get_func("min")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5), api_detail::get_arg<A6>(a6), api_detail::get_arg<A7>(a7), api_detail::get_arg<A8>(a8), api_detail::get_arg<A9>(a9));
}
BOOST_PYTHON_DECL object min(object const& a0);
BOOST_PYTHON_DECL object min(object const& a0, object const& a1);
BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3);
BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4);
BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5);
BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6);
BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7);
BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8);
BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9);
template<class A0>
object oct(A0 const& a0)
{
return api_detail::get_func("oct")(api_detail::get_arg<A0>(a0));
}
BOOST_PYTHON_DECL object oct(object const& a0);
BOOST_PYTHON_DECL object oct(char a0);
BOOST_PYTHON_DECL object oct(short a0);
BOOST_PYTHON_DECL object oct(int a0);
BOOST_PYTHON_DECL object oct(long a0);
BOOST_PYTHON_DECL object open(object const& a0);
BOOST_PYTHON_DECL object open(const char* a0);
BOOST_PYTHON_DECL object open(object const& a0, object const& a1);
BOOST_PYTHON_DECL object open(const char* a0, const char* a1);
BOOST_PYTHON_DECL object open(object const& a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL object open(const char* a0, const char* a1, int a2);
BOOST_PYTHON_DECL long ord(object const& a0);
BOOST_PYTHON_DECL long ord(const char* a0);
template<class A0, class A1>
object pow(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("pow")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1));
}
BOOST_PYTHON_DECL object pow(object const& a0, object const& a1);
BOOST_PYTHON_DECL object pow(double const& a0, double const& a1);
BOOST_PYTHON_DECL object pow(double const& a0, double const& a1, double const& a2);
template<class A0>
object print(A0 const& a0)
{
return api_detail::call_statement_du("print _1", use_new_dict, 1, (object const*)api_detail::get_arg<A0>(a0));
}
template<class A0, class A1>
object print(A0 const& a0, A1 const& a1)
{
return api_detail::call_statement_du("print _1, _2", use_new_dict, 2, (object const*)api_detail::get_arg<A0>(a0), (object const*)api_detail::get_arg<A1>(a1));
}
template<class A0, class A1, class A2>
object print(A0 const& a0, A1 const& a1, A2 const& a2)
{
return api_detail::call_statement_du("print _1, _2, _3", use_new_dict, 3, (object const*)api_detail::get_arg<A0>(a0), (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2));
}
template<class A0, class A1, class A2, class A3>
object print(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3)
{
return api_detail::call_statement_du("print _1, _2, _3, _4", use_new_dict, 4, (object const*)api_detail::get_arg<A0>(a0), (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3));
}
template<class A0, class A1, class A2, class A3, class A4>
object print(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4)
{
return api_detail::call_statement_du("print _1, _2, _3, _4, _5", use_new_dict, 5, (object const*)api_detail::get_arg<A0>(a0), (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4));
}
template<class A0, class A1, class A2, class A3, class A4, class A5>
object print(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5)
{
return api_detail::call_statement_du("print _1, _2, _3, _4, _5, _6", use_new_dict, 6, (object const*)api_detail::get_arg<A0>(a0), (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6>
object print(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6)
{
return api_detail::call_statement_du("print _1, _2, _3, _4, _5, _6, _7", use_new_dict, 7, (object const*)api_detail::get_arg<A0>(a0), (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
object print(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7)
{
return api_detail::call_statement_du("print _1, _2, _3, _4, _5, _6, _7, _8", use_new_dict, 8, (object const*)api_detail::get_arg<A0>(a0), (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
object print(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8)
{
return api_detail::call_statement_du("print _1, _2, _3, _4, _5, _6, _7, _8, _9", use_new_dict, 9, (object const*)api_detail::get_arg<A0>(a0), (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
object print(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9)
{
return api_detail::call_statement_du("print _1, _2, _3, _4, _5, _6, _7, _8, _9, _10", use_new_dict, 10, (object const*)api_detail::get_arg<A0>(a0), (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8), (object const*)api_detail::get_arg<A9>(a9));
}
BOOST_PYTHON_DECL object print(object const& a0);
BOOST_PYTHON_DECL object print(object const& a0, object const& a1);
BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3);
BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4);
BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5);
BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6);
BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7);
BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8);
BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9);
template<class A1>
object print_file(object const& a0, A1 const& a1)
{
return api_detail::call_statement_du("print >>_1, _2", use_new_dict, 2, a0, (object const*)api_detail::get_arg<A1>(a1));
}
template<class A1, class A2>
object print_file(object const& a0, A1 const& a1, A2 const& a2)
{
return api_detail::call_statement_du("print >>_1, _2, _3", use_new_dict, 3, a0, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2));
}
template<class A1, class A2, class A3>
object print_file(object const& a0, A1 const& a1, A2 const& a2, A3 const& a3)
{
return api_detail::call_statement_du("print >>_1, _2, _3, _4", use_new_dict, 4, a0, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3));
}
template<class A1, class A2, class A3, class A4>
object print_file(object const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4)
{
return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5", use_new_dict, 5, a0, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4));
}
template<class A1, class A2, class A3, class A4, class A5>
object print_file(object const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5)
{
return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6", use_new_dict, 6, a0, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5));
}
template<class A1, class A2, class A3, class A4, class A5, class A6>
object print_file(object const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6)
{
return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6, _7", use_new_dict, 7, a0, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6));
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7>
object print_file(object const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7)
{
return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6, _7, _8", use_new_dict, 8, a0, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7));
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
object print_file(object const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8)
{
return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6, _7, _8, _9", use_new_dict, 9, a0, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8));
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
object print_file(object const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9)
{
return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6, _7, _8, _9, _10", use_new_dict, 10, a0, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8), (object const*)api_detail::get_arg<A9>(a9));
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
object print_file(object const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10)
{
return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11", use_new_dict, 11, a0, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8), (object const*)api_detail::get_arg<A9>(a9), (object const*)api_detail::get_arg<A10>(a10));
}
BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1);
BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3);
BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4);
BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5);
BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6);
BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7);
BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8);
BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9);
BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9, object const& a10);
template<class A0>
object range(A0 const& a0)
{
return api_detail::get_func("range")(api_detail::get_arg<A0>(a0));
}
BOOST_PYTHON_DECL object range(object const& a0);
BOOST_PYTHON_DECL object range(int a0);
template<class A0, class A1>
object range(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("range")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1));
}
BOOST_PYTHON_DECL object range(object const& a0, object const& a1);
BOOST_PYTHON_DECL object range(int a0, int a1);
template<class A0, class A1, class A2>
object range(A0 const& a0, A1 const& a1, A2 const& a2)
{
return api_detail::get_func("range")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2));
}
BOOST_PYTHON_DECL object range(object const& a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL object range(int a0, int a1, int a2);
BOOST_PYTHON_DECL object raw_input();
BOOST_PYTHON_DECL object raw_input(object const& a0);
BOOST_PYTHON_DECL object raw_input(const char* a0);
BOOST_PYTHON_DECL object reduce(object const& a0, object const& a1);
BOOST_PYTHON_DECL object reduce(object const& a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL object reload(object const& a0);
BOOST_PYTHON_DECL object repr(object const& a0);
template<class A0>
object round(A0 const& a0)
{
return api_detail::get_func("round")(api_detail::get_arg<A0>(a0));
}
BOOST_PYTHON_DECL object round(object const& a0);
BOOST_PYTHON_DECL object round(double const& a0);
template<class A0, class A1>
object round(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("round")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1));
}
BOOST_PYTHON_DECL object round(object const& a0, object const& a1);
BOOST_PYTHON_DECL object round(double const& a0, double const& a1);
template<class A0>
object slice(A0 const& a0)
{
return api_detail::get_func("slice")(api_detail::get_arg<A0>(a0));
}
BOOST_PYTHON_DECL object slice(object const& a0);
BOOST_PYTHON_DECL object slice(int a0);
template<class A0, class A1>
object slice(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("slice")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1));
}
BOOST_PYTHON_DECL object slice(object const& a0, object const& a1);
BOOST_PYTHON_DECL object slice(int a0, int a1);
template<class A0, class A1, class A2>
object slice(A0 const& a0, A1 const& a1, A2 const& a2)
{
return api_detail::get_func("slice")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2));
}
BOOST_PYTHON_DECL object slice(object const& a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL object slice(int a0, int a1, int a2);
BOOST_PYTHON_DECL object str(object const& a0);
BOOST_PYTHON_DECL object tuple();
BOOST_PYTHON_DECL object tuple(object const& a0);
BOOST_PYTHON_DECL object type_(object const& a0);
template<class A0>
object unichr(A0 const& a0)
{
return api_detail::get_func("unichr")(api_detail::get_arg<A0>(a0));
}
BOOST_PYTHON_DECL object unichr(object const& a0);
BOOST_PYTHON_DECL object unichr(short a0);
BOOST_PYTHON_DECL object unichr(int a0);
BOOST_PYTHON_DECL object unichr(long a0);
BOOST_PYTHON_DECL object unicode(object const& a0);
BOOST_PYTHON_DECL object unicode(object const& a0, object const& a1);
BOOST_PYTHON_DECL object unicode(object const& a0, const char* a1);
BOOST_PYTHON_DECL object unicode(object const& a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL object unicode(object const& a0, const char* a1, const char* a2);
BOOST_PYTHON_DECL object vars();
BOOST_PYTHON_DECL object vars(object const& a0);
template<class A0>
object xrange(A0 const& a0)
{
return api_detail::get_func("xrange")(api_detail::get_arg<A0>(a0));
}
BOOST_PYTHON_DECL object xrange(object const& a0);
BOOST_PYTHON_DECL object xrange(int a0);
template<class A0, class A1>
object xrange(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("xrange")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1));
}
BOOST_PYTHON_DECL object xrange(object const& a0, object const& a1);
BOOST_PYTHON_DECL object xrange(int a0, int a1);
template<class A0, class A1, class A2>
object xrange(A0 const& a0, A1 const& a1, A2 const& a2)
{
return api_detail::get_func("xrange")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2));
}
BOOST_PYTHON_DECL object xrange(object const& a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL object xrange(int a0, int a1, int a2);
BOOST_PYTHON_DECL object zip(object const& a0);
BOOST_PYTHON_DECL object zip(object const& a0, object const& a1);
BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3);
BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4);
BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5);
BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6);
BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7);
BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8);
BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9);
BOOST_PYTHON_DECL object compile_string(const char* a0, const char* a1, int a2);
BOOST_PYTHON_DECL int import_append_inittab(const char* a0, void(*a1)(void));
BOOST_PYTHON_DECL object import_add_module(const char* a0);
BOOST_PYTHON_DECL object import_get_module_dict();
BOOST_PYTHON_DECL object import_import(object const& a0);
BOOST_PYTHON_DECL object import_import(const char* a0);
BOOST_PYTHON_DECL object import_import_module(const char* a0);
BOOST_PYTHON_DECL object import_import_module_ex(const char* a0, object const& a1, object const& a2, object const& a3);
BOOST_PYTHON_DECL object module_get_dict(object const& a0);
BOOST_PYTHON_DECL int object_print(object const& a0, FILE* a1, int a2);
BOOST_PYTHON_DECL object run_file(FILE* a0, const char* a1, int a2, object const& a3, object const& a4);
BOOST_PYTHON_DECL int run_simple_file(FILE* a0, const char* a1);
BOOST_PYTHON_DECL int run_simple_string(const char* a0);
BOOST_PYTHON_DECL object run_string(const char* a0, int a1, object const& a2, object const& a3);
BOOST_PYTHON_DECL object call_statement(const char* a0);
BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1);
template<class A1>
object call_statement(const char* a0, A1 const& a1)
{
return api_detail::call_statement(a0, 1, (object const*)api_detail::get_arg<A1>(a1));
}
template<class A1, class A2>
object call_statement(const char* a0, A1 const& a1, A2 const& a2)
{
return api_detail::call_statement(a0, 2, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2));
}
template<class A1, class A2, class A3>
object call_statement(const char* a0, A1 const& a1, A2 const& a2, A3 const& a3)
{
return api_detail::call_statement(a0, 3, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3));
}
template<class A1, class A2, class A3, class A4>
object call_statement(const char* a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4)
{
return api_detail::call_statement(a0, 4, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4));
}
template<class A1, class A2, class A3, class A4, class A5>
object call_statement(const char* a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5)
{
return api_detail::call_statement(a0, 5, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5));
}
template<class A1, class A2, class A3, class A4, class A5, class A6>
object call_statement(const char* a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6)
{
return api_detail::call_statement(a0, 6, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6));
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7>
object call_statement(const char* a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7)
{
return api_detail::call_statement(a0, 7, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7));
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
object call_statement(const char* a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8)
{
return api_detail::call_statement(a0, 8, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8));
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
object call_statement(const char* a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9)
{
return api_detail::call_statement(a0, 9, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8), (object const*)api_detail::get_arg<A9>(a9));
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
object call_statement(const char* a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10)
{
return api_detail::call_statement(a0, 10, (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8), (object const*)api_detail::get_arg<A9>(a9), (object const*)api_detail::get_arg<A10>(a10));
}
BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1);
BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2);
BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3);
BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4);
BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5);
BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6);
BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7);
BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8);
BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9);
BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9, object const& a10);
template<class A2>
object call_statement(const char* a0, call_dict_usage a1, A2 const& a2)
{
return api_detail::call_statement_du(a0, a1, 1, (object const*)api_detail::get_arg<A2>(a2));
}
template<class A2, class A3>
object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3)
{
return api_detail::call_statement_du(a0, a1, 2, (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3));
}
template<class A2, class A3, class A4>
object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3, A4 const& a4)
{
return api_detail::call_statement_du(a0, a1, 3, (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4));
}
template<class A2, class A3, class A4, class A5>
object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5)
{
return api_detail::call_statement_du(a0, a1, 4, (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5));
}
template<class A2, class A3, class A4, class A5, class A6>
object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6)
{
return api_detail::call_statement_du(a0, a1, 5, (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6));
}
template<class A2, class A3, class A4, class A5, class A6, class A7>
object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7)
{
return api_detail::call_statement_du(a0, a1, 6, (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7));
}
template<class A2, class A3, class A4, class A5, class A6, class A7, class A8>
object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8)
{
return api_detail::call_statement_du(a0, a1, 7, (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8));
}
template<class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9)
{
return api_detail::call_statement_du(a0, a1, 8, (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8), (object const*)api_detail::get_arg<A9>(a9));
}
template<class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10)
{
return api_detail::call_statement_du(a0, a1, 9, (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8), (object const*)api_detail::get_arg<A9>(a9), (object const*)api_detail::get_arg<A10>(a10));
}
template<class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11)
{
return api_detail::call_statement_du(a0, a1, 10, (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8), (object const*)api_detail::get_arg<A9>(a9), (object const*)api_detail::get_arg<A10>(a10), (object const*)api_detail::get_arg<A11>(a11));
}
BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2);
BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3);
BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4);
BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5);
BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6);
BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7);
BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8);
BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9);
BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9, object const& a10);
BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9, object const& a10, object const& a11);
}}}
#endif // PY_INTERFACE_HPP

236
include/boost/python/reference.hpp
View File

@@ -1,236 +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 PYPTR_DWA050400_H_
# define PYPTR_DWA050400_H_
# ifdef BOOST_PYTHON_V2
# error obsolete
# else
# include <boost/python/detail/config.hpp>
# include <boost/operators.hpp>
# include <boost/python/detail/wrap_python.hpp>
# include <boost/python/detail/cast.hpp>
# include <cassert>
# include <cstddef>
# include <boost/python/detail/signatures.hpp>
# include <boost/python/errors.hpp>
# include <boost/python/detail/cast.hpp>
# include <boost/python/conversions.hpp>
BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
template <class T, class Value, class Base = boost::detail::empty_base>
struct py_ptr_conversions : Base
{
inline friend T from_python(PyObject* x, boost::python::type<const T&>)
{ return T(boost::python::downcast<Value>(x).get(), T::increment_count); }
inline friend T from_python(PyObject* x, boost::python::type<T>)
{ return T(boost::python::downcast<Value>(x).get(), T::increment_count); }
inline friend PyObject* to_python(T x)
{ return boost::python::as_object(x.release()); }
};
BOOST_PYTHON_END_CONVERSION_NAMESPACE
namespace boost { namespace python {
BOOST_PYTHON_IMPORT_CONVERSION(py_ptr_conversions);
template <class T>
class reference
: public py_ptr_conversions<reference<T>, T>
{
public:
typedef T value_type;
reference(const reference& rhs)
: m_p(rhs.m_p)
{
assert(m_p == 0 || m_p->ob_refcnt > 0);
Py_XINCREF(m_p);
}
reference() : m_p(0) {}
// These are two ways of spelling the same thing, that we need to increment
// the reference count on the pointer when we're initialized.
enum increment_count_t { increment_count };
enum allow_null { null_ok };
template <class T2>
explicit reference(T2* x)
: m_p(expect_non_null(x))
{
assert(m_p->ob_refcnt > 0);
}
template <class T2>
reference(T2* x, increment_count_t)
: m_p(expect_non_null(x))
{
assert(m_p->ob_refcnt > 0);
Py_INCREF(m_p);
}
template <class T2>
reference(T2* x, allow_null)
: m_p(x)
{
assert(m_p == 0 || m_p->ob_refcnt > 0);
}
template <class T2>
reference(T2* x, allow_null, increment_count_t)
: m_p(x)
{
assert(m_p == 0 || m_p->ob_refcnt > 0);
Py_XINCREF(m_p);
}
template <class T2>
reference(T2* x, increment_count_t, allow_null)
: m_p(x)
{
assert(m_p == 0 || m_p->ob_refcnt > 0);
Py_XINCREF(m_p);
}
reference& operator=(const reference& rhs)
{
assert(rhs.m_p == 0 || rhs.m_p->ob_refcnt > 0);
Py_XINCREF(static_cast<PyObject*>(rhs.m_p));
assert(m_p == 0 || m_p->ob_refcnt > 0);
Py_XDECREF(m_p);
m_p = rhs.m_p;
return *this;
}
~reference()
{
assert(m_p == 0 || m_p->ob_refcnt > 0);
Py_XDECREF(m_p);
}
T& operator*() const
{
assert(m_p == 0 || m_p->ob_refcnt > 0);
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
{
assert(m_p == 0 || m_p->ob_refcnt > 0);
return &**this;
}
T* get() const
{
assert(m_p == 0 || m_p->ob_refcnt > 0);
return m_p;
}
T* release()
{
assert(m_p == 0 || m_p->ob_refcnt > 0);
T* p = m_p;
m_p = 0;
return p;
}
void reset()
{
assert(m_p == 0 || m_p->ob_refcnt > 0);
Py_XDECREF(m_p);
m_p = 0;
}
template <class T2>
void reset(T2* x)
{
assert(m_p == 0 || m_p->ob_refcnt > 0);
Py_XDECREF(m_p);
m_p = expect_non_null(x);
assert(m_p == 0 || m_p->ob_refcnt > 0);
}
template <class T2>
void reset(T2* x, increment_count_t)
{
assert(m_p == 0 || m_p->ob_refcnt > 0);
Py_XINCREF(x);
Py_XDECREF(m_p);
m_p = expect_non_null(x);
assert(m_p->ob_refcnt > 0);
}
template <class T2>
void reset(T2* x, allow_null)
{
assert(m_p == 0 || m_p->ob_refcnt > 0);
Py_XDECREF(m_p);
m_p = x;
assert(m_p == 0 || m_p->ob_refcnt > 0);
}
template <class T2>
void reset(T2* x, allow_null, increment_count_t)
{
assert(m_p == 0 || m_p->ob_refcnt > 0);
Py_XINCREF(x);
Py_XDECREF(m_p);
m_p = x;
assert(m_p == 0 || m_p->ob_refcnt > 0);
}
template <class T2>
void reset(T2* x, increment_count_t, allow_null)
{
assert(m_p == 0 || m_p->ob_refcnt > 0);
Py_XINCREF(x);
Py_XDECREF(m_p);
m_p = x;
assert(m_p == 0 || m_p->ob_refcnt > 0);
}
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
private:
template<typename Y> friend class shared_ptr;
#endif
inline PyObject* object() const
{
return as_object(m_p);
}
T* m_p;
};
typedef reference<PyObject> ref;
template <class T>
ref make_ref(const T& x)
{
return ref(to_python(x));
}
}} // namespace boost::python
#endif // BOOST_PYTHON_V2
#endif // PYPTR_DWA050400_H_

1047
src/classes.cpp
View File

File diff suppressed because it is too large Load Diff

223
src/conversions.cpp
View File

@@ -1,223 +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)
#define BOOST_PYTHON_SOURCE
#include <boost/python/conversions.hpp>
#include <boost/function.hpp>
#include <typeinfo>
#include <exception>
#include <boost/cast.hpp>
BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
BOOST_PYTHON_DECL 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())
boost::python::throw_argument_error();
}
return result;
}
BOOST_PYTHON_DECL double from_python(PyObject* p, boost::python::type<double>)
{
double result;
{
result = PyFloat_AsDouble(p);
if (PyErr_Occurred())
boost::python::throw_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>());
try
{
return boost::numeric_cast<T>(long_result);
}
catch(const boost::bad_numeric_cast&)
{
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);
boost::python::throw_argument_error();
}
return 0; // Not smart enough to know that the catch clause always rethrows
}
template <class T>
PyObject* integer_to_python(T value)
{
long value_as_long;
try
{
value_as_long = boost::numeric_cast<long>(value);
}
catch(const boost::bad_numeric_cast&)
{
const char message[] = "value out of range for Python int";
PyErr_SetString(PyExc_ValueError, message);
boost::python::throw_error_already_set();
}
return to_python(value_as_long);
}
BOOST_PYTHON_DECL int from_python(PyObject* p, boost::python::type<int> type)
{
return integer_from_python(p, type);
}
BOOST_PYTHON_DECL PyObject* to_python(unsigned int i)
{
return integer_to_python(i);
}
BOOST_PYTHON_DECL unsigned int from_python(PyObject* p, boost::python::type<unsigned int> type)
{
return integer_from_python(p, type);
}
BOOST_PYTHON_DECL short from_python(PyObject* p, boost::python::type<short> type)
{
return integer_from_python(p, type);
}
BOOST_PYTHON_DECL float from_python(PyObject* p, boost::python::type<float>)
{
return static_cast<float>(from_python(p, boost::python::type<double>()));
}
BOOST_PYTHON_DECL PyObject* to_python(unsigned short i)
{
return integer_to_python(i);
}
BOOST_PYTHON_DECL unsigned short from_python(PyObject* p, boost::python::type<unsigned short> type)
{
return integer_from_python(p, type);
}
BOOST_PYTHON_DECL PyObject* to_python(char c)
{
if (c == '\0') return PyString_FromString("");
return PyString_FromStringAndSize(&c, 1);
}
BOOST_PYTHON_DECL 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");
boost::python::throw_argument_error();
}
if (l == 0) return '\0';
return PyString_AsString(p)[0];
}
BOOST_PYTHON_DECL PyObject* to_python(unsigned char i)
{
return integer_to_python(i);
}
BOOST_PYTHON_DECL unsigned char from_python(PyObject* p, boost::python::type<unsigned char> type)
{
return integer_from_python(p, type);
}
BOOST_PYTHON_DECL PyObject* to_python(signed char i)
{
return integer_to_python(i);
}
BOOST_PYTHON_DECL signed char from_python(PyObject* p, boost::python::type<signed char> type)
{
return integer_from_python(p, type);
}
BOOST_PYTHON_DECL PyObject* to_python(unsigned long x)
{
return integer_to_python(x);
}
BOOST_PYTHON_DECL unsigned long from_python(PyObject* p, boost::python::type<unsigned long> type)
{
return integer_from_python(p, type);
}
BOOST_PYTHON_DECL void from_python(PyObject* p, boost::python::type<void>)
{
if (p != Py_None) {
PyErr_SetString(PyExc_TypeError, "expected argument of type None");
boost::python::throw_argument_error();
}
}
BOOST_PYTHON_DECL const char* from_python(PyObject* p, boost::python::type<const char*>)
{
const char* s = PyString_AsString(p);
if (!s)
boost::python::throw_argument_error();
return s;
}
BOOST_PYTHON_DECL PyObject* to_python(const std::string& s)
{
return PyString_FromStringAndSize(s.data(), s.size());
}
BOOST_PYTHON_DECL std::string from_python(PyObject* p, boost::python::type<std::string>)
{
if (! PyString_Check(p)) {
PyErr_SetString(PyExc_TypeError, "expected a string");
boost::python::throw_argument_error();
}
return std::string(PyString_AsString(p), PyString_Size(p));
}
BOOST_PYTHON_DECL 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;
}
#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
// An optimizer bug prevents these from being inlined.
BOOST_PYTHON_DECL PyObject* to_python(double d)
{
return PyFloat_FromDouble(d);
}
BOOST_PYTHON_DECL PyObject* to_python(float f)
{
return PyFloat_FromDouble(f);
}
#endif
BOOST_PYTHON_END_CONVERSION_NAMESPACE

104
src/cross_module.cpp
View File

@@ -1,104 +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)
*/
#define BOOST_PYTHON_SOURCE
# 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) python::throw_import_error();
return module_dict;
}
}
namespace boost { namespace python {
void BOOST_PYTHON_DECL throw_import_error()
{
throw import_error();
}
void BOOST_PYTHON_DECL throw_export_error()
{
throw export_error();
}
namespace detail
{
BOOST_PYTHON_DECL const char* converters_attribute_name = "__converters__";
BOOST_PYTHON_DECL 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()));
python::throw_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()));
python::throw_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()));
python::throw_import_error();
}
return PyCObject_AsVoidPtr(c_obj.get());
}
BOOST_PYTHON_DECL 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

685
src/extension_class.cpp
View File

@@ -1,685 +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)
#define BOOST_PYTHON_SOURCE
#define BOOST_PYTHON_EXPORT
#include <boost/python/detail/extension_class.hpp>
#include <boost/python/detail/call_object.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 {
BOOST_PYTHON_DECL 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);
boost::python::throw_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;
}
}
BOOST_PYTHON_DECL 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);
return handle_exception(
bind_return(
*r
, bind(operator_dispatcher::create,
ref(*r, ref::increment_count),
ref())))
? -1 : 0;
}
#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

181
src/functions.cpp
View File

@@ -1,181 +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)
#define BOOST_PYTHON_SOURCE
#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

26
src/gen_all.py
View File

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

139
src/gen_arg_tuple_size.py
View File

@@ -1,139 +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
from gen_function import *
import string
header = '''// (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 %d-argument member functions and %d-argument free
// functions by gen_arg_tuple_size.python
'''
_cv_qualifiers = ('', ' const', ' volatile', ' const volatile')
_suffix = {
'': '''
// Metrowerks thinks this creates ambiguities
# if !defined(__MWERKS__) || __MWERKS__ > 0x2406
''', ' const volatile': '''
# endif // __MWERKS__
'''
};
def gen_arg_tuple_size(member_function_args, free_function_args = None):
if free_function_args is None:
free_function_args = member_function_args + 1
return_none = ''';
return detail::none();'''
return (header % (member_function_args, free_function_args)
+ '''
#ifndef ARG_TUPLE_SIZE_DWA20011201_HPP
# define ARG_TUPLE_SIZE_DWA20011201_HPP
# include <boost/python/detail/char_array.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__)
'''
+ gen_functions(
'''template <class R%(, class A%+%)>
struct arg_tuple_size<R (*)(%(A%+%:, %))>
{
BOOST_STATIC_CONSTANT(std::size_t, value = %n);
};
''', free_function_args)
+ '\n'
+ reduce(lambda x,y: x+'\n'+y
, map(
lambda cv: gen_functions(
'''template <class R, class A0%(, class A%+%)>
struct arg_tuple_size<R (A0::*)(%(A%+%:, %))%1>
{
BOOST_STATIC_CONSTANT(std::size_t, value = %+);
};
'''
, member_function_args, cv) + _suffix.get(cv, '')
, _cv_qualifiers))
+
'''# 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
// 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.
'''
+ gen_functions(
'''template <class R%(, class A%+%)>
char_array<%n> arg_tuple_size_helper(R (*)(%(A%+%:, %)));
''', free_function_args)
+ reduce(lambda x,y: x+'\n'+y
, map(
lambda cv: gen_functions(
'''template <class R, class A0%(, class A%+%)>
char_array<%+> arg_tuple_size_helper(R (A0::*)(%(A%+%:, %))%1);
''', member_function_args, cv)
, _cv_qualifiers))
+ '''
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
''')
if __name__ == '__main__':
import sys
if len(sys.argv) == 1:
member_function_args = 5
free_function_args = 6
else:
member_function_args = int(sys.argv[1])
if len(sys.argv) > 2:
free_function_args = int(sys.argv[2])
else:
free_function_args = member_function_args
print gen_arg_tuple_size(member_function_args, free_function_args)

82
src/gen_call.py
View File

@@ -1,82 +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
from gen_function import *
import string
header = '''// 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 %d-argument member functions and %d-argument free
// functions by gen_call.py
#ifndef CALL_DWA20011214_HPP
# define CALL_DWA20011214_HPP
# include <boost/python/detail/returning.hpp>
namespace boost { namespace python {
'''
_cv_qualifiers = ('', ' const', ' volatile', ' const volatile')
def gen_call(member_function_args, free_function_args = None):
if free_function_args is None:
free_function_args = member_function_args + 1
return (header % (member_function_args, free_function_args)
+ gen_functions(
'''template <class R%(, class A%n%)>
inline PyObject* call(R (*f)(%(A%n%:, %)), PyObject* args, PyObject* keywords)
{
return detail::returning<R>::call(f, args, keywords);
}
''', free_function_args)
+
'''// Member functions
'''
+ reduce(lambda x,y: x+y
, map(lambda cv:
gen_functions(
'''template <class R, class A0%(, class A%+%)>
inline PyObject* call(R (A0::*f)(%(A%+%:, %))%1, PyObject* args, PyObject* keywords)
{
return detail::returning<R>::call(f, args, keywords);
}
'''
, member_function_args, cv)
, _cv_qualifiers))
+
'''
}} // namespace boost::python
#endif // CALL_DWA20011214_HPP
''')
if __name__ == '__main__':
import sys
if len(sys.argv) == 1:
member_function_args = 5
free_function_args = 6
else:
member_function_args = int(sys.argv[1])
if len(sys.argv) > 2:
free_function_args = int(sys.argv[2])
else:
free_function_args = member_function_args
print gen_call(member_function_args, free_function_args)

124
src/gen_callback.py
View File

@@ -1,124 +0,0 @@
from gen_function import *
import string
def gen_callback(args):
return (
"""// (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 python callbacks by gen_callback.python
#ifndef CALLBACK_DWA_052100_H_
# define CALLBACK_DWA_052100_H_
# include <boost/python/detail/config.hpp>
# include <boost/python/conversions.hpp>
namespace boost { namespace python {
namespace detail {
template <class T>
inline void callback_adjust_refcount(PyObject*, type<T>) {}
inline void callback_adjust_refcount(PyObject* p, type<PyObject*>)
{ Py_INCREF(p); }
}
// Calling Python from C++
template <class R>
struct callback
{""" % args
+ gen_functions('''
%{ template <%(class A%n%:, %)>
%} static R call_method(PyObject* self, const char* name%(, const A%n& a%n%))
{%(
ref p%n(to_python(a%n));%)
ref result(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(%(O%))")%(,
p%n.get()%)));
detail::callback_adjust_refcount(result.get(), type<R>());
return from_python(result.get(), type<R>());
}
%{ template <%(class A%n%:, %)>
%} static R call(PyObject* self%(, const A%n& a%n%))
{%(
ref p%n(to_python(a%n));%)
ref result(PyEval_CallFunction(self, const_cast<char*>("(%(O%))")%(,
p%n.get()%)));
detail::callback_adjust_refcount(result.get(), type<R>());
return from_python(result.get(), type<R>());
}
''', args)
+
"""};
// This specialization wouldn't be needed, but MSVC6 doesn't correctly allow the following:
// void g();
// void f() { return g(); }
template <>
struct callback<void>
{
"""
+ gen_functions('''
%{ template <%(class A%n%:, %)>
%} static void call_method(PyObject* self, const char* name%(, const A%n& a%n%))
{%(
ref p%n(to_python(a%n));%)
ref result(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(%(O%))")%(,
p%n.get()%)));
}
%{ template <%(class A%n%:, %)>
%} static void call(PyObject* self%(, const A%n& a%n%))
{%(
ref p%n(to_python(a%n));%)
ref result(PyEval_CallFunction(self, const_cast<char*>("(%(O%))")%(,
p%n.get()%)));
}
''', args)
+
"""};
// Make it a compile-time error to try to return a const char* from a virtual
// function. The standard conversion
//
// from_python(PyObject* string, boost::python::type<const char*>)
//
// returns a pointer to the character array which is internal to string. The
// problem with trying to do this in a standard callback function is that the
// Python string would likely be destroyed upon return from the calling function
// (boost::python::callback<const char*>::call[_method]) when its reference count is
// decremented. If you absolutely need to do this and you're sure it's safe (it
// usually isn't), you can use
//
// boost::python::string result(boost::python::callback<boost::python::string>::call[_method](...args...));
// ...result.c_str()... // access the char* array
template <>
struct callback<const char*>
{
// Try hard to generate a readable error message
typedef struct unsafe_since_python_string_may_be_destroyed {} call, call_method;
};
}} // namespace boost::python
#endif // CALLBACK_DWA_052100_H_
""")
if __name__ == '__main__':
import sys
if len(sys.argv) == 1:
args = 5
else:
args = int(sys.argv[1])
print gen_callback(args)

138
src/gen_caller.py
View File

@@ -1,138 +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.
from gen_function import *
import string
header = '''// (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
// The author gratefully acknowleges the support of Dragon Systems, Inc., in
// producing this work.
//
// This file generated for %d-argument member functions and %d-argument free
// functions by gen_caller.python
'''
body_sections = (
'''
#ifndef CALLER_DWA05090_H_
# define CALLER_DWA05090_H_
# include <boost/python/detail/config.hpp>
# include <boost/python/detail/wrap_python.hpp>
# include <boost/config.hpp>
# include <boost/python/detail/signatures.hpp>
# include <boost/python/detail/none.hpp>
namespace boost { namespace python {
// Calling C++ from Python
template <class R>
struct caller
{
''',
'''
''',
''' // Free functions
''',
'''};
template <>
struct caller<void>
{
''',
'''
''',
'''
// Free functions
''',
'''};
}} // namespace boost::python
#endif
''')
#'
member_function = ''' template <class T%(, class A%n%)>
static PyObject* call(%1 (T::*pmf)(%(A%n%:, %))%2, PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
%( PyObject* a%n;
%) if (!PyArg_ParseTuple(args, const_cast<char*>("O%(O%)"), &self%(, &a%n%)))
return 0;
T& target = from_python(self, type<T&>());
%3(target.*pmf)(%(from_python(a%n, type<A%n>())%:,
%))%4
}
'''
free_function = '''%{ template <%(class A%n%:, %)>
%} static PyObject* call(%1 (*f)(%(A%n%:, %)), PyObject* args, PyObject* /* keywords */ ) {
%( PyObject* a%n;
%) if (!PyArg_ParseTuple(args, const_cast<char*>("%(O%)")%(, &a%n%)))
return 0;
%2f(%(from_python(a%n, type<A%n>())%:,
%))%3
}
'''
def gen_caller(member_function_args, free_function_args = None):
if free_function_args is None:
free_function_args = member_function_args + 1
return_none = ''';
return detail::none();'''
return (header % (member_function_args, free_function_args)
+ body_sections[0]
+ gen_functions(member_function, member_function_args,
'R', '', 'return to_python(', ');')
+ body_sections[1]
+ gen_functions(member_function, member_function_args,
'R', ' const', 'return to_python(', ');')
+ body_sections[2]
+ gen_functions(free_function, free_function_args,
'R', 'return to_python(', ');')
+ body_sections[3]
# specialized part for void return values begins here
+ gen_functions(member_function, member_function_args,
'void', '', '', return_none)
+ body_sections[4]
+ gen_functions(member_function, member_function_args,
'void', ' const', '', return_none)
+ body_sections[5]
+ gen_functions(free_function, free_function_args,
'void', '', return_none)
+ body_sections[6]
)
if __name__ == '__main__':
import sys
if len(sys.argv) == 1:
member_function_args = 5
free_function_args = 6
else:
member_function_args = int(sys.argv[1])
if len(sys.argv) > 2:
free_function_args = int(sys.argv[2])
else:
free_function_args = member_function_args
print gen_caller(member_function_args, free_function_args)

948
src/gen_extclass.py
View File

@@ -1,948 +0,0 @@
from gen_function import *
import string
def gen_extclass(args):
return (
"""// (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.
//
// The author gratefully acknowleges the support of Dragon Systems, Inc., in
// producing this work.
//
// This file automatically generated for %d-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;
class BOOST_PYTHON_DECL 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;
};
} // namespace detail
# ifndef BOOST_PYTHON_NO_TEMPLATE_EXPORT
BOOST_PYTHON_EXPORT_TEMPLATE_CLASS class_t<detail::extension_instance>;
BOOST_PYTHON_EXPORT_TEMPLATE_CLASS meta_class<detail::extension_instance>;
# endif
namespace detail {
BOOST_PYTHON_DECL meta_class<extension_instance>* extension_meta_class();
BOOST_PYTHON_DECL extension_instance* get_extension_instance(PyObject* p);
BOOST_PYTHON_DECL void report_missing_instance_data(extension_instance*, class_t<extension_instance>*, const std::type_info&);
BOOST_PYTHON_DECL void report_missing_ptr_data(extension_instance*, class_t<extension_instance>*, const std::type_info&);
BOOST_PYTHON_DECL void report_missing_class_object(const std::type_info&);
BOOST_PYTHON_DECL 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 BOOST_PYTHON_DECL 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 BOOST_PYTHON_DECL 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));
boost::python::throw_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));
boost::python::throw_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 BOOST_PYTHON_DECL 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
""" % args
+ gen_function(
""" template <%(class A%n%:, %)>
inline void def(constructor<%(A%n%:, %)>)
// The following incantation builds a signature1, signature2,... object. It
// should _all_ get optimized away.
{ add_constructor(
%(prepend(type<A%n>::id(),
%) signature0()%()%));
}
""", args)
+
"""
// 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:"""
+ gen_functions("""%{
template <%(class A%n%:, %)>%}
held_instance(PyObject*%(, A%n% a%n%)) : Held(
%(typename unwrap_parameter<A%n>::type(a%n)%:
, %)) {}""", args)
+ """
};
// Abstract base class for all obj holders. Base for template class
// instance_holder<>, below.
class BOOST_PYTHON_DECL 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;
};
//
// 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_
""")
if __name__ == '__main__':
import sys
if len(sys.argv) == 1:
args = 5
else:
args = int(sys.argv[1])
print gen_extclass(args)

243
src/gen_function.py
View File

@@ -1,243 +0,0 @@
r"""
>>> template = ''' template <class T%(, class A%+%)>
... static PyObject* call( %1(T::*pmf)(%(A%+%:, %))%2, PyObject* args, PyObject* ) {
... PyObject* self;
... %( PyObject* a%+;
... %) if (!PyArg_ParseTuple(args, const_cast<char*>("O%(O%)"), &self%(, &a%+%)))
... return 0;
... T& target = from_python(self, type<T&>());
... %3to_python((target.*pmf)(%(
... from_python(a%+, type<A%+>())%:,%)
... ));%4
... }'''
>>> print gen_function(template, 0, 'R ', '', 'return ', '')
template <class T>
static PyObject* call( R (T::*pmf)(), PyObject* args, PyObject* ) {
PyObject* self;
if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
return 0;
T& target = from_python(self, type<T&>());
return to_python((target.*pmf)(
));
}
>>> print gen_function(template, 2, 'R ', '', 'return ', '')
template <class T, class A1, class A2>
static PyObject* call( R (T::*pmf)(A1, A2), PyObject* args, PyObject* ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &self, &a1, &a2))
return 0;
T& target = from_python(self, type<T&>());
return to_python((target.*pmf)(
from_python(a1, type<A1>()),
from_python(a2, type<A2>())
));
}
>>> print gen_function(template, 3, 'void ', ' const', '', '\n'+8*' ' + 'return none();')
template <class T, class A1, class A2, class A3>
static PyObject* call( void (T::*pmf)(A1, A2, A3) const, PyObject* args, PyObject* ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &self, &a1, &a2, &a3))
return 0;
T& target = from_python(self, type<T&>());
to_python((target.*pmf)(
from_python(a1, type<A1>()),
from_python(a2, type<A2>()),
from_python(a3, type<A3>())
));
return none();
}
"""
import string
def _find(s, sub, start=0, end=None):
"""Just like string.find, except it returns end or len(s) when not found.
"""
if end == None:
end = len(s)
pos = string.find(s, sub, start, end)
if pos < 0:
return end
else:
return pos
def _raise_no_argument(key, n, args):
raise IndexError(str(key) + " extra arg(s) not passed to gen_function")
def _gen_common_key(key, n, args, fill = _raise_no_argument):
# import sys
# print >> sys.stderr, "_gen_common_key(", repr(key), ",", repr(n), ',', repr(args), ',', fill, ')'
# sys.stderr.flush()
if len(key) > 0 and key in '123456789':
index = int(key) - 1;
if index >= len(args):
return fill(key, n, args)
arg = args[index]
if callable(arg):
return str(arg(key, n, args))
else:
return str(arg)
elif key in ('x','n','-','+'):
return str(n + {'-':-1,'+':+1,'x':0,'n':0}[key])
else:
return key
def _gen_arg(template, n, args, fill = _raise_no_argument):
result = ''
i = 0
while i < len(template): # until the template is consumed
# consume everything up to the first '%'
delimiter_pos = _find(template, '%', i)
result = result + template[i:delimiter_pos]
# The start position of whatever comes after the '%'+key
start = delimiter_pos + 2
key = template[start - 1 : start] # the key character. If there were no
# '%'s left, key will be empty
if 0 and key == 'n':
result = result + `n`
else:
result = result + _gen_common_key(key, n, args, fill)
i = start
return result
def gen_function(template, n, *args, **keywords):
r"""gen_function(template, n, [args...] ) -> string
Generate a function declaration based on the given template.
Sections of the template between '%(', '%)' pairs are repeated n times. If '%:'
appears in the middle, it denotes the beginning of a '%'.
Sections of the template between '%{', '%}' pairs are ommitted if n == 0.
%n is transformed into the string representation of 1..n for each
repetition within %(...%). Elsewhere, %n is transformed into the
string representation of n
%- is transformed into the string representation of 0..n-1 for
each repetition within %(...%). Elsewhere, %- is transformed into the
string representation of n-1.
%+ is transformed into the string representation of 2..n+1 for
each repetition within %(...%). Elsewhere, %- is transformed into the
string representation of n+1.
%x is always transformed into the string representation of n
%z, where z is a digit, selects the corresponding additional
argument. If that argument is callable, it is called with three
arguments:
key - the string representation of 'z'
n - the iteration number
args - a tuple consisting of all the additional arguments to
this function
otherwise, the selected argument is converted to a string representation
for example,
>>> gen_function('%1 abc%x(%(int a%n%:, %));%{ // all args are ints%}', 2, 'void')
'void abc2(int a0, int a1); // all args are ints'
>>> gen_function('%1 abc(%(int a%n%:, %));%{ // all args are ints%}', 0, 'x')
'x abc();'
>>> gen_function('%1 abc(%(int a%n%:, %));%{ // all args are ints%}', 0, lambda key, n, args: 'abcd'[n])
'a abc();'
>>> gen_function('%2 %1 abc(%(int a%n%:, %));%{ // all args are ints%}', 0, 'x', fill = lambda key, n, args: 'const')
'const x abc();'
>>> gen_function('abc%[k%:v%]', 0, fill = lambda key, n, args, value = None: '<' + key + ',' + value + '>')
'abc<k,v>'
"""
expand = (lambda s, n = n:
apply(gen_function, (s, n) + args, keywords))
fill = keywords.get('fill', _raise_no_argument);
result = ''
i = 0
while i < len(template): # until the template is consumed
# consume everything up to the first '%'
delimiter_pos = _find(template, '%', i)
result = result + template[i:delimiter_pos]
# The start position of whatever comes after the '%'+key
start = delimiter_pos + 2
key = template[start - 1 : start] # the key character. If there were no
# '%'s left, key will be empty
pairs = { '(':')', '{':'}', '[':']' }
if key in pairs.keys():
end = string.find(template, '%' + pairs[key], start)
assert end >= 0, "Matching '" + '%' + pairs[key] +"' not found!"
delimiter_pos = end
if key == '{':
if n > 0:
result = result + expand(template[start:end])
else:
separator_pos = _find(template, '%:', start, end)
remainder = template[separator_pos+2 : end]
if key == '(':
for x in range(n):
iteration = expand(
template[start:separator_pos], x)
result = result + expand(iteration, x)
if x != n - 1:
result = result + expand(remainder, x)
else:
function_result = fill(
template[start:separator_pos], n, args, value = remainder)
result = result + expand(function_result)
else:
result = result + expand(_gen_common_key(key, n, args, fill))
i = delimiter_pos + 2
return result
def gen_functions(template, n, *args, **keywords):
r"""gen_functions(template, n, [args...]) -> string
Call gen_function repeatedly with from 0..n and the given optional
arguments.
>>> print gen_functions('%1 abc(%(int a%n%:, %));%{ // all args are ints%}\n', 2, 'void'),
void abc();
void abc(int a0); // all args are ints
void abc(int a0, int a1); // all args are ints
"""
fill = keywords.get('fill', _raise_no_argument);
result = ''
for x in range(n + 1):
result = result + apply(gen_function, (template, x) + args, keywords)
return result
if __name__ == '__main__':
import doctest
import sys
doctest.testmod(sys.modules.get(__name__))

215
src/gen_init_function.py
View File

@@ -1,215 +0,0 @@
from gen_function import *
import string
def gen_init_function(args):
return (
"""// (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.
//
// 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;
};
struct reference_parameter_base {};
template <class T>
class reference_parameter
: public reference_parameter_base
{
public:
typedef typename parameter_traits<T>::const_reference const_reference;
reference_parameter(const_reference value)
: value(value) {}
operator const_reference() { return value; }
private:
const_reference value;
};
# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template <class T>
struct unwrap_parameter
{
typedef typename boost::add_reference<T>::type type;
};
template <class T>
struct unwrap_parameter<reference_parameter<T> >
{
typedef typename reference_parameter<T>::const_reference type;
};
# else
template <bool is_wrapped>
struct unwrap_parameter_helper
{
template <class T>
struct apply
{
typedef typename T::const_reference type;
};
};
template <>
struct unwrap_parameter_helper<false>
{
template <class T>
struct apply
{
typedef typename add_reference<T>::type type;
};
};
template <class T>
struct unwrap_parameter
{
BOOST_STATIC_CONSTANT(
bool, is_wrapped = (is_base_and_derived<T,reference_parameter_base>::value));
typedef typename unwrap_parameter_helper<
is_wrapped
>::template apply<T>::type type;
};
# endif
class extension_instance;
class instance_holder_base;
class init;
"""
+ gen_functions('template <class T%(, class A%n%)> struct init%x;\n', args)
+ """
template <class T>
struct init_function
{
""" + gen_functions("""%{
template <%(class A%n%:, %)>
%} static init* create(signature%x%{<%(A%n%:, %)>%}) {
return new init%x<T%(,
typename detail::parameter_traits<A%n>::const_reference%)>;
}
""", args)+"""};
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;
};
""" + gen_functions("""
template <class T%(, class A%n%)>
struct init%x : init
{
virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
{
%(PyObject* a%n;
%)if (!PyArg_ParseTuple(args, const_cast<char*>("%(O%)")%(, &a%n%)))
throw_argument_error();
return new T(self%(,
boost::python::detail::reference_parameter<A%n>(from_python(a%n, type<A%n>()))%)
);
}
const char* description() const
{ return typeid(void (*)(T&%(, A%n%%))).name(); }
};""", args) + """
}}} // namespace boost::python::detail
#endif // INIT_FUNCTION_DWA052000_H_
""")
if __name__ == '__main__':
import sys
if len(sys.argv) == 1:
args = 5
else:
args = int(sys.argv[1])
print gen_init_function(args)

776
src/gen_py_api.py
View File

@@ -1,776 +0,0 @@
# Copyright David Hawkes 2002.
# Permission is hereby granted to copy, use and modify this software
# for any purpose, including commercial distribution, provided this
# copyright notice is not removed. No warranty WHATSOEVER is provided with this
# software. Any user(s) accepts this software "as is" and as such they will not
# bind the author(s) to any claim of suitabilty for any purpose.
# Build python API wrappers for boost python
import re
API_List = [
'PyObject*{new} abs{direct}(int{template})',
'PyObject*{new} abs{direct}(PyObject*)',
'PyObject*{new} abs{direct}(short)',
'PyObject*{new} abs{direct}(int)',
'PyObject*{new} abs{direct}(long)',
'PyObject*{new} abs{direct}(double const &)',
'PyObject*{new,err=NULL} PyObject_CallObject{decl=apply}(PyObject*,PyObject*)',
'PyObject*{new,err=NULL} PyObject_Call{decl=apply}(PyObject*,PyObject*,PyObject*)',
'bool PyCallable_Check{decl=callable}(PyObject*)',
'PyObject*{new} chr{direct}(int{template})',
'PyObject*{new} chr{direct}(PyObject*)',
'PyObject*{new} chr{direct}(short)',
'PyObject*{new} chr{direct}(int)',
'PyObject*{new} chr{direct}(long)',
'int{err=-1} PyObject_Cmp{decl=cmp}(PyObject*{template},PyObject*{template},int{result})',
'int{err=-1} PyObject_Cmp{decl=cmp}(PyObject*,PyObject*,int{result})',
'PyObject*{new} coerce{direct}(PyObject*,PyObject*)',
'PyObject*{new} compile{direct}(PyObject*,PyObject*,PyObject*)',
'PyObject*{new} compile{direct}(const char*,const char*,const char*)',
'PyObject*{new} compile{direct}(PyObject*,PyObject*,PyObject*,PyObject*)',
'PyObject*{new} compile{direct}(const char*,const char*,const char*,int)',
'PyObject*{new} compile{direct}(PyObject*,PyObject*,PyObject*,PyObject*,PyObject*)',
'PyObject*{new} compile{direct}(const char*,const char*,const char*,int,int)',
'PyObject*{new} complex{direct}(int{template})',
'PyObject*{new} complex{direct}(PyObject*)',
'PyObject*{new} complex{direct}(double const&)',
'PyObject*{new} complex{direct}(int{template},int{template})',
'PyObject*{new} complex{direct}(PyObject*,PyObject*)',
'PyObject*{new} complex{direct}(double const&,double const&)',
'PyObject*{new} dict{direct}()',
'PyObject*{new} dict{direct}(PyObject*)',
'PyObject*{new} PyObject_Dir{decl=dir}(PyObject*{value=NULL})',
'PyObject*{new} PyObject_Dir{decl=dir}(PyObject*)',
'PyObject*{new} divmod{direct}(int{template},int{template})',
'PyObject*{new} divmod{direct}(PyObject*,PyObject*)',
'PyObject*{new} divmod{direct}(int,int)',
'PyObject*{new} divmod{direct}(long,long)',
'PyObject*{new} divmod{direct}(double const&,double const&)',
'PyObject*{new} PyRun_String{decl=eval}(char*{const},int{value=Py_eval_input},PyObject*{value=globals().ptr()},PyObject*{value=globals().ptr()})',
'PyObject*{new} PyRun_String{decl=eval}(char*{const},int{value=Py_eval_input},PyObject*,PyObject*{value=globals().ptr()})',
'PyObject*{new} PyRun_String{decl=eval}(char*{const},int{value=Py_eval_input},PyObject*,PyObject*)',
'PyObject*{new} PyRun_String{decl=exec}(char*{const},int{value=Py_file_input},PyObject*{value=globals().ptr()},PyObject*{value=globals().ptr()})',
'PyObject*{new} PyRun_String{decl=exec}(char*{const},int{value=Py_file_input},PyObject*,PyObject*{value=globals().ptr()})',
'PyObject*{new} PyRun_String{decl=exec}(char*{const},int{value=Py_file_input},PyObject*,PyObject*)',
'PyObject*{new} execfile{direct}(PyObject*)',
'PyObject*{new} execfile{direct}(PyObject*,PyObject*)',
'PyObject*{new} execfile{direct}(PyObject*,PyObject*,PyObject*)',
'PyObject*{new} file{direct}(PyObject*)',
'PyObject*{new} file{direct}(const char*)',
'PyObject*{new} file{direct}(PyObject*,PyObject*)',
'PyObject*{new} file{direct}(const char*,const char*)',
'PyObject*{new} file{direct}(PyObject*,PyObject*,PyObject*)',
'PyObject*{new} file{direct}(const char*,const char*,int)',
'PyObject*{new} filter{direct}(PyObject*,PyObject*)',
'PyObject*{new} float{direct,decl=float_}(PyObject*)',
'PyObject*{new} float{direct,decl=float_}(const char*)',
'PyObject*{new} float{direct,decl=float_}(double const&)',
'PyObject*{new} getattr{direct}(PyObject*,PyObject*,PyObject*)',
'PyObject*{new} getattr{direct}(PyObject*,const char *,PyObject*)',
'PyObject*{borrowed,err=NULL} PyModule_GetDict{decl=globals}(PyObject*{value=PyImport_AddModule("__main__")})',
'bool PyObject_HasAttr{decl=hasattr}(PyObject*,PyObject*)',
'bool PyObject_HasAttrString{decl=hasattr}(PyObject*,char*{const})',
'long{err=-1} PyObject_Hash{decl=hash}(PyObject*)',
'PyObject*{new} hex{direct}(int{template})',
'PyObject*{new} hex{direct}(PyObject*)',
'PyObject*{new} hex{direct}(char)',
'PyObject*{new} hex{direct}(short)',
'PyObject*{new} hex{direct}(int)',
'PyObject*{new} hex{direct}(long)',
'long id{direct}(PyObject*)',
'PyObject*{new} input{direct}()',
'PyObject*{new} input{direct}(PyObject*)',
'PyObject*{new} input{direct}(const char*)',
'PyObject*{new} int{direct,decl=int_}(PyObject*)',
'PyObject*{new} int{direct,decl=int_}(long)',
'PyObject*{new} int{direct,decl=int_}(const char*)',
'PyObject*{new} intern{direct}(PyObject*)',
'PyObject*{new} intern{direct}(const char*)',
'bool PyObject_IsInstance{decl=isinstance}(PyObject*,PyObject*)',
'bool PyObject_IsSubclass{decl=issubclass}(PyObject*,PyObject*)',
'PyObject*{new} PyObject_GetIter{decl=iter}(PyObject*)',
'PyObject*{new} iter{direct}(PyObject*,PyObject*)',
'long{err=-1} PyObject_Length{decl=len}(PyObject*)',
'PyObject*{new} list{direct}()',
'PyObject*{new} list{direct}(PyObject*)',
'PyObject*{new} long{direct,decl=long_}(PyObject*)',
'PyObject*{new} long{direct,decl=long_}(long)',
'PyObject*{new} long{direct,decl=long_}(const char*)',
'PyObject*{new} map{direct,argrepeat}(PyObject*)',
'PyObject*{new} max{direct,argrepeat}(PyObject*{template})',
'PyObject*{new} max{direct,argrepeat}(PyObject*)',
'PyObject*{new} min{direct,argrepeat}(PyObject*{template})',
'PyObject*{new} min{direct,argrepeat}(PyObject*)',
'PyObject*{new} oct{direct}(int{template})',
'PyObject*{new} oct{direct}(PyObject*)',
'PyObject*{new} oct{direct}(char)',
'PyObject*{new} oct{direct}(short)',
'PyObject*{new} oct{direct}(int)',
'PyObject*{new} oct{direct}(long)',
'PyObject*{new} open{direct}(PyObject*)',
'PyObject*{new} open{direct}(const char*)',
'PyObject*{new} open{direct}(PyObject*,PyObject*)',
'PyObject*{new} open{direct}(const char*,const char*)',
'PyObject*{new} open{direct}(PyObject*,PyObject*,PyObject*)',
'PyObject*{new} open{direct}(const char*,const char*,int)',
'long ord{direct}(PyObject*)',
'long ord{direct}(const char*)',
'PyObject*{new} pow{direct}(int{template},int{template})',
'PyObject*{new} pow{direct}(PyObject*,PyObject*)',
'PyObject*{new} pow{direct}(double const&,double const&)',
'PyObject*{new} pow{direct}(double const&,double const&,double const&)',
'PyObject*{new} print{direct,statement=print _1,argrepeat}(int{template})',
'PyObject*{new} print{direct,statement=print _1,argrepeat}(PyObject*)',
'PyObject*{new} print{decl=print_file,direct,statement="print >>_1, _2",argrepeat}(PyObject*,int{template})',
'PyObject*{new} print{decl=print_file,direct,statement="print >>_1, _2",argrepeat}(PyObject*,PyObject*)',
'PyObject*{new} range{direct}(int{template})',
'PyObject*{new} range{direct}(PyObject*)',
'PyObject*{new} range{direct}(int)',
'PyObject*{new} range{direct}(int{template},int{template})',
'PyObject*{new} range{direct}(PyObject*,PyObject*)',
'PyObject*{new} range{direct}(int,int)',
'PyObject*{new} range{direct}(int{template},int{template},int{template})',
'PyObject*{new} range{direct}(PyObject*,PyObject*,PyObject*)',
'PyObject*{new} range{direct}(int,int,int)',
'PyObject*{new} raw_input{direct}()',
'PyObject*{new} raw_input{direct}(PyObject*)',
'PyObject*{new} raw_input{direct}(const char*)',
'PyObject*{new} reduce{direct}(PyObject*,PyObject*)',
'PyObject*{new} reduce{direct}(PyObject*,PyObject*,PyObject*)',
'PyObject*{new,err=NULL} PyImport_ReloadModule{decl=reload}(PyObject*)',
'PyObject*{new} PyObject_Repr{decl=repr}(PyObject*)',
'PyObject*{new} round{direct}(int{template})',
'PyObject*{new} round{direct}(PyObject*)',
'PyObject*{new} round{direct}(double const&)',
'PyObject*{new} round{direct}(int{template},int{template})',
'PyObject*{new} round{direct}(PyObject*,PyObject*)',
'PyObject*{new} round{direct}(double const&,double const&)',
'PyObject*{new} slice{direct}(int{template})',
'PyObject*{new} slice{direct}(PyObject*)',
'PyObject*{new} slice{direct}(int)',
'PyObject*{new} slice{direct}(int{template},int{template})',
'PyObject*{new} slice{direct}(PyObject*,PyObject*)',
'PyObject*{new} slice{direct}(int,int)',
'PyObject*{new} slice{direct}(int{template},int{template},int{template})',
'PyObject*{new} slice{direct}(PyObject*,PyObject*,PyObject*)',
'PyObject*{new} slice{direct}(int,int,int)',
'PyObject*{new} PyObject_Str{decl=str}(PyObject*)',
'PyObject*{new} tuple{direct}()',
'PyObject*{new} tuple{direct}(PyObject*)',
'PyObject*{new,err=NULL} PyObject_Type{decl=type_}(PyObject*)',
'PyObject*{new} unichr{direct}(int{template})',
'PyObject*{new} unichr{direct}(PyObject*)',
'PyObject*{new} unichr{direct}(short)',
'PyObject*{new} unichr{direct}(int)',
'PyObject*{new} unichr{direct}(long)',
'PyObject*{new} PyObject_Unicode{decl=unicode}(PyObject*)',
'PyObject*{new} unicode{direct}(PyObject*,PyObject*)',
'PyObject*{new} unicode{direct}(PyObject*,const char*)',
'PyObject*{new} unicode{direct}(PyObject*,PyObject*,PyObject*)',
'PyObject*{new} unicode{direct}(PyObject*,const char*,const char*)',
'PyObject*{new} vars{direct}()',
'PyObject*{new} vars{direct}(PyObject*)',
'PyObject*{new} xrange{direct}(int{template})',
'PyObject*{new} xrange{direct}(PyObject*)',
'PyObject*{new} xrange{direct}(int)',
'PyObject*{new} xrange{direct}(int{template},int{template})',
'PyObject*{new} xrange{direct}(PyObject*,PyObject*)',
'PyObject*{new} xrange{direct}(int,int)',
'PyObject*{new} xrange{direct}(int{template},int{template},int{template})',
'PyObject*{new} xrange{direct}(PyObject*,PyObject*,PyObject*)',
'PyObject*{new} xrange{direct}(int,int,int)',
'PyObject*{new} zip{direct,argrepeat}(PyObject*)',
'PyObject*{new,err=NULL} Py_CompileString{decl=compile_string}(char*{const},char*{const},int)',
'int{err=-1} PyImport_AppendInittab{decl=import_append_inittab}(char*{const},void(*arg)(void))',
'PyObject*{borrowed,err=NULL} PyImport_AddModule{decl=import_add_module}(char*{const})',
'PyObject*{borrowed,err=NULL} PyImport_GetModuleDict{decl=import_get_module_dict}()',
'PyObject*{new,err=NULL} PyImport_Import{decl=import_import}(PyObject*)',
'PyObject*{new,err=NULL} PyImport_Import{decl=import_import}(const char*{object})',
'PyObject*{new,err=NULL} PyImport_ImportModule{decl=import_import_module}(char*{const})',
'PyObject*{new,err=NULL} PyImport_ImportModuleEx{decl=import_import_module_ex}(char*{const},PyObject*,PyObject*,PyObject*)',
'PyObject*{borrowed,err=NULL} PyModule_GetDict{decl=module_get_dict}(PyObject*)',
'int{err=-1} PyObject_Print{decl=object_print}(PyObject*,FILE*,int)',
'PyObject*{new,err=NULL} PyRun_File{decl=run_file}(FILE*,char*{const},int,PyObject*,PyObject*)',
'int{err=-1} PyRun_SimpleFile{decl=run_simple_file}(FILE*,char*{const})',
'int{err=-1} PyRun_SimpleString{decl=run_simple_string}(char*{const})',
'PyObject*{new,err=NULL} PyRun_String{decl=run_string}(char*{const},int,PyObject*,PyObject*)',
'PyObject*{new} call_statement{statement,direct}(const char*{statement})',
'PyObject*{new} call_statement{statement,direct}(const char*{statement},call_dict_usage{use_gd})',
'PyObject*{new} call_statement{argrepeat,statement,direct}(const char*{statement},int{template})',
'PyObject*{new} call_statement{argrepeat,statement,direct}(const char*{statement},PyObject*)',
'PyObject*{new} call_statement{argrepeat,statement,direct}(const char*{statement},call_dict_usage{use_gd},int{template})',
'PyObject*{new} call_statement{argrepeat,statement,direct}(const char*{statement},call_dict_usage{use_gd},PyObject*)',
]
DeclFile = '../../../boost/python/py_interface.hpp'
ImplFile = 'py_interface.cpp'
DeclFileHeader = '''\
// Automatically generated from py_api_gen.py
#ifndef PY_INTERFACE_HPP
#define PY_INTERFACE_HPP
#include <boost/python/object.hpp>
#include <boost/python/arg_from_python.hpp>
namespace boost { namespace python { namespace api {
enum call_dict_usage { use_new_dict, use_local_dict, use_global_dict };
namespace api_detail {
BOOST_PYTHON_DECL object get_func(const char* name);
BOOST_PYTHON_DECL object call_statement(const char *stmt, int n, ...);
BOOST_PYTHON_DECL object call_statement_du(const char *stmt, call_dict_usage cdu, int n, ...);
template<class A>
struct get_arg
{
get_arg(A const &a) : h(a) {}
object h;
operator object const& () { return h; }
operator object const* () { return &h; }
};
template<>
struct get_arg<object>
{
get_arg(object const &a) : h(a) {}
object const &h;
operator object const& () { return h; }
operator object const* () { return &h; }
};
template<>
struct get_arg<PyObject*>
{
get_arg(PyObject* a) : h((python::detail::borrowed_reference)a) {}
object h;
operator object const& () { return h; }
operator object const* () { return &h; }
};
}
BOOST_PYTHON_DECL object locals();
'''
DeclFileTrailer = '''\
}}}
#endif // PY_INTERFACE_HPP
'''
ImplFileHeader = '''\
// Automatically generated from py_api_gen.py
#include <boost/python/py_interface.hpp>
namespace boost { namespace python { namespace api {
namespace api_detail {
BOOST_PYTHON_DECL object get_func(const char* name) {
object __builtin__((python::detail::borrowed_reference)::PyImport_AddModule(const_cast<char *>("__builtin__")));
return object(__builtin__.attr(name));
}
inline handle<> get_current_frame()
{
return handle<>(allow_null(borrowed((PyObject*)(PyThreadState_Get()->frame))));
}
inline object get_global_dict(call_dict_usage cdu, handle<> const& frame)
{
if(frame.get())
return object(object(frame).attr("f_globals"));
else
return api::globals();
}
object get_local_dict(call_dict_usage cdu, handle<> const& frame, object const& global_dict)
{
switch(cdu) {
case use_new_dict:
return api::dict();
case use_global_dict:
return global_dict;
default:
if(frame.get())
return object(object(frame).attr("f_locals"));
else
return api::dict();
}
}
inline object call_statement(const char *stmt, object const& global_dict, object& local_dict)
{
local_dict["_0"] = object((python::detail::borrowed_reference)Py_None);
api::run_string(stmt, Py_file_input, global_dict, local_dict);
return object(local_dict["_0"]);
}
object call_statement(const char *stmt)
{
handle<> frame(get_current_frame());
if(frame.get()) {
object f(frame);
object gd(f.attr("f_globals"));
object ld(f.attr("f_locals"));
return call_statement(stmt, gd, ld);
} else {
object gd(api::globals());
object ld(api::dict());
return call_statement(stmt, gd, ld);
}
}
object call_statement_du(const char *stmt, call_dict_usage cdu)
{
handle<> frame(get_current_frame());
object gd(get_global_dict(cdu, frame));
return call_statement(stmt, gd, get_local_dict(cdu, frame, gd));
}
inline object call_statement(const char *stmt, object const& global_dict, object& local_dict, int n, va_list mk)
{
static const char *(idx[]) = { "_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_9", "_10" };
local_dict["_0"] = object((python::detail::borrowed_reference)Py_None);
for(int i = 0; i < n; ++i)
{
object const* p_arg = va_arg(mk, object const*);
object const& arg = *p_arg;
if(i < (int) (sizeof(idx) / sizeof(idx[0])))
local_dict[idx[i]] = arg;
else {
local_dict[object("_") + object((python::detail::new_reference)PyObject_Str(object(i + 1).ptr()))] = arg;
}
}
va_end(mk);
api::run_string(stmt, Py_file_input, global_dict, local_dict);
return object(local_dict["_0"]);
}
BOOST_PYTHON_DECL object call_statement(const char *stmt, int n, ...)
{
va_list mk;
va_start(mk, n);
handle<> frame(get_current_frame());
if(frame.get()) {
object f(frame);
object gd(f.attr("f_globals"));
object ld(f.attr("f_locals"));
return call_statement(stmt, gd, ld, n, mk);
} else {
object gd(api::globals());
object ld(api::dict());
return call_statement(stmt, gd, ld, n, mk);
}
}
BOOST_PYTHON_DECL object call_statement_du(const char *stmt, call_dict_usage cdu, int n, ...)
{
handle<> frame(get_current_frame());
object gd(get_global_dict(cdu, frame));
va_list mk;
va_start(mk, n);
return call_statement(stmt, gd, get_local_dict(cdu, frame, gd), n, mk);
}
}
BOOST_PYTHON_DECL object locals()
{
handle<> frame(api_detail::get_current_frame());
if(frame.get())
return object(object(frame).attr("f_locals"));
else
return api::dict();
}
'''
ImplFileTrailer = '''\
}}}
'''
def SplitOutList(l):
vals_list = []
if l == None:
return vals_list
vals_list = re.findall(r'((?:[^,{}]|(?:{[^{}]*}))+),?\s*', l)
return vals_list
def SplitOutListDict(l):
vals_dict = {}
if l == None:
return vals_dict
vals = re.findall(r'((?:"[^"]+"|[^,"]+)+)\s*,?', l)
for val in vals:
m = re.match(r'(?P<aname>[^\s=]+)\s*(=\s*(?P<qt>"?)(?P<aval>.+)(?P=qt))?', val).groupdict()
vals_dict[m['aname']] = m['aval']
return vals_dict
def SplitOutAttrs(a):
soa = {}
m = re.match(r'(?P<name>[^{]+)({(?P<attrs>[^}]+)})?', a).groupdict()
soa['name'] = m['name']
soa.update(SplitOutListDict(m['attrs']))
return soa
def is_object(name):
if re.match(r'PyObject\s*\*', name['name']):
return 1
return 0
def is_arg_really_const(arg):
return arg.has_key('const')
def get_actual_rtn_type(rtn, args):
i = 0
for a in args:
if a.has_key('result'):
true_rtn = dict(rtn)
true_rtn['name'] = a['name']
true_rtn['arg_number'] = i
return true_rtn
i += 1
return rtn
def is_template(name):
return name.has_key('template')
def decl_func_arg(arg, p):
if arg.has_key('value'):
return ''
elif arg.has_key('result'):
return ''
elif is_object(arg):
if is_template(arg):
sn = str(p)
return 'A' + sn +' const& a' + sn
else:
return 'object const& a' + str(p)
elif is_arg_really_const(arg):
return 'const ' + arg['name'] + ' a' + str(p)
elif re.search(r'arg', arg['name']):
return re.sub(r'arg', 'a' + str(p), arg['name'])
else:
if is_template(arg):
sn = str(p)
return 'A' + sn +' const& a' + sn
else:
return arg['name'] + ' a' + str(p)
def decl_func_args(name, args):
if not len(args):
return ''
d_args = reduce(lambda x,y : x + (y and (', ' + y) or ''), map(decl_func_arg, args, xrange(len(args))))
return d_args
def call_func_arg(arg, p):
if arg.has_key('value'):
return arg['value']
elif arg.has_key('result'):
return '&rslt'
elif arg.has_key('template'):
sn = str(p)
return 'api_detail::get_arg<A%s>(a%s)' % (sn, sn)
elif arg.has_key('object'):
return 'object(a%s).ptr()' % str(p)
elif is_object(arg):
return 'a' + str(p) + '.ptr()'
elif is_arg_really_const(arg):
return 'const_cast<%s>(%s)' % (arg['name'], 'a' + str(p))
else:
return 'a' + str(p)
def call_func_args(args):
if not len(args):
return ''
d_args = reduce(lambda x,y : x + (y and ((x and ', ' or '') + y) or ''), map(call_func_arg, args, xrange(len(args))))
return d_args
def call_func(name, args):
return '::%s(%s)' % (name['name'], call_func_args(args))
def call_func_direct_arg(arg, p):
if arg.has_key('use_gd'):
return ''
elif arg.has_key('statement'):
return ''
elif arg.has_key('value'):
return arg['value']
elif arg.has_key('template'):
sn = str(p)
if arg.has_key('addr'):
return '(object const*)api_detail::get_arg<A%s>(a%s)' % (sn, sn)
else:
return 'api_detail::get_arg<A%s>(a%s)' % (sn, sn)
elif is_object(arg):
if arg.has_key('addr'):
return '&a' + str(p)
else:
return 'a' + str(p)
else:
if arg.has_key('addr'):
return '&object(a%s)' % str(p)
else:
return 'object(a%s)' % str(p)
def call_func_direct_args(args):
if not len(args):
return ''
d_args = reduce(lambda x,y : x + (y and ((x and ', ' or '') + y) or ''), map(call_func_direct_arg, args, xrange(len(args))))
return d_args
def get_statement_arg(args):
i = 0
for arg in args:
if arg.has_key('statement'):
return i
i = i + 1
return -1
def get_use_gd_arg(args):
i = 0
for arg in args:
if arg.has_key('use_gd'):
return i
i = i + 1
return -1
def call_func_direct(name, args):
if name.has_key('statement'):
na = len(args)
ugd = get_use_gd_arg(args)
sa = get_statement_arg(args)
if ugd >= 0:
ugd = 'a' + str(ugd)
na = na - 1
else:
if (sa < 0) and (na > 0):
ugd = 'use_new_dict'
else:
ugd = None
if sa >= 0:
na = na - 1
if na > 0:
if ugd:
return 'api_detail::call_statement_du(%s, %s, %s, %s)' % ('a' + str(sa), ugd, na, call_func_direct_args(args))
else:
return 'api_detail::call_statement(%s, %s, %s)' % ('a' + str(sa), na, call_func_direct_args(args))
else:
if ugd:
return 'api_detail::call_statement_du(%s, %s)' % ('a' + str(sa), ugd)
else:
return 'api_detail::call_statement(%s)' % ('a' + str(sa))
else:
if na > 0:
if ugd:
return 'api_detail::call_statement_du("%s", %s, %s, %s)' % (name['statement'], ugd, na, call_func_direct_args(args))
else:
return 'api_detail::call_statement("%s", %s, %s)' % (name['statement'], na, call_func_direct_args(args))
else:
if ugd:
return 'api_detail::call_statement_du("%s", %s)' % (name['statement'], ugd)
else:
return 'api_detail::call_statement("%s")' % (name['statement'])
else:
return 'api_detail::get_func("%s")(%s)' % (name['name'], call_func_direct_args(args))
def decl_template_arg(arg, p):
if arg.has_key('value'):
return ''
elif arg.has_key('result'):
return ''
elif is_template(arg):
return 'class A' + str(p)
else:
return ''
def decl_template_args(args):
if not len(args):
return ''
d_args = reduce(lambda x,y : x + (y and ((x and ', ' or '') + y) or ''), map(decl_template_arg, args, xrange(len(args))))
return d_args
def is_rtn_borrowed_object(rtn):
if is_object(rtn):
return rtn.has_key('borrowed')
else:
return 0
def is_rtn_new_object(rtn):
if is_object(rtn):
return not rtn.has_key('borrowed')
else:
return 0
def is_func_direct(name):
return name.has_key('direct')
def rtn_call_func_direct(rtn, name, args):
if rtn['name'] == 'void':
direct_code = ' %s;' % call_func_direct(name, args)
elif is_object(rtn):
direct_code = ' return %s;' % call_func_direct(name, args)
else:
r = '''\
object r(%s);
return boost::python::arg_from_python<%s>(r.ptr())(r.ptr());'''
direct_code = r % (call_func_direct(name, args), rtn['name'])
return direct_code
def rtn_call_func(rtn, name, args):
if is_func_direct(name):
return rtn_call_func_direct(rtn, name, args)
true_rtn = get_actual_rtn_type(rtn, args)
err = true_rtn.get('err')
arg_number = true_rtn.get('arg_number')
if rtn['name'] == 'void':
return ' %s;' % call_func(name, args)
elif is_rtn_new_object(rtn):
if err and (err != 'NULL'):
r = '''\
PyObject* r = %s;
if(r == %s)
throw_error_already_set();
return object((python::detail::new_reference)r);'''
return r % (call_func(name, args), err)
else:
return ' return object((python::detail::new_reference)%s);' % call_func(name, args)
elif is_rtn_borrowed_object(rtn):
if err and (err != 'NULL'):
r = '''\
PyObject* r = %s;
if(r == %s)
throw_error_already_set();
return object((python::detail::borrowed_reference)r);'''
return r % (call_func(name, args), err)
else:
return ' return object((python::detail::borrowed_reference)%s);' % call_func(name, args)
else:
if err:
if arg_number == None:
r = '''\
%s r = %s;
if(r == %s)
throw_error_already_set();
return r;'''
return r % (rtn['name'], call_func(name, args), err)
else:
r = '''\
%s rslt;
%s r = %s;
if(r == %s)
throw_error_already_set();
return rslt;'''
return r % (true_rtn['name'], rtn['name'], call_func(name, args), err)
else:
return ' return %s;' % call_func(name, args)
def decl_func(name, args):
return '%s(%s)' % (name.get('decl', name['name']), decl_func_args(name, args))
def rtn_decl_func(rtn, name, args):
true_rtn = get_actual_rtn_type(rtn, args)
ta = decl_template_args(args)
if ta:
decl = 'template<%s>\n' % ta
else:
decl = 'BOOST_PYTHON_DECL '
if is_object(true_rtn):
return decl + 'object %s' % decl_func(name, args)
else:
return decl + '%s %s' % (true_rtn['name'], decl_func(name, args))
def is_info_template(fn_info):
for arg in fn_info['args']:
if is_template(arg):
return 1
return 0
def parse_func(func):
fn_info = {}
fnm = re.match(r'(?P<rtn>\S+)\s+(?P<fname>[^\s\(\){}]+({[^{}]*})?)\s*\((?P<args>(({[^{}]*})+|(\([^\(\)]*\))+|[^\(\)]+)*)\)', func).groupdict()
fn_info['fname'] = SplitOutAttrs(fnm['fname'])
fn_info['rtn'] = SplitOutAttrs(fnm['rtn'])
fn_info['args'] = map(SplitOutAttrs, SplitOutList(fnm['args']))
if fn_info['fname'].has_key('statement'):
if is_info_template(fn_info):
for arg in fn_info['args']:
if is_template(arg):
arg['addr'] = None
else:
for arg in fn_info['args']:
if is_object(arg):
arg['addr'] = None
return fn_info
def get_argrepeat(fn_info):
if fn_info['fname'].has_key('argrepeat'):
argrepeat = fn_info['fname']['argrepeat']
if argrepeat == None:
argrepeat = 10
else:
argrepeat = 1
return argrepeat
def do_arg_repeat(fn_info):
fn_info['args'] = fn_info['args'] + [fn_info['args'][len(fn_info['args']) - 1],]
if fn_info['fname'].has_key('statement'):
stmt = fn_info['fname']['statement']
if stmt:
s_args = re.findall(r'[\s,\(](?:_([0-9]+))(?=$|[\s,\)])', stmt)
if s_args:
mx = reduce(max, map(int, s_args), 0)
mx_arg = '_' + str(mx)
next_arg = '_' + str(mx + 1)
stmt = re.sub(r'(?<=[\s,\(])' + mx_arg + '(?=$|[\s,\)])', mx_arg + ', ' + next_arg, stmt, 1)
fn_info['fname']['statement'] = stmt
def decl_funcs(fn_list):
fn_defs = ''
for fn in fn_list:
fn_info = parse_func(fn)
argrepeat = get_argrepeat(fn_info)
for ar in xrange(argrepeat):
fn_defs += rtn_decl_func(fn_info['rtn'], fn_info['fname'], fn_info['args'])
if is_info_template(fn_info):
fn_defs += '\n{\n' + rtn_call_func(fn_info['rtn'], fn_info['fname'], fn_info['args']) + '\n}\n'
else:
fn_defs += ';\n'
if ar != (argrepeat - 1):
do_arg_repeat(fn_info)
return fn_defs
def impl_funcs(fn_list):
fn_defs = ''
for fn in fn_list:
fn_info = parse_func(fn)
if is_info_template(fn_info):
continue
argrepeat = get_argrepeat(fn_info)
for ar in xrange(argrepeat):
fn_defs += rtn_decl_func(fn_info['rtn'], fn_info['fname'], fn_info['args']) + ' {\n'
fn_defs += rtn_call_func(fn_info['rtn'], fn_info['fname'], fn_info['args']) + '\n}\n\n'
if ar != (argrepeat - 1):
do_arg_repeat(fn_info)
return fn_defs
if __name__ == '__main__':
f = file(DeclFile, 'w')
print >>f, DeclFileHeader
print >>f, decl_funcs(API_List)
print >>f, DeclFileTrailer
f.close()
f = file(ImplFile, 'w')
print >>f, ImplFileHeader
print >>f, impl_funcs(API_List)
print >>f, ImplFileTrailer
f.close()

201
src/gen_returning.py
View File

@@ -1,201 +0,0 @@
# (C) Copyright David Abrahams 2001,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.
#
# This work was funded in part by Lawrence Berkeley National Labs
from gen_function import *
import string
header = '''// (C) Copyright David Abrahams 2001,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.
//
// This work was funded in part by Lawrence Berkeley National Labs
//
// This file generated for %d-argument member functions and %d-argument free
// functions by gen_returning.py
'''
body_sections = (
'''
#ifndef RETURNING_DWA20011201_HPP
# define RETURNING_DWA20011201_HPP
# include <boost/python/detail/wrap_python.hpp>
# include <boost/config.hpp>
# include <boost/python/detail/none.hpp>
# include <boost/python/from_python.hpp>
namespace boost { namespace python { namespace detail {
// Calling C++ from Python
template <class R>
struct returning
{
''',
'''
''',
''' // Free functions
''',
'''};
template <>
struct returning<void>
{
typedef void R;
''',
'''
''',
'''
// Free functions
''',
'''};
}}} // namespace boost::python::detail
#endif // RETURNING_DWA20011201_HPP
''')
#'
member_function = ''' template <class P, class A0%(, class A%+%)>
static PyObject* call(R (A0::*pmf)(%(A%+%:, %))%1, PyObject* args_, PyObject*, P const& policies)
{
// check that each of the arguments is convertible
from_python<A0%1*> c0(PyTuple_GET_ITEM(args_, 0));
if (!c0.convertible()) return 0;
%( from_python<A%+> c%+(PyTuple_GET_ITEM(args_, %+));
if (!c%+.convertible()) return 0;
%)
%[r%: // find the result converter
typedef typename P::result_converter result_converter;
typename eval<result_converter,R>::type cr;
if (!cr.convertible()) return 0;
%] if (!policies.precall(args_)) return 0;
%[r%:PyObject* result = cr( %]((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
%(c%+(PyTuple_GET_ITEM(args_, %+))%:
, %))%[r%: )%];
return policies.postcall(args_, %[r%:result%]%[v%:detail::none()%]);
}
'''
free_function = ''' template <class P%(, class A%n%%)>
static PyObject* call(R (*pf)(%(A%n%:, %)), PyObject* args_, PyObject*, P const& policies)
{%{
// check that each of the arguments is convertible
%}%( from_python<A%n> c%n(PyTuple_GET_ITEM(args_, %n));
if (!c%n.convertible()) return 0;
%)
%[r%: // find the result converter
typedef typename P::result_converter result_converter;
typename eval<result_converter,R>::type cr;
if (!cr.convertible()) return 0;
%]%[not-void-and-0-arg%: if (!policies.precall(args_)) return 0;
%] %[r%:PyObject* result = cr( %](*pf)(
%(c%n(PyTuple_GET_ITEM(args_, %n))%:
, %))%[r%: )%];
return policies.postcall(args_, %[r%:result%]%[v%:detail::none()%]);
}
'''
def _returns_value(key, n, args, value):
if key != 'v':
return value
else:
return ''
def _returns_void(key, n, args, value):
if key == 'v' or key == 'not-void-and-0-arg' and n != 0:
return value
else:
return ''
_cv_qualifiers = ('', ' const', ' volatile', ' const volatile')
_prefix = {
# ' const': '''
# // missing cv-qualified -> cv-unqualified member pointer conversions
# # if defined(__MWERKS__) && __MWERKS__ <=0x2406 || defined(BOOST_MSVC) && BOOST_MSVC <= 1200 || defined(__BORLANDC__)
# ''',
' const volatile': '''
// missing const volatile type traits
# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
'''};
def gen_returning(member_function_args, free_function_args = None):
if free_function_args is None:
free_function_args = member_function_args + 1
return_none = ''';
return detail::none();'''
return (header % (member_function_args, free_function_args)
+ body_sections[0]
#
# functions returning results
#
+ reduce(lambda x,y: x+y
, map(lambda cv:
_prefix.get(cv,'')
+ gen_functions(member_function,
member_function_args, cv,
fill = _returns_value) + '\n'
, _cv_qualifiers))
+ '''# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
'''
## endif // missing cv-qualified -> cv-unqualified member pointer conversions
#'''
# free functions
+ gen_functions(free_function, free_function_args, fill = _returns_value)
+ body_sections[3]
#
# functions returning void
#
+ reduce(lambda x,y: x+y
, map(lambda cv:
_prefix.get(cv,'')
+ gen_functions(member_function,
member_function_args, cv, fill =
_returns_void) + '\n'
, _cv_qualifiers))
+ '''# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
'''
## endif // missing cv-qualified -> cv-unqualified member pointer conversions
#'''
# free functions
+ gen_functions(free_function, free_function_args, fill = _returns_void)
+ body_sections[6]
)
if __name__ == '__main__':
import sys
if len(sys.argv) == 1:
member_function_args = 5
free_function_args = 6
else:
member_function_args = int(sys.argv[1])
if len(sys.argv) > 2:
free_function_args = int(sys.argv[2])
else:
free_function_args = member_function_args
print gen_returning(member_function_args, free_function_args)

90
src/gen_signature.py
View File

@@ -1,90 +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
from gen_function import *
import string
header = '''// (C) 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.
//
// This work was funded in part by Lawrence Berkeley and Lawrence
// Livermore National Labs
//
// This file generated for %d-argument member functions and %d-argument free
// functions by gen_signature.py
'''
_cv_qualifiers = ('', ' const', ' volatile', ' const volatile')
_suffix = {
'': '''
// Metrowerks thinks this creates ambiguities
# if !defined(__MWERKS__) || __MWERKS__ > 0x2406
''', ' const volatile': '''
# endif // __MWERKS__
'''
};
def gen_arg_tuple_size(member_function_args, free_function_args = None):
if free_function_args is None:
free_function_args = member_function_args + 1
return_none = ''';
return detail::none();'''
return (header % (member_function_args, free_function_args)
+ '''
#ifndef SIGNATURE_DWA2002128_HPP
# define SIGNATURE_DWA2002128_HPP
# include <boost/mpl/type_list.hpp>
namespace boost { namespace python { namespace detail {
'''
+ gen_functions('''
template <class R%(, class A%n%)>
mpl::type_list<R%(,A%n%)>
signature(R (*)(%(A%n%:, %)))
{
return mpl::type_list<R%(,A%n%)>()
}
''', free_function_args)
+ reduce(lambda x,y: x+'\n'+y
, map(
lambda cv: gen_functions(
'''template <class R, class A0%(, class A%+%)>
mpl::type_list<R%,A0%1&%(,A%+%)> signature(R (A0::*)(%(A%+%:, %))%1)
{
return mpl::type_list<R%,A0%1&%(,A%+%)>();
}
''', member_function_args, cv)
, _cv_qualifiers)) + '''}}} // namespace boost::python::detail
#endif // SIGNATURE_DWA2002128_HPP
''')
if __name__ == '__main__':
import sys
if len(sys.argv) == 1:
member_function_args = 5
free_function_args = 6
else:
member_function_args = int(sys.argv[1])
if len(sys.argv) > 2:
free_function_args = int(sys.argv[2])
else:
free_function_args = member_function_args
print gen_arg_tuple_size(member_function_args, free_function_args)

158
src/gen_signatures.py
View File

@@ -1,158 +0,0 @@
from gen_function import *
import string
def gen_struct_signatures(args):
result = ''
for n in range(args, -1, -1):
result = (
result + gen_function("""%{template <%(class T%n%:, %)>
%}struct signature%x {};
""", n)
# + ((n == args) and [""] or
# [gen_function("""
# template <class X>
# static inline signature%1<X%(, T%n%)> prepend(type<X>)
# { return signature%1<X%(, T%n%)>(); }""",
# n, (str(n+1),))
# ]
# )[0]
#
# + ((n != 0) and [""] or
# ["""
# // This one terminates the chain. Prepending void_t to the head of a void_t
# // signature results in a void_t signature again.
# static inline signature0 prepend(void_t) { return signature0(); }"""]
# )[0]
# + """
#};
#
#"""
+ ((n == args) and [""] or
[gen_function(
"""template <%(class T%n%, %)class X>
inline signature%1<X%(, T%n%)> prepend(type<X>, signature%x%{<%(T%n%:, %)>%})
{ return signature%1<X%(, T%n%)>(); }
""", n, str(n+1))
]
)[0]
)
return result
def gen_signatures(args):
return (
"""// (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 %d 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
""" % args
+ gen_struct_signatures(args)
+ """
// 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
"""
+ gen_function("""
template <%(class A%n% = detail::void_t%:, %)>
struct constructor
{
};
""", args)
+ """
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"""
+ gen_functions("""
template <class R%(, class A%n%)>
return_value_select<R> return_value(R (*)(%(A%n%:, %))) { return return_value_select<R>(); }
""", args)
+
"""
// TODO(?): handle 'const void'
// member functions"""
+ gen_functions("""
template <class R, class T%(, class A%n%)>
return_value_select<R> return_value(R (T::*)(%(A%n%:, %))) { return return_value_select<R>(); }
""", args)
+ gen_functions("""
template <class R, class T%(, class A%n%)>
return_value_select<R> return_value(R (T::*)(%(A%n%:, %)) const) { return return_value_select<R>(); }
""", args)
+ """
}}} // namespace boost::python::detail
#endif
""")
if __name__ == '__main__':
import sys
if len(sys.argv) == 1:
args = 5
else:
args = int(sys.argv[1])
print gen_signatures(args)

58
src/gen_singleton.py
View File

@@ -1,58 +0,0 @@
from gen_function import *
import string
def gen_singleton(args):
return (
"""// (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
"""
+ gen_functions("""%{
template <%(class A%n%:, %)>
%} singleton(%(const A%n& a%n%:, %)) : Base(%(a%n%:, %)) {}
""", args)
+ """
};
template <class Derived, class Base>
Derived* singleton<Derived,Base>::instance()
{
static Derived x;
return &x;
}
}}} // namespace boost::python::detail
#endif
""")
if __name__ == '__main__':
import sys
if len(sys.argv) == 1:
args = 5
else:
args = int(sys.argv[1])
print gen_singleton(args)

35
src/gen_value_holder.py
View File

@@ -1,35 +0,0 @@
# 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.
#
# This work was funded in part by Lawrence Livermore National Labs
from gen_function import *
import string
def _generate(member_function_args, free_function_args = None):
return ('''// 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 VALUE_HOLDER_DWA20011215_HPP
# define VALUE_HOLDER_DWA20011215_HPP
# include <boost/python/object/class.hpp>
# include <boost/python/converter/type_id.hpp>
# include <boost/python/object/inheritance.hpp>
# include <boost/ref.hpp>
# include <boost/function/function_base.hpp>
namespace boost { namespace python { namespace objects {
template <class Held>
struct value_holder : instance_holder
{
// Forward construction to the held object
'''
+
gen_functions(

Some files were not shown because too many files have changed in this diff Show More