boost/python
2
0
Fork 0
mirror of https://github.com/boostorg/python.git synced 2026-01-24 06:02:14 +00:00
Code Issues Projects Releases Wiki Activity

Merge Trunk changes to RC_1_29_0

Browse Source 
[SVN r15732]
This commit is contained in:
Dave Abrahams
2002-10-05 12:53:06 +00:00
parent 0462c4d2f4
commit c33ac6b47a
154 changed files with 4121 additions and 9390 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
Jamfile
View File

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

242
doc/v2/CallPolicies.html
View File

@@ -1,124 +1,152 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../../../boost.css">
<title>Boost.Python - CallPolicies Concept</title>
</head>
<body link="#0000ff" vlink="#800080">
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../../../boost.css">
<title>Boost.Python - CallPolicies Concept</title>
</head>
<body link="#0000ff" vlink="#800080">
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">CallPolicies Concept</h2>
</td>
</tr>
</table>
<hr>
<dl class="page-index">
<dt><a href="#introduction">Introduction</a></dt>
<dt><a href="#composition">CallPolicies Composition</a></dt>
<dt><a href="#concept-requirements">Concept Requirements</a></dt>
<dl class="page-index">
<dt><a href="#CallPolicies-concept">CallPolicies Concept</a></dt>
</dl>
</dl>
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<h2><a name="introduction"></a>Introduction</h2>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<p>Models of the CallPolicies concept are used to specialize the
behavior of Python callable objects generated by Boost.Python to
wrapped C++ objects like function and member function
pointers, providing three behaviors:
<ol>
<li> <code>precall</code> - Python argument tuple management before
the wrapped object is invoked
<li> <code>result_converter</code> - C++ return value handling
<li> <code>postcall</code> - Python argument tuple and result
management after the wrapped object is invoked
</ol>
<h2 align="center">CallPolicies Concept</h2>
</td>
</tr>
</table>
<hr>
<h2><a name="composition"></a>CallPolicies Composition</h2>
<dl class="page-index">
<dt><a href="#introduction">Introduction</a></dt>
In order to allow the use of multiple models of CallPolicies in the
same callable object, Boost.Python's CallPolicies class templates
provide a chaining interface which allows them to be recursively
composed. This interface takes the form of an optional template
parameter, <code>Base</code> which defaults to <a
href="default_call_policies.html#default_call_policies-spec">
<code>default_call_policies</code></a>. By convention, the
<code>precall</code> function of the
<code>Base</code> is invoked <i>after</i> the <code>precall</code>
function supplied by the outer template, and the <code>postcall</code>
function of the <code>Base</code> is invoked <i>before</i> the
<code>postcall</code> function of the outer template. If a
<code>result_converter</code> is supplied by the outer template, it
<i>replaces</i> any <code>result_converter</code> supplied by the
<code>Base</code>. For an example, see <a
href="return_internal_reference.html#return_internal_reference-spec">
<code>return_internal_reference</code></a>.
<dt><a href="#composition">CallPolicies Composition</a></dt>
<h2><a name="concept-requirements"></a>Concept Requirements</h2>
<h3><a name="CallPolicies-concept"></a>CallPolicies Concept</h3>
<dt><a href="#concept-requirements">Concept Requirements</a></dt>
<p>In the table below, <code><b>x</b></code> denotes an object whose
type <code><b>P</b></code> is a model of CallPolicies,
<code><b>a</b></code> denotes a <code>PyObject*</code> pointing to
a Python argument tuple object, and <code><b>r</b></code> denotes a
<code>PyObject*</code> referring to a &quot;preliminary&quot; result
object.
<dd>
<dl class="page-index">
<dt><a href="#CallPolicies-concept">CallPolicies Concept</a></dt>
</dl>
</dd>
</dl>
<table summary="CallPolicies expressions" border="1" cellpadding="5">
<h2><a name="introduction"></a>Introduction</h2>
<tr>
<td><b>Expression</b></td>
<td><b>Type</b></td>
<td><b>Result/Semantics</b></td>
</tr>
<p>Models of the CallPolicies concept are used to specialize the behavior
of Python callable objects generated by Boost.Python to wrapped C++
objects like function and member function pointers, providing three
behaviors:</p>
<tr>
<td valign="top"><code>x.precall(a)</code></td>
<td>convertible to <code>bool</code>
<td>returns <code>false</code> and <code><a
href="http://www.python.org/doc/2.2/api/exceptionHandling.html#l2h-71">PyErr_Occurred</a>()&nbsp;!=&nbsp;0</code>
upon failure, <code>true</code> otherwise.
<ol>
<li><code>precall</code> - Python argument tuple management before the
wrapped object is invoked</li>
<tr>
<td valign="top"><code>P::result_converter</code></td>
<td>A model of <a href="ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a>.
<td>An MPL unarymetafunction object used produce the
&quot;preliminary&quot result object.
<li><code>result_converter</code> - C++ return value handling</li>
<tr>
<td valign="top"><code>x.postcall(a, r)</code></td>
<td>convertible to <code>PyObject*</code>
<td>0 <code>0</code> and <code><a
href="http://www.python.org/doc/2.2/api/exceptionHandling.html#l2h-71">PyErr_Occurred</a>()&nbsp;!=&nbsp;0</code>
upon failure. Must &quot;conserve references&quot; even in the
event of an exception. In other words, if <code>r</code> is not
returned, its reference count must be decremented; if another
existing object is returned, its reference count must be
incremented.
</table>
<li><code>postcall</code> - Python argument tuple and result management
after the wrapped object is invoked</li>
</ol>
Models of CallPolicies are required to be <a
href="../../../utility/CopyConstructible.html">CopyConstructible</a>.
<h2><a name="composition"></a>CallPolicies Composition</h2>
In order to allow the use of multiple models of CallPolicies in the same
callable object, Boost.Python's CallPolicies class templates provide a
chaining interface which allows them to be recursively composed. This
interface takes the form of an optional template parameter,
<code>Base</code> which defaults to <a href=
"default_call_policies.html#default_call_policies-spec"><code>default_call_policies</code></a>.
By convention, the <code>precall</code> function of the <code>Base</code>
is invoked <i>after</i> the <code>precall</code> function supplied by the
outer template, and the <code>postcall</code> function of the
<code>Base</code> is invoked <i>before</i> the <code>postcall</code>
function of the outer template. If a <code>result_converter</code> is
supplied by the outer template, it <i>replaces</i> any
<code>result_converter</code> supplied by the <code>Base</code>. For an
example, see <a href=
"return_internal_reference.html#return_internal_reference-spec"><code>return_internal_reference</code></a>.
<hr>
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
19 May, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
Abrahams</a> 2002. All Rights Reserved.</i>
<h2><a name="concept-requirements"></a>Concept Requirements</h2>
<p>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.
</body>
<h3><a name="CallPolicies-concept"></a>CallPolicies Concept</h3>
<p>In the table below, <code><b>x</b></code> denotes an object whose type
<code><b>P</b></code> is a model of CallPolicies, <code><b>a</b></code>
denotes a <code>PyObject*</code> pointing to a Python argument tuple
object, and <code><b>r</b></code> denotes a <code>PyObject*</code>
referring to a "preliminary" result object.</p>
<table summary="CallPolicies expressions" border="1" cellpadding="5">
<tr>
<td><b>Expression</b></td>
<td><b>Type</b></td>
<td><b>Result/Semantics</b></td>
</tr>
<tr>
<td valign="top"><code>x.precall(a)</code></td>
<td>convertible to <code>bool</code></td>
<td>returns <code>false</code> and <code><a href=
"http://www.python.org/doc/2.2/api/exceptionHandling.html#l2h-71">PyErr_Occurred</a>()&nbsp;!=&nbsp;0</code>
upon failure, <code>true</code> otherwise.</td>
</tr>
<tr>
<td valign="top"><code>P::result_converter</code></td>
<td>A model of <a href=
"ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a>.</td>
<td>An MPL unary <a href=
"../../../mpl/doc/paper/html/usage.html#metafunctions.classes">Metafunction
Class</a> used produce the "preliminary" result object.</td>
</tr>
<tr>
<td valign="top"><code>x.postcall(a, r)</code></td>
<td>convertible to <code>PyObject*</code></td>
<td>0 <code>0</code> and <code><a href=
"http://www.python.org/doc/2.2/api/exceptionHandling.html#l2h-71">PyErr_Occurred</a>()&nbsp;!=&nbsp;0</code>
upon failure. Must "conserve references" even in the event of an
exception. In other words, if <code>r</code> is not returned, its
reference count must be decremented; if another existing object is
returned, its reference count must be incremented.</td>
</tr>
</table>
Models of CallPolicies are required to be <a href=
"../../../utility/CopyConstructible.html">CopyConstructible</a>.
<hr>
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
19 May, 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</i></p>
<p>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.</p>
</body>
</html>

173
doc/v2/call_method.html
View File

@@ -1,74 +1,89 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - &lt;call_method.hpp&gt;</title>
</head>
<body link="#0000ff" vlink="#800080">
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - &lt;call_method.hpp&gt;</title>
</head>
<body link="#0000ff" vlink="#800080">
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt=
"C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Header &lt;call_method.hpp&gt;</h2>
</td>
</tr>
</table>
<hr>
<h2>Contents</h2>
<dl class="page-index">
<dt><a href="#introduction">Introduction</a></dt>
<dt><a href="#functions">Functions</a></dt>
<dl class="page-index">
<dt><a href="#call_method-spec">call_method</a></dt>
</dl>
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<dt><a href="#examples">Example(s)</a></dt>
<td valign="top">
<h1 align="center">Boost.Python</h1>
</dl>
<hr>
<h2><a name="introduction"></a>Introduction</h2>
<p>
<code>&lt;boost/python/call_method.hpp&gt;</code> defines the <a
href="#call_method-spec"><code>call_method</code></a> family of overloaded function
templates, used to invoke callable attributes of Python objects from C++.
<h2 align="center">Header &lt;call_method.hpp&gt;</h2>
</td>
</tr>
</table>
<hr>
<h2><a name="functions"></a>Functions</h2>
<h2>Contents</h2>
<dl class="page-index">
<dt><a href="#introduction">Introduction</a></dt>
<dt><a href="#functions">Functions</a></dt>
<dd>
<dl class="page-index">
<dt><a href="#call_method-spec">call_method</a></dt>
</dl>
</dd>
<dt><a href="#examples">Example(s)</a></dt>
</dl>
<hr>
<h2><a name="introduction"></a>Introduction</h2>
<p><code>&lt;boost/python/call_method.hpp&gt;</code> defines the <a href=
"#call_method-spec"><code>call_method</code></a> family of overloaded
function templates, used to invoke callable attributes of Python objects
from C++.</p>
<h2><a name="functions"></a>Functions</h2>
<pre>
<a name="call_method-spec">template &lt;class R, class A1, class A2, ... class A<i>n</i>&gt;</a>
<a name=
"call_method-spec">template &lt;class R, class A1, class A2, ... class A<i>n</i>&gt;</a>
R call_method(PyObject* self, char const* method, A1 const&amp;, A2 const&amp;, ... A<i>n</i> const&amp;)
</pre>
<dl class="function-semantics">
<dt><b>Requires:</b> <code>R</code> is a pointer type, reference
type, or a complete type with an accessible copy constructor</dt>
<dt><b>Effects:</b> Invokes <code>self.<i>method</i>(a1,&nbsp;a2,&nbsp;...a<i>n</i>)</code> in
Python, where <code>a1</code>...<code>a<i>n</i></code> are the arguments to
<code>call_method()</code>, converted to Python objects. For a
complete semantic description, see <a href="callbacks.html">this
page</a>.
<dl class="function-semantics">
<dt><b>Requires:</b> <code>R</code> is a pointer type, reference type,
or a complete type with an accessible copy constructor</dt>
<dt><b>Returns:</b> The result of the Python call, converted to the
C++ type <code>R</code>.</dt>
<dt><b>Effects:</b> Invokes
<code>self.<i>method</i>(a1,&nbsp;a2,&nbsp;...a<i>n</i>)</code> in
Python, where <code>a1</code>...<code>a<i>n</i></code> are the
arguments to <code>call_method()</code>, converted to Python objects.
For a complete semantic description, see <a href="callbacks.html">this
page</a>.</dt>
</dt>
<dt><b>Rationale:</b> <code>call_method</code> is critical to
implementing C++ virtual functions which are overridable in Python,
as shown by the example below.
</dt>
</dl>
<dt><b>Returns:</b> The result of the Python call, converted to the C++
type <code>R</code>.</dt>
<h2><a name="examples"></a>Example(s)</h2>
<dt><b>Rationale:</b> <code>call_method</code> is critical to
implementing C++ virtual functions which are overridable in Python, as
shown by the example below.</dt>
</dl>
The following C++ illustrates the use of <code>call_method</code> in
wrapping a class with a virtual function that can be overridden in
Python:
<h2><a name="examples"></a>Example(s)</h2>
The following C++ illustrates the use of <code>call_method</code> in
wrapping a class with a virtual function that can be overridden in
Python:
<h3>C++ Module Definition</h3>
<h3>C++ Module Definition</h3>
<pre>
#include &lt;boost/python/module.hpp&gt;
#include &lt;boost/python/class.hpp&gt;
@@ -79,13 +94,13 @@ Python:
class Base
{
public:
virtual char const* class_name() const { return &quot;Base&quot;; }
virtual char const* class_name() const { return "Base"; }
virtual ~Base();
};
bool is_base(Base* b)
{
return !std::strcmp(b-&gt;class_name(), &quot;Base&quot;);
return !std::strcmp(b-&gt;class_name(), "Base");
}
// Wrapper code begins here
@@ -97,26 +112,25 @@ class Base_callback : public Base
public:
Base_callback(PyObject* self) : m_self(self) {}
char const* class_name() const { return <b>call_method</b>(m_self, &quot;class_name&quot;); }
char const* class_name() const { return <b>call_method</b>(m_self, "class_name"); }
char const* Base_name() const { return Base::class_name(); }
private:
PyObject* m_self;
PyObject* const m_self;
};
using namespace boost::python;
BOOST_PYTHON_MODULE_INIT(my_module)
BOOST_PYTHON_MODULE(my_module)
{
module("my_module")
.def(&quot;is_base&quot;, is_base)
.add(
class_&lt;Base,Base_callback, noncopyable&gt;(&quot;Base&quot;)
.def(&quot;class_name&quot;, &#24;Base_callback::Base_name);
)
;
def("is_base", is_base);
class_&lt;Base,Base_callback, noncopyable&gt;("Base")
.def("class_name", &amp;Base_callback::Base_name)
;
}
</pre>
<h3>Python Code</h3>
<h3>Python Code</h3>
<pre>
&gt;&gt;&gt; from my_module import *
&gt;&gt;&gt; class Derived(Base):
@@ -130,12 +144,15 @@ BOOST_PYTHON_MODULE_INIT(my_module)
&gt;&gt;&gt; is_base(Derived())
0
</pre>
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
10 May, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a>
2002. All Rights Reserved.</i></p>
</body>
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
28 Sept, 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</i></p>
</body>
</html>

825
doc/v2/class.html
View File

File diff suppressed because it is too large Load Diff

226
doc/v2/configuration.html
View File

@@ -1,91 +1,141 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - Configuration</title>
</head>
<body link="#0000ff" vlink="#800080">
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - Configuration</title>
</head>
<body link="#0000ff" vlink="#800080">
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt=
"C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Configuration</h2>
</td>
</tr>
</table>
<hr>
<dl class="page-index">
<dt><a href="#introduction">Introduction</a></dt>
<dt><a href="#app-defined">Application Defined Macros</a></dt>
<dt><a href="#lib-defined-public">Public Library Defined Macros</a></dt>
<dt><a href="#lib-defined-impl">Library Defined Implementation Macros</a></dt>
</dl>
<h2><a name="introduction"></a>Introduction</h2>
<p>Boost.Python uses several configuration macros in <a href="http://www.boost.org/libs/config/config.htm">&lt;boost/config.hpp&gt;</a>,
as well as configuration macros meant to be supplied by the application. These
macros are documented here.</p>
<h2><a name="app-defined"></a>Application Defined Macros</h2>
<p>These are the macros that may be defined by an application using Boost.Python.</p>
<table summary="application defined macros" cellspacing="10" width="100%">
<tr>
<td><b>Macro</b></td>
<td><b>Meaning</b></td>
</tr>
<tr>
<td>{{macro}}</td>
<td>{{meaning}}</td>
</tr>
<tr>
<td>{{macro}}</td>
<td>{{meaning}}</td>
</tr>
</table>
<h2><a name="lib-defined-public"></a>Public Library Defined Macros</h2>
<p>These macros are defined by Boost.Python but are expected to be used by application
code.</p>
<table summary="public library defined macros" cellspacing="10" width="100%">
<tr>
<td><b>Macro</b></td>
<td><b>Meaning</b></td>
</tr>
<tr>
<td>{{macro}}</td>
<td>{{meaning}}</td>
</tr>
<tr>
<td>{{macro}}</td>
<td>{{meaning}}</td>
</tr>
</table>
<h2><a name="lib-defined-impl"></a>Library Defined Implementation Macros</h2>
<p>These macros are defined by Boost.Python and are implementation details of interest
only to implementers.</p>
<table summary="library defined implementation macros" cellspacing="10" width="100%">
<tr>
<td><b>Macro</b></td>
<td><b>Meaning</b></td>
</tr>
<tr>
<td>{{macro}}</td>
<td>{{meaning}}</td>
</tr>
<tr>
<td>{{macro}}</td>
<td>{{meaning}}</td>
</tr>
</table>
<hr>
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
05 November, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a>
2002. All Rights Reserved.</i></p>
</body>
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Configuration</h2>
</td>
</tr>
</table>
<hr>
<dl class="page-index">
<dt><a href="#introduction">Introduction</a></dt>
<dt><a href="#app-defined">Application Defined Macros</a></dt>
<dt><a href="#lib-defined-impl">Library Defined Implementation
Macros</a></dt>
</dl>
<h2><a name="introduction"></a>Introduction</h2>
<p><b>Boost.Python</b> uses several configuration macros in <a href=
"http://www.boost.org/libs/config/config.htm">&lt;boost/config.hpp&gt;</a>,
as well as configuration macros meant to be supplied by the application.
These macros are documented here.</p>
<h2><a name="app-defined"></a>Application Defined Macros</h2>
<p>These are the macros that may be defined by an application using
<b>Boost.Python</b>. Note that if you extend a strict interpretation of the C++
standard to cover dynamic libraries, using different values of these
macros when compiling different libraries (including extension modules
and the <b>Boost.Python</b> library itself) is a violation of the <a href=
"definitions.html#ODR">ODR</a>. However, we know of no C++
implementations on which this particular violation is detectable or
causes any problems.</p>
<table summary="application defined macros" width="100%" cellpadding=
"10">
<tr>
<th align="left"><b>Macro</b></td>
<th><b>Default</b></td>
<th align="left"><b>Meaning</b></td>
</tr>
<tr>
<td valign="top"><code>BOOST_PYTHON_MAX_ARITY</code></td>
<td valign="top" align="center">15</td>
<td valign="top">The maximum <a href="definitions.html#arity">arity</a> of any
function, member function, or constructor to be wrapped, invocation
of a <b>Boost.Python</b> function wich is specified as taking arguments
<code>x1,&nbsp;x2,</code>...<code>X</code><i>n</i>. This includes, in
particular, callback mechanisms such as <code><a href=
"object.html#object-spec">object</a>::operator()(</code>...<code>)</code>
or <code><a href=
"call_method.html#call_method-spec">call_method</a>&lt;R&gt;(</code>...<code>
)</code>.</td>
</tr>
<tr>
<td valign="top"><code>BOOST_PYTHON_MAX_BASES</code></td>
<td valign="top" align="center">10</td>
<td valign="top">The maximum number of template arguments to the <code><a href=
"class.html#bases-spec">bases</a>&lt;</code>...<code>&gt;</code>
class template, which is used to specify the bases of a wrapped C++
class..</td>
</tr>
</table>
<h2><a name="lib-defined-impl"></a>Library Defined Implementation
Macros</h2>
<p>These macros are defined by <b>Boost.Python</b> and are
implementation details of interest only to implementors and those porting
to new platforms.</p>
<table summary="library defined implementation macros" width="100%"
cellpadding="10">
<tr>
<th align="left"><b>Macro</b></td>
<th><b>Default</b></td>
<th align="left"><b>Meaning</b></td>
</tr>
<tr>
<td valign="top"><code>BOOST_PYTHON_TYPE_ID_NAME</code></td>
<td valign="top" align="center"><i>not&nbsp;defined</i></td>
<td valign="top">If defined, this indicates that the type_info comparison across
shared library boundaries does not work on this platform. In other
words, if shared-lib-1 passes <code>typeid(T)</code> to a function in
shared-lib-2 which compares it to <code>typeid(T)</code>, that
comparison may return <code>false</code>. If this macro is #defined,
Boost.Python uses and compares <code>typeid(T).name()</code> instead
of using and comparing the <code>std::type_info</code> objects
directly.</td>
</tr>
</table>
<hr>
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
04 October, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</i></p>
</body>
</html>

76
doc/v2/copy_const_reference.html
View File

@@ -1,46 +1,58 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<meta name="generator" content="HTML Tidy, see www.w3.org">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - &lt;boost/python/copy_const_reference.hpp&gt;</title>
<title>Boost.Python -
&lt;boost/python/copy_const_reference.hpp&gt;</title>
</head>
<body>
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt=
"C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Header
&lt;boost/python/copy_const_reference.hpp&gt;</h2>
</td>
</tr>
</table>
<hr>
<h2>Contents</h2>
<dl class="page-index">
<dt><a href="#classes">Classes</a>
<dt><a href="#classes">Classes</a></dt>
<dd>
<dl class="page-index">
<dt><a href="#copy_const_reference-spec">Class
<code>copy_const_reference</code></a>
<code>copy_const_reference</code></a></dt>
<dd>
<dl class="page-index">
<dt><a href="#copy_const_reference-spec-synopsis">Class
<code>copy_const_reference</code> synopsis</a>
<code>copy_const_reference</code> synopsis</a></dt>
<dt><a href="#copy_const_reference-spec-metafunctions">Class
<code>copy_const_reference</code> metafunctions</a>
<code>copy_const_reference</code> metafunctions</a></dt>
</dl>
</dd>
</dl>
</dd>
<dt><a href="#examples">Example</a>
<dt><a href="#examples">Example</a></dt>
</dl>
<hr>
@@ -50,9 +62,10 @@
<code>copy_const_reference</code></h3>
<p><code>copy_const_reference</code> is a model of <a href=
"ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a> which can be
used to wrap C++ functions returning a reference-to-const type such that
the referenced value is copied into a new Python object.
"ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a>
which can be used to wrap C++ functions returning a reference-to-const
type such that the referenced value is copied into a new Python
object.</p>
<h4><a name="copy_const_reference-spec-synopsis"></a>Class
<code>copy_const_reference</code> synopsis</h4>
@@ -73,17 +86,17 @@ template &lt;class T&gt; struct apply
</pre>
<dl class="metafunction-semantics">
<dt><b>Requires:</b> <code>T</code> is <code>U const&amp;</code> for some
<code>U</code>.
<dt><b>Requires:</b> <code>T</code> is <code>U const&amp;</code> for
some <code>U</code>.</dt>
<dt><b>Returns:</b> <code>typedef <a href=
"to_python_value.html#to_python_value-spec">to_python_value</a>&lt;T&gt;
type;</code>
type;</code></dt>
</dl>
<h2><a name="examples"></a>Example</h2>
<h3>C++ Module Definition</h3>
<h3>C++ Module Definition</h3>
<pre>
#include &lt;boost/python/module.hpp&gt;
#include &lt;boost/python/class.hpp&gt;
@@ -102,22 +115,18 @@ struct Foo {
// Wrapper code
using namespace boost::python;
BOOST_PYTHON_MODULE_INIT(my_module)
BOOST_PYTHON_MODULE(my_module)
{
module m("my_module")
.add(
class_&lt;Bar&gt;()
)
.add(
class_&lt;Foo&gt;()
.def_init(args&lt;int&gt;())
.def("get_bar", &amp;Foo::get_bar
, return_value_policy&lt;copy_const_reference&gt;())
)
class_&lt;Bar&gt;("Bar");
class_&lt;Foo&gt;("Foo", init&lt;int&gt;())
.def("get_bar", &amp;Foo::get_bar
, return_value_policy&lt;copy_const_reference&gt;())
;
}
</pre>
<h3>Python Code</h3>
<h3>Python Code</h3>
<pre>
&gt;&gt;&gt; from my_module import *
&gt;&gt;&gt; f = Foo(3) # create a Foo object
@@ -126,10 +135,13 @@ BOOST_PYTHON_MODULE_INIT(my_module)
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
15 February, 2002
29 September, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
Abrahams</a> 2002. All Rights Reserved.</i>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</i></p>
</body>
</html>

72
doc/v2/copy_non_const_reference.html
View File

@@ -1,47 +1,59 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<meta name="generator" content="HTML Tidy, see www.w3.org">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python -
&lt;boost/python/copy_non_const_reference.hpp&gt;</title>
</head>
<body>
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt=
"C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Header
&lt;boost/python/copy_non_const_reference.hpp&gt;</h2>
</td>
</tr>
</table>
<hr>
<h2>Contents</h2>
<dl class="page-index">
<dt><a href="#classes">Classes</a>
<dt><a href="#classes">Classes</a></dt>
<dd>
<dl class="page-index">
<dt><a href="#copy_non_const_reference-spec">Class
<code>copy_non_const_reference</code></a>
<code>copy_non_const_reference</code></a></dt>
<dd>
<dl class="page-index">
<dt><a href="#copy_non_const_reference-spec-synopsis">Class
<code>copy_non_const_reference</code> synopsis</a>
<code>copy_non_const_reference</code> synopsis</a></dt>
<dt><a href="#copy_non_const_reference-spec-metafunctions">Class
<code>copy_non_const_reference</code> metafunctions</a>
<dt><a href=
"#copy_non_const_reference-spec-metafunctions">Class
<code>copy_non_const_reference</code> metafunctions</a></dt>
</dl>
</dd>
</dl>
</dd>
<dt><a href="#examples">Example</a>
<dt><a href="#examples">Example</a></dt>
</dl>
<hr>
@@ -51,9 +63,10 @@
<code>copy_non_const_reference</code></h3>
<p><code>copy_non_const_reference</code> is a model of <a href=
"ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a> which can be
used to wrap C++ functions returning a reference-to-non-const type such
that the referenced value is copied into a new Python object.
"ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a>
which can be used to wrap C++ functions returning a
reference-to-non-const type such that the referenced value is copied into
a new Python object.</p>
<h4><a name="copy_non_const_reference-spec-synopsis"></a>Class
<code>copy_non_const_reference</code> synopsis</h4>
@@ -75,16 +88,16 @@ template &lt;class T&gt; struct apply
<dl class="metafunction-semantics">
<dt><b>Requires:</b> <code>T</code> is <code>U&amp;</code> for some
non-const <code>U</code>.
non-const <code>U</code>.</dt>
<dt><b>Returns:</b> <code>typedef <a href=
"to_python_value.html#to_python_value-spec">to_python_value</a>&lt;T&gt;
type;</code>
type;</code></dt>
</dl>
<h2><a name="examples"></a>Example</h2>
<p>C++ code:
<p>C++ code:</p>
<pre>
#include &lt;boost/python/module.hpp&gt;
#include &lt;boost/python/class.hpp&gt;
@@ -103,18 +116,14 @@ struct Foo {
// Wrapper code
using namespace boost::python;
BOOST_PYTHON_MODULE_INIT(my_module)
BOOST_PYTHON_MODULE(my_module)
{
module("my_module")
.add(
class_&lt;Bar&gt;()
)
.add(
class_&lt;Foo&gt;()
.def_init(args&lt;int&gt;())
.def("get_bar", &amp;Foo::get_bar
, return_value_policy&lt;copy_non_const_reference&gt;())
);
class_&lt;Bar&gt;("Bar");
class_&lt;Foo&gt;("Foo", init&lt;int&gt;())
.def("get_bar", &amp;Foo::get_bar
, return_value_policy&lt;copy_non_const_reference&gt;())
;
}
</pre>
Python Code:
@@ -126,10 +135,13 @@ BOOST_PYTHON_MODULE_INIT(my_module)
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
05 November, 2001
29 September, 2001
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
Abrahams</a> 2002. All Rights Reserved.</i>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</i></p>
</body>
</html>

121
doc/v2/data_members.html
View File

@@ -1,109 +1,118 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<meta name="generator" content="HTML Tidy, see www.w3.org">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - &lt;boost/python/data_members.hpp&gt;</title>
</head>
<body>
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt=
"C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Header &lt;boost/python/data_members.hpp&gt;</h2>
<h2 align="center">Header
&lt;boost/python/data_members.hpp&gt;</h2>
</td>
</tr>
</table>
<hr>
<h2>Contents</h2>
<dl class="page-index">
<dt><a href="#introduction">Introduction</a>
<dt><a href="#introduction">Introduction</a></dt>
<dt><a href="#functions">Functions</a>
<dt><a href="#functions">Functions</a></dt>
<dd>
<dl class="page-index">
<dt><a href="#make_getter-spec">make_getter</a>
<dt><a href="#make_getter-spec">make_getter</a></dt>
<dt><a href="#make_setter-spec">make_setter</a>
<dt><a href="#make_setter-spec">make_setter</a></dt>
</dl>
</dd>
<dt><a href="#examples">Example</a>
<dt><a href="#examples">Example</a></dt>
</dl>
<hr>
<h2><a name="introduction"></a>Introduction</h2>
<p><code><a href="#make_getter-spec">make_getter</a>()</code> and
<code><a href="#make_setter-spec">make_setter</a>()</code> are
the functions used internally by <code>class_&lt;&gt;::<a href=
<code><a href="#make_setter-spec">make_setter</a>()</code> are the
functions used internally by <code>class_&lt;&gt;::<a href=
"class.html#class_-spec-modifiers">def_readonly</a></code> and
<code>class_&lt;&gt;::<a href=
"class.html#class_-spec-modifiers">def_readwrite</a></code> to
produce Python callable objects which wrap C++ data members.
"class.html#class_-spec-modifiers">def_readwrite</a></code> to produce
Python callable objects which wrap C++ data members.</p>
<h2><a name="functions"></a>Functions</h2>
<pre>
<a name="make_getter-spec">template &lt;class C, class D&gt;</a>
objects::function* make_getter(D C::*pm);
<a href="object.html#object-spec">object</a> make_getter(D C::*pm);
template &lt;class C, class D, class Policies&gt;
objects::function* make_getter(D C::*pm, Policies const&amp; policies);
<a href=
"object.html#object-spec">object</a> make_getter(D C::*pm, Policies const&amp; policies);
</pre>
<dl class="function-semantics">
<dt><b>Requires:</b> <code>Policies</code> is a model of <a
href="CallPolicies.html">CallPolicies</a>.
<dt><b>Requires:</b> <code>Policies</code> is a model of <a href=
"CallPolicies.html">CallPolicies</a>.</dt>
<dt><b>Effects:</b> Creates a Python callable object which
accepts a single argument that can be converted
<code>from_python</code> to <code>C*</code>, and returns the
corresponding member <code>D</code> member of the <code>C</code>
object, converted <code>to_python</code>. If
<code>policies</code> is supplied, it will be applied to the
function as described <a href=
"CallPolicies.html">here</a>.
<dt><b>Effects:</b> Creates a Python callable object which accepts a
single argument that can be converted <code>from_python</code> to
<code>C*</code>, and returns the corresponding member <code>D</code>
member of the <code>C</code> object, converted <code>to_python</code>.
If <code>policies</code> is supplied, it will be applied to the
function as described <a href="CallPolicies.html">here</a>.</dt>
<dt><b>Returns:</b> A pointer convertible to <code>PyObject*</code> which
refers to the new Python callable object.
<dt><b>Returns:</b> An instance of <a href=
"object.html#object-spec">object</a> which holds the new Python
callable object.</dt>
</dl>
<pre>
<a name="make_setter-spec">template &lt;class C, class D&gt;</a>
objects::function* make_setter(D C::*pm);
<a href="object.html#object-spec">object</a> make_setter(D C::*pm);
template &lt;class C, class D, class Policies&gt;
objects::function* make_setter(D C::*pm, Policies const&amp; policies);
<a href=
"object.html#object-spec">object</a> make_setter(D C::*pm, Policies const&amp; policies);
</pre>
<dl class="function*-semantics">
<dt><b>Requires:</b> <code>Policies</code> is a model of <a
href="CallPolicies.html">CallPolicies</a>.
<dt><b>Requires:</b> <code>Policies</code> is a model of <a href=
"CallPolicies.html">CallPolicies</a>.</dt>
<dt><b>Effects:</b> Creates a Python callable object which, when
called from Python, expects two arguments which can be converted
<dt><b>Effects:</b> Creates a Python callable object which, when called
from Python, expects two arguments which can be converted
<code>from_python</code> to <code>C*</code> and
<code>D&nbsp;const&amp;</code>, respectively, and sets the
corresponding <code>D</code> member of the <code>C</code>
object. If <code>policies</code> is supplied, it will be applied
to the function as described <a
href="CallPolicies.html">here</a>.
corresponding <code>D</code> member of the <code>C</code> object. If
<code>policies</code> is supplied, it will be applied to the function
as described <a href="CallPolicies.html">here</a>.</dt>
<dt><b>Returns:</b> A pointer convertible to
<code>PyObject*</code> which refers to the new Python callable
object.
<dt><b>Returns:</b> An instance of <a href=
"object.html#object-spec">object</a> which holds the new Python
callable object.</dt>
</dl>
<h2><a name="examples"></a>Example</h2>
<p>The code below uses make_getter and make_setter to expose a
data member as functions:
<p>The code below uses make_getter and make_setter to expose a data
member as functions:</p>
<pre>
#include &lt;boost/python/data_members.hpp&gt;
#include &lt;boost/python/module.hpp&gt;
@@ -119,14 +128,10 @@ using namespace boost::python;
BOOST_PYTHON_MODULE_INIT(data_members_example)
{
module("data_members_example")
.add(
class_&lt;X&gt;(&quot;X&quot;)
.def_init(args&lt;int&gt;())
.def(&quot;get&quot;, make_getter(&amp;X::y))
.def(&quot;set&quot;, make_setter(&amp;X::y))
)
;
class_&lt;X&gt;("X", init&lt;int&gt;())
.def("get", make_getter(&amp;X::y))
.def("set", make_setter(&amp;X::y))
;
}
</pre>
It can be used this way in Python:
@@ -142,9 +147,13 @@ BOOST_PYTHON_MODULE_INIT(data_members_example)
<p>
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
8 May 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
29 September 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
Abrahams</a> 2002. All Rights Reserved.</i>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</i></p>
</body>
</html>

129
doc/v2/definitions.html
View File

@@ -1,35 +1,100 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - Definitions</title>
</head>
<body link="#0000ff" vlink="#800080">
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - Definitions</title>
</head>
<body link="#0000ff" vlink="#800080">
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt=
"C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Definitions</h2>
</td>
</tr>
</table>
<hr>
<dl class="definitions">
<dt><b>{{term}}:</b> {{definition}}</dt>
<dt><b>{{term}}:</b> {{definition}}</dt>
</dl>
<hr>
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
05 November, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a>
2002. All Rights Reserved.</i></p>
</body>
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Definitions</h2>
</td>
</tr>
</table>
<hr>
<dl class="definitions">
<dt><b><a name="arity">arity</a>:</b> The number of arguments accepted
by a function or member function. Unless otherwise specified, the
hidden "<code>this</code>" argument to member functions is not counted
when specifying arity</dt>
<dd><br>
</dd>
<dt><b><a name="ntbs">ntbs</a>:</b> Null-Terminated Byte String, or
`C'-string. C++ string literals are <strong>ntbs</strong>es. An
<strong>ntbs</strong> must never be null.</dt>
<dd><br>
</dd>
<dt><b><a name="raise">raise</a>:</b> Exceptions in Python are
"raised", not "thrown", as they are in C++. When this documentation
says that some Python exception is "raised" in the context of C++ code,
it means that the corresponding Python exception is set via the <a
href=
"http://www.python.org/doc/current/api/exceptionHandling.html">Python/'C'
API</a>, and <code><a href=
"errors.html#throw_error_already_set-spec">throw_error_already_set</a>()</code>
is called.</dt>
<dd><br>
</dd>
<dt><b><a name="POD">POD</a>:</b> A technical term from the C++
standard. Short for "Plain Ol'Data": A POD-struct is an aggregate class
that has no non-static data members of type pointer to member,
non-POD-struct, non-POD-union (or array of such types) or reference,
and has no user-defined copy assign- ment operator and no user-defined
destructor. Similarly, a POD-union is an aggregate union that has no
non-static data members of type pointer to member, non-POD-struct,
non-POD-union (or array of such types) or reference, and has no
user-defined copy assignment operator and no user-defined destructor. A
POD class is a class that is either a POD-struct or a POD-union. An
aggregate is an array or a class (clause 9) with no user-declared
constructors (12.1), no private or protected non-static data members
(clause 11), no base classes (clause 10), and no virtual functions
(10.3).</dt>
<dd><br>
</dd>
<dt><b><a name="ODR">ODR</a>:</b> The &quot;One Definition
Rule&quot;, which says that any entity in a C++ program must have the same definition in all translation units (object files) which make up a program.
</dt>
<dd><br>
</dd>
</dl>
<hr>
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
03 October, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</i></p>
</body>
</html>

174
doc/v2/errors.html
View File

@@ -1,53 +1,68 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<meta name="generator" content="HTML Tidy, see www.w3.org">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - &lt;boost/python/errors.hpp&gt;</title>
</head>
<body>
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt=
"C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Header &lt;boost/python/errors.hpp&gt;</h2>
</td>
</tr>
</table>
<hr>
<h2>Contents</h2>
<dl class="page-index">
<dt><a href="#introduction">Introduction</a>
<dt><a href="#introduction">Introduction</a></dt>
<dt><a href="#classes">Classes</a>
<dt><a href="#classes">Classes</a></dt>
<dd>
<dl class="page-index">
<dt><a href="#error_already_set-spec">Class <code>error_already_set</code></a>
<dt><a href="#error_already_set-spec">Class
<code>error_already_set</code></a></dt>
<dd>
<dl class="page-index">
<dt><a href="#error_already_set-spec-synopsis">Class
<code>error_already_set</code> synopsis</a>
<code>error_already_set</code> synopsis</a></dt>
</dl>
</dd>
</dl>
</dd>
<dt><a href="#functions">Functions</a>
<dt><a href="#functions">Functions</a></dt>
<dd>
<dl class="page-index">
<dt><a href="#handle_exception-spec">handle_exception</a>
<dt><a href="#handle_exception-spec">handle_exception</a></dt>
<dt><a href="#expect_non_null-spec">expect_non_null</a>
<dt><a href="#throw_error_already_set-spec">throw_error_already_set</a>
<dt><a href="#expect_non_null-spec">expect_non_null</a></dt>
<dt><a href=
"#throw_error_already_set-spec">throw_error_already_set</a></dt>
</dl>
</dd>
<dt><a href="#examples">Examples</a>
<dt><a href="#examples">Examples</a></dt>
</dl>
<hr>
@@ -56,20 +71,24 @@
<p><code>&lt;boost/python/errors.hpp&gt;</code> provides types and
functions for managing and translating between Python and C++ exceptions.
This is relatively low-level functionality that is mostly used internally
by Boost.Python. Users should seldom need it.
by Boost.Python. Users should seldom need it.</p>
<h2><a name="classes"></a>Classes</h2>
<h3><a name="error_already_set-spec"></a>Class
<code>error_already_set</code></h3>
<p><code>error_already_set</code> is an exception type which can be thrown
to indicate that a Python error has occurred. If thrown, the precondition
is that <a href=
<p><code>error_already_set</code> is an exception type which can be
thrown to indicate that a Python error has occurred. If thrown, the
precondition is that <a href=
"http://www.python.org/doc/2.2/api/exceptionHandling.html#l2h-71">PyErr_Occurred()</a>
returns a value convertible to <code>true</code>.
returns a value convertible to <code>true</code>. Portable code shouldn't
throw this exception type directly, but should instead use <code><a href=
"#throw_error_already_set-spec">throw_error_already_set</a>()</code>,
below.</p>
<h4><a name="error_already_set-spec-synopsis"></a>Class error_already_set synopsis</h4>
<h4><a name="error_already_set-spec-synopsis"></a>Class error_already_set
synopsis</h4>
<pre>
namespace boost { namespace python
{
@@ -86,84 +105,100 @@ void handle_exception() throw();
</pre>
<dl class="handle_exception-semantics">
<dt><b>Requires:</b> The first form requires that the expression <code><a
href=
<dt><b>Requires:</b> The first form requires that the expression
<code><a href=
"../../../function/doc/reference.html#functionN">function0</a>&lt;void&gt;(f)</code>
is valid. The second form requires that a C++ exception is currently
being handled (see section 15.1 in the C++ standard).
being handled (see section 15.1 in the C++ standard).</dt>
<dt><b>Effects:</b> The first form calls <code>f()</code> inside a
<code>try</code> block whose <code>catch</code> clauses set an
appropriate Python exception for the C++ exception caught, returning
<code>true</code> if an exception was caught, <code>false</code>
otherwise. The second form passes a function which rethrows the exception
currently being handled to the first form.
<code>try</code> block which first attempts to use all registered <a
href="exception_translator.html">exception translators</a>. If none of
those translates the exception, the <code>catch</code> clauses then set
an appropriate Python exception for the C++ exception caught, returning
<code>true</code> if an exception was thrown, <code>false</code>
otherwise. The second form passes a function which rethrows the
exception currently being handled to the first form.</dt>
<dt><b>Postconditions:</b> No exception is being handled
<dt><b>Postconditions:</b> No exception is being handled</dt>
<dt><b>Throws:</b> nothing
<dt><b>Throws:</b> nothing</dt>
<dt><b>Rationale:</b> At inter-language boundaries it is important to
ensure that no C++ exceptions escape, since the calling language usually
doesn't have the equipment neccessary to properly unwind the stack. Use
<code>handle_exception</code> to manage exception translation whenever
your C++ code is called directly from the Python API. This is done for
you automatically by the usual function wrapping facilities: <a href=
"make_function.html#make_function-spec">make_function()</a>, <a href=
"make_function.html#make_constructor-spec">make_constructor()</a>, <a
href="module.html#def-spec">module::def</a> and <a href=
"class.html#def-spec">class_::def</a>). The second form can be more
convenient to use (see the <a href="#examples">example</a> below), but
various compilers have problems when exceptions are rethrown from within
an enclosing <code>try</code> block.
ensure that no C++ exceptions escape, since the calling language
usually doesn't have the equipment neccessary to properly unwind the
stack. Use <code>handle_exception</code> to manage exception
translation whenever your C++ code is called directly from the Python
API. This is done for you automatically by the usual function wrapping
facilities: <code><a href=
"make_function.html#make_function-spec">make_function</a>()</code>,
<code><a href=
"make_function.html#make_constructor-spec">make_constructor</a>()</code>,
<code><a href="def.html#def-spec">def</a>()</code> and <code><a href=
"class.html#def-spec">class_::def</a>()</code>. The second form can be
more convenient to use (see the <a href="#examples">example</a> below),
but various compilers have problems when exceptions are rethrown from
within an enclosing <code>try</code> block.</dt>
</dl>
<pre>
<a name="expect_non_null-spec">template &lt;class T&gt; T* expect_non_null(T* x);</a>
<a name=
"expect_non_null-spec">template &lt;class T&gt; T* expect_non_null(T* x);</a>
</pre>
<dl class="expect_non_null-semantics">
<dt><b>Returns:</b> <code>x</code>
<dt><b>Returns:</b> <code>x</code></dt>
<dt><b>Throws:</b> <code><a href=
"#error_already_set-spec">error_already_set()</a></code> iff <code>x ==
0</code>.
"#error_already_set-spec">error_already_set</a>()</code> iff <code>x ==
0</code>.</dt>
<dt><b>Rationale:</b> Simplifies error-handling when calling many
functions in the <a href=
"http://www.python.org/doc/2.2/api/api.html">Python/C API</a>, which
return 0 on error.
<dt><b>Rationale:</b> Simplifies error-handling when calling functions
in the <a href="http://www.python.org/doc/2.2/api/api.html">Python/C
API</a> which return 0 on error.</dt>
</dl>
<pre>
<a name="throw_error_already_set-spec">void throw_error_already_set();</a>
</pre>
<dl class="throw_error_already_set-semantics">
<dt><b>Effects:</b> <code>throw&nbsp;<a href=
"#error_already_set-spec">error_already_set</a>();</code>
"#error_already_set-spec">error_already_set</a>();</code></dt>
</dl>
<dl>
<dt><b>Rationale:</b> Many platforms and compilers are not able to
consistently catch exceptions thrown across shared library boundaries.
Using this function from the Boost.Python library ensures that the
appropriate <code>catch</code> block in <code><a href=
"#handle_exception-spec">handle_exception</a>()</code> can catch the
exception.</dt>
</dl>
<h2><a name="examples"></a>Examples</h2>
<pre>
#include &lt;string&gt;
#include &lt;boost/python/errors.hpp&gt;
#include &lt;boost/python/reference.hpp&gt;
#include &lt;boost/python/object.hpp&gt;
#include &lt;boost/python/handle.hpp&gt;
// Returns a std::string which has the same value as obj's "__name__"
// attribute.
std::string get_name(boost::python::ref obj)
std::string get_name(boost::python::object obj)
{
// throws if there's no __name__ attribute
PyObject* p = boost::python::expect_non_null(
PyObject_GetAttrString(obj.get(), "__name__"));
PyObject_GetAttrString(obj.ptr(), "__name__"));
char const* s = PyString_AsString(p);
if (s != 0)
Py_DECREF(p);
// throws if it's not a Python string
std::string result(
boost::python::expect_non_null(
PyString_AsString(p)));
Py_XDECREF(p); // Done with p
Py_DECREF(p); // Done with p
return result;
}
@@ -172,12 +207,19 @@ std::string get_name(boost::python::ref obj)
// Demonstrate form 1 of handle_exception
//
// Place a Python Int object whose value is 1 if a and b have
// Place into result a Python Int object whose value is 1 if a and b have
// identical "__name__" attributes, 0 otherwise.
void same_name_impl(PyObject*&amp; result, PyObject* a, PyObject* b)
void same_name_impl(PyObject*&amp; result, boost::python::object a, boost::python::object b)
{
result = PyInt_FromLong(
get_name(boost::python::ref(a1)) == get_name(boost::python::ref(a2)));
get_name(a) == get_name(a2));
}
object borrowed_object(PyObject* p)
{
return boost::python::object(
boost::python::handle&lt;&gt;(
boost::python::borrowed(a1)));
}
// This is an example Python 'C' API interface function
@@ -194,7 +236,7 @@ same_name(PyObject* args, PyObject* keywords)
// Use boost::bind to make an object compatible with
// boost::Function0&lt;void&gt;
if (boost::python::handle_exception(
boost::bind&lt;void&gt;(same_name_impl, boost::ref(result), a1, a2)))
boost::bind&lt;void&gt;(same_name_impl, boost::ref(result), borrowed_object(a1), borrowed_object(a2))))
{
// an exception was thrown; the Python error was set by
// handle_exception()
@@ -217,9 +259,10 @@ same_name2(PyObject* args, PyObject* keywords)
if (!PyArg_ParseTuple(args, const_cast&lt;char*&gt;("OO"), &amp;a1, &amp;a2))
return 0;
try {
return PyInt_FromLong(
get_name(boost::python::ref(a1)) == get_name(boost::python::ref(a2)));
get_name(borrowed_object(a1)) == get_name(borrowed_object(a2)));
}
catch(...)
{
@@ -232,10 +275,13 @@ same_name2(PyObject* args, PyObject* keywords)
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
17 November, 2002
29 September, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
Abrahams</a> 2002. All Rights Reserved.</i>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</i></p>
</body>
</html>

199
doc/v2/faq.html
View File

@@ -1,39 +1,166 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - FAQ</title>
</head>
<body link="#0000ff" vlink="#800080">
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - FAQ</title>
</head>
<body link="#0000ff" vlink="#800080">
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt=
"C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Frequently Asked Questions (FAQs)</h2>
</td>
</tr>
</table>
<hr>
<dl class="page-index">
<dt><a href="#question1">{{question}}</a></dt>
<dt><a href="#question2">{{question}}</a></dt>
</dl>
<h2><a name="question1"></a>{{question}}</h2>
<p>{{answer}}</p>
<h2><a name="question2"></a>{{question}}</h2>
<p>{{answer}}</p>
<hr>
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
05 November, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a>
2002. All Rights Reserved.</i></p>
</body>
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Frequently Asked Questions (FAQs)</h2>
</td>
</tr>
</table>
<hr>
<dl class="page-index">
<dt><a href="#question1">Is return_internal reference
efficient?</a></dt>
<dt><a href="#question2">How can I which take C++ containers as
arguments?</a></dt>
</dl>
<h2><a name="question1"></a>Is return_internal reference efficient?</h2>
<blockquote>
<b>Q:</b> <i>I have an object composed of 12 doubles. A const&amp; to
this object is returned by a member function of another class. From the
viewpoint of using the returned object in Python I do not care if I get
a copy or a reference to the returned object. In Boost.Python Version 2
I have the choice of using copy_const_reference or
return_internal_reference. Are there considerations that would lead me
to prefer one over the other, such as size of generated code or memory
overhead?</i>
<p><b>A:</b> copy_const_reference will make an instance with storage
for one of your objects, size = base_size + 12 * sizeof(double).
return_internal_reference will make an instance with storage for a
pointer to one of your objects, size = base_size + sizeof(void*).
However, it will also create a weak reference object which goes in the
source object's weakreflist and a special callback object to manage the
lifetime of the internally-referenced object. My guess?
copy_const_reference is your friend here, resulting in less overall
memory use and less fragmentation, also probably fewer total
cycles.</p>
</blockquote>
<h2><a name="question2"></a>How can I wrap functions which take C++
containers as arguments?</h2>
<p>Ralf W. Grosse-Kunstleve provides these notes:</p>
<ol>
<li>
Using the regular <code>class_&lt;&gt;</code> wrapper:
<pre>
class_&lt;std::vector&lt;double&gt; &gt;("std_vector_double")
.def(...)
...
;
</pre>
This can be moved to a template so that several types (double, int,
long, etc.) can be wrapped with the same code. This technique is used
in the file
<blockquote>
scitbx/include/scitbx/array_family/boost_python/flex_wrapper.h
</blockquote>
in the "scitbx" package. The file could easily be modified for
wrapping std::vector&lt;&gt; instantiations.
<p>This type of C++/Python binding is most suitable for containers
that may contain a large number of elements (&gt;10000).</p>
</li>
<li>
Using custom rvalue converters. Boost.Python "rvalue converters"
match function signatures such as:
<pre>
void foo(std::vector&lt;double&gt; const&amp; array); // pass by const-reference
void foo(std::vector&lt;double&gt; array); // pass by value
</pre>
Some custom rvalue converters are implemented in the file
<blockquote>
scitbx/include/scitbx/boost_python/container_conversions.h
</blockquote>
This code can be used to convert from C++ container types such as
std::vector&lt;&gt; or std::list&lt;&gt; to Python tuples and vice
versa. A few simple examples can be found in the file
<blockquote>
scitbx/array_family/boost_python/regression_test_module.cpp
</blockquote>
Automatic C++ container &lt;-&gt; Python tuple conversions are most
suitable for containers of moderate size. These converters generate
significantly less object code compared to alternative 1 above.
</li>
</ol>
A disadvantage of using alternative 2 is that operators such as
arithmetic +,-,*,/,% are not available. It would be useful to have custom
rvalue converters that convert to a "math_array" type instead of tuples.
This is currently not implemented but is possible within the framework of
Boost.Python V2 as it will be released in the next couple of weeks. [ed.:
this was posted on 2002/03/10]
<p>It would also be useful to also have "custom lvalue converters" such
as std::vector&lt;&gt; &lt;-&gt; Python list. These converters would
support the modification of the Python list from C++. For example:</p>
<p>C++:</p>
<pre>
void foo(std::vector&lt;double&gt;&amp; array)
{
for(std::size_t i=0;i&lt;array.size();i++) {
array[i] *= 2;
}
}
</pre>
Python:
<pre>
&gt;&gt;&gt; l = [1, 2, 3]
&gt;&gt;&gt; foo(l)
&gt;&gt;&gt; print l
[2, 4, 6]
</pre>
Custom lvalue converters require changes to the Boost.Python core library
and are currently not available.
<p>P.S.:</p>
<p>The "scitbx" files referenced above are available via anonymous
CVS:</p>
<pre>
cvs -d:pserver:anonymous@cvs.cctbx.sourceforge.net:/cvsroot/cctbx login
cvs -d:pserver:anonymous@cvs.cctbx.sourceforge.net:/cvsroot/cctbx co scitbx
</pre>
<hr>
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
05 November, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</i></p>
</body>
</html>

155
doc/v2/has_back_reference.html
View File

@@ -1,77 +1,82 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<meta name="generator" content="HTML Tidy, see www.w3.org">
<meta http-equiv="Content-Type" content=
"text/html; charset=iso-8859-1">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python -
&lt;boost/python/has_back_reference.hpp&gt;</title>
<style type="text/css">
<title>Boost.Python - &lt;boost/python/has_back_reference.hpp&gt;</title>
<style type="text/css">
p.c3 {font-style: italic}
h2.c2 {text-align: center}
h1.c1 {text-align: center}
</style>
</style>
</head>
<table border="0" cellpadding="7" cellspacing="0" width=
"100%" summary="header">
<body>
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86"
width="277" alt="C++ Boost" src=
"../../../../c++boost.gif" border="0"></a></h3>
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 class="c1">Boost.Python</h1>
<h2 class="c2">Header
&lt;boost/python/has_back_reference.hpp&gt;</h2>
</td>
</tr>
</table>
<hr>
<h2>Contents</h2>
<dl class="page-index">
<dt><a href="#introduction">Introduction</a>
<dt><a href="#introduction">Introduction</a></dt>
<dt><a href="#classes">Classes</a>
<dt><a href="#classes">Classes</a></dt>
<dd>
<dl class="page-index">
<dt><a href="#has_back_reference-spec">Class template
<code>has_back_reference</code></a>
<code>has_back_reference</code></a></dt>
<dd>
<dl class="page-index">
<dt><a href=
"#has_back_reference-spec-synopsis">Class template
<code>has_back_reference</code> synopsis</a>
<dt><a href="#has_back_reference-spec-synopsis">Class template
<code>has_back_reference</code> synopsis</a></dt>
</dl>
</dd>
<dt><a href="#examples">Example(s)</a>
<dt><a href="#examples">Example(s)</a></dt>
</dl>
</dd>
</dl>
<hr>
<h2><a name="introduction"></a>Introduction</h2>
<p><code>&lt;boost/python/has_back_reference.hpp&gt;</code>
defines the traits class template
<code>has_back_reference&lt;&gt;</code>, which can be
specialized by the user to indicate that a wrapped class
instance holds a <code>PyObject*</code> corresponding to a
Python object.
<p><code>&lt;boost/python/has_back_reference.hpp&gt;</code> defines the
traits class template <code>has_back_reference&lt;&gt;</code>, which can
be specialized by the user to indicate that a wrapped class instance
holds a <code>PyObject*</code> corresponding to a Python object.</p>
<h2><a name="classes"></a>Classes</h2>
<h3><a name="has_back_reference-spec"></a>Class template
<code>has_back_reference</code></h3>
<p>A unary metafunction whose <code>value</code> is true iff
its argument is a <code>pointer_wrapper&lt;&gt;</code>.
<p>A unary metafunction whose <code>value</code> is true iff its argument
is a <code>pointer_wrapper&lt;&gt;</code>.</p>
<h4><a name="has_back_reference-spec-synopsis"></a>Class
template <code>has_back_reference</code> synopsis</h4>
<h4><a name="has_back_reference-spec-synopsis"></a>Class template
<code>has_back_reference</code> synopsis</h4>
<pre>
namespace boost { namespace python
{
@@ -82,36 +87,33 @@ namespace boost { namespace python
}}
</pre>
<p>A &quot;<a href=
"../../../../more/generic_programming.html#traits">traits
class</a>&quot; which is inspected by Boost.Python to
determine how wrapped classes can be constructed.
<p>A "<a href="../../../../more/generic_programming.html#traits">traits
class</a>" which is inspected by Boost.Python to determine how wrapped
classes can be constructed.</p>
<dl class="traits-semantics">
<dt><code>value</code> is an integral constant convertible
to bool of unspecified type.
<dt><code>value</code> is an integral constant convertible to bool of
unspecified type.</dt>
<dt>Specializations may substitute a value convertible to
<code>true</code> for <code>value</code> iff for each invocation of
<code>class_&lt;WrappedClass&gt;::def_init(args&lt;</code><i>type-sequence...</i><code>&gt;())</code>,
there exists a corresponding constructor
<code>WrappedClass::WrappedClass(PyObject*,&nbsp;</code><i>type-sequence...</i><code>)</code>. If
such a specialization exists, the <code>WrappedClass</code>
constructors will be called with a &quot;back reference&quot; pointer
to the corresponding Python object whenever they are invoked from
Python.
<code>true</code> for <code>value</code> iff for each invocation of
<code>class_&lt;WrappedClass&gt;::def(init&lt;</code><i>type-sequence...</i><code>
&gt;())</code>, there exists a corresponding constructor
<code>WrappedClass::WrappedClass(PyObject*,&nbsp;</code><i>type-sequence...</i>
<code>)</code>. If such a specialization exists, the
<code>WrappedClass</code> constructors will be called with a "back
reference" pointer to the corresponding Python object whenever they are
invoked from Python.</dt>
</dl>
<h2><a name="examples"></a>Example</h2>
<h3>C++ module definition</h3>
<h3>C++ module definition</h3>
<pre>
#include &lt;boost/python/class.hpp&gt;
#include &lt;boost/python/module.hpp&gt;
#include &lt;boost/python/has_back_reference.hpp&gt;
#include &lt;boost/python/handle.hpp&gt;
#include &lt;boost/shared_ptr.hpp&gt;
using namespace boost::python;
@@ -121,7 +123,7 @@ struct X
X(PyObject* self) : m_self(self), m_x(0) {}
X(PyObject* self, int x) : m_self(self), m_x(x) {}
PyObject* self() { return m_self; }
handle&lt;&gt; self() { return handle&lt;&gt;(borrowed(m_self)); }
int get() { return m_x; }
void set(int x) { m_x = x; }
@@ -151,36 +153,29 @@ struct Y
boost::shared_ptr&lt;Y&gt; Y_self(boost::shared_ptr&lt;Y&gt; self) const { return self; }
BOOST_PYTHON_MODULE_INIT(back_references)
BOOST_PYTHON_MODULE(back_references)
{
module(&quot;back_references&quot;)
.add(
class_&lt;X&gt;(&quot;X&quot;)
.def_init()
.def_init(args&lt;int&gt;())
.def(&quot;self&quot;, &amp;X::self)
.def(&quot;get&quot;, &amp;X::get)
.def(&quot;set&quot;, &amp;X::set)
)
.add(
class_&lt;Y, shared_ptr&lt;Y&gt; &gt;(&quot;Y&quot;)
.def_init()
.def_init(args&lt;int&gt;())
.def(&quot;get&quot;, &amp;Y::get)
.def(&quot;set&quot;, &amp;Y::set)
.def(&quot;self&quot;, Y_self)
)
;
class_&lt;X&gt;("X")
.def(init&lt;int&gt;())
.def("self", &amp;X::self)
.def("get", &amp;X::get)
.def("set", &amp;X::set)
;
class_&lt;Y, shared_ptr&lt;Y&gt; &gt;("Y")
.def(init&lt;int&gt;())
.def("get", &amp;Y::get)
.def("set", &amp;Y::set)
.def("self", Y_self)
;
}
</pre>
The following Python session illustrates that <code>x.self()</code>
returns the same Python object on which it is invoked, while
<code>y.self()</code> must create a new Python object which refers to the
same Y instance.
The following Python session illustrates that <code>x.self()</code>
returns the same Python object on which it is invoked, while
<code>y.self()</code> must create a new Python object which refers to
the same Y instance.
<h3>Python code</h3>
<h3>Python code</h3>
<pre>
&gt;&gt;&gt; from back_references import *
&gt;&gt;&gt; x = X(1)
@@ -207,11 +202,13 @@ the same Y instance.
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
07 May, 2002
29 September, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p class="c3">&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a>
2002. All Rights Reserved.
<p class="c3">&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</p>
</body>
</html>

108
doc/v2/implicit.html
View File

@@ -1,51 +1,60 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<meta name="generator" content="HTML Tidy, see www.w3.org">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - &lt;boost/python/implicit.hpp&gt;</title>
</head>
<body>
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt=
"C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Header &lt;boost/python/implicit.hpp&gt;</h2>
</td>
</tr>
</table>
<hr>
<h2>Contents</h2>
<dl function="page-index">
<dt><a href="#introduction">Introduction</a>
<dl class="page-index">
<dt><a href="#introduction">Introduction</a></dt>
<dt><a href="#functions">Functions</a>
<dt><a href="#functions">Functions</a></dt>
<dd>
<dl function="page-index">
<dt><a href="#implicitly_convertible-spec">Function Template <code>implicitly_convertible</code></a>
<dl class="page-index">
<dt><a href="#implicitly_convertible-spec">Function Template
<code>implicitly_convertible</code></a></dt>
</dl>
</dd>
<dt><a href="#examples">Example</a>
<dt><a href="#examples">Example</a></dt>
</dl>
<hr>
<h2><a name="introduction"></a>Introduction</h2>
<code>implicitly_convertible</code> allows Boost.Python to
implicitly take advantage of a C++ implicit or explicit conversion
when matching Python objects to C++ argument types.
<code>implicitly_convertible</code> allows Boost.Python to implicitly
take advantage of a C++ implicit or explicit conversion when matching
Python objects to C++ argument types.
<h2><a name="functions"></a>Functions</h2>
<h3><a name="implicitly_convertible-spec"></a>Function template <code>implicitly_convertible</code></h3>
<h3><a name="implicitly_convertible-spec"></a>Function template
<code>implicitly_convertible</code></h3>
<pre>
template &lt;class Source, class Target&gt;
void implicitly_convertible();
@@ -55,40 +64,42 @@ void implicitly_convertible();
<caption>
<b><code>implicitly_convertible</code> template parameters</b><br>
</caption>
<tr>
<th>Parameter
<th>Description
<tr>
<td><code>Source</code>
<td>The source type of the implicit conversion
<th>Parameter</th>
<th>Description</th>
</tr>
<tr>
<td><code>Target</code>
<td>The target type of the implicit conversion
<td><code>Source</code></td>
<td>The source type of the implicit conversion</td>
</tr>
<tr>
<td><code>Target</code></td>
<td>The target type of the implicit conversion</td>
</tr>
</table>
<dl class="function-semantics">
<dt><b>Requires:</b> The expression <code>Target(s)</code>,
where <code>s</code> is of type <code>Source</code>, is valid.
<dt><b>Requires:</b> The declaration <code>Target t(s);</code>, where
<code>s</code> is of type <code>Source</code>, is valid.</dt>
<dt><b>Effects:</b> registers an rvalue <code>from_python</code>
converter to <code>Target</code> which can succeed for any
<code>PyObject*&nbsp;p</code> iff there exists any registered
converter which can produce <code>Source</code> rvalues
<code>PyObject*&nbsp;p</code> iff there exists any registered converter
which can produce <code>Source</code> rvalues</dt>
<dt><b>Rationale:</b> C++ users expect to be able to take
advantage of the same sort of interoperability in Python as they
do in C++.
<dt><b>Rationale:</b> C++ users expect to be able to take advantage of
the same sort of interoperability in Python as they do in C++.</dt>
</dl>
<h2><a name="examples"></a>Example</h2>
<h3>C++ module definition</h3>
<h3>C++ module definition</h3>
<pre>
#include &lt;boost/python/class.hpp&gt;
#include &lt;boost/python/implicit.hpp&gt;
@@ -110,23 +121,21 @@ int x_value(X const&amp; x)
X make_x(int n) { return X(n); }
BOOST_PYTHON_MODULE_INIT(implicit_ext)
BOOST_PYTHON_MODULE(implicit_ext)
{
module(&quot;implicit_ext&quot;)
.def(&quot;x_value&quot;, x_value)
.def(&quot;make_x&quot;, make_x)
.add(
class_&lt;X&gt;(&quot;X&quot;)
.def_init(args&lt;int&gt;())
)
def("x_value", x_value);
def("make_x", make_x);
class_&lt;X&gt;("X",
init&lt;int&gt;())
;
implicitly_convertible&lt;X,int&gt;();
implicitly_convertible&lt;int,X&gt;();
}
</pre>
<h3>Python code</h3>
<h3>Python code</h3>
<pre>
&gt;&gt;&gt; from implicit_ext import *
&gt;&gt;&gt; x_value(X(42))
@@ -140,10 +149,13 @@ BOOST_PYTHON_MODULE_INIT(implicit_ext)
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
08 May, 2002
29 September, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
Abrahams</a> 2002. All Rights Reserved.</i>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</i></p>
</body>
</html>

407
doc/v2/iterator.html
View File

@@ -1,216 +1,239 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<meta name="generator" content="HTML Tidy, see www.w3.org">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - &lt;boost/python/iterator.hpp&gt;</title>
</head>
<body>
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt=
"C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Header &lt;boost/python/iterator.hpp&gt;</h2>
</td>
</tr>
</table>
<hr>
<h2>Contents</h2>
<dl class="page-index">
<dt><a href="#introduction">Introduction</a>
<dt><a href="#introduction">Introduction</a></dt>
<dt><a href="#classes">Classes</a>
<dt><a href="#classes">Classes</a></dt>
<dd>
<dl class="page-index">
<dt><a href="#iterator-spec">Class template <code>iterator</code></a>
<dt><a href="#iterator-spec">Class template
<code>iterator</code></a></dt>
<dd>
<dl class="page-index">
<dt><a href="#iterator-spec-synopsis">Class
<code>iterator</code> synopsis</a>
<code>iterator</code> synopsis</a></dt>
<dt><a href="#iterator-spec-ctors">Class template <code>iterator</code>
constructor</a>
<dt><a href="#iterator-spec-ctors">Class template
<code>iterator</code> constructor</a></dt>
</dl>
</dl>
</dd>
</dl>
<dl class="page-index">
<dt><a href="#iterators-spec">Class template <code>iterators</code></a>
<dt><a href="#iterators-spec">Class template
<code>iterators</code></a></dt>
<dd>
<dl class="page-index">
<dt><a href="#iterators-spec-synopsis">Class
<code>iterators</code> synopsis</a>
<dt><a href="#iterators-spec-types">Class template
<code>iterators</code> nested types</a>
<dt><a href="#iterators-spec-statics">Class template
<code>iterators</code> static functions</a>
</dl>
</dl>
<code>iterators</code> synopsis</a></dt>
<dt><a href="#functions">Functions</a>
<dt><a href="#iterators-spec-types">Class template
<code>iterators</code> nested types</a></dt>
<dt><a href="#iterators-spec-statics">Class template
<code>iterators</code> static functions</a></dt>
</dl>
</dd>
</dl>
</dd>
<dt><a href="#functions">Functions</a></dt>
<dd>
<dl class="page-index">
<dt><a href="#range-spec">range</a>
<dt><a href="#range-spec">range</a></dt>
</dl>
</dd>
<dt><a href="#examples">Examples</a>
<dt><a href="#examples">Examples</a></dt>
</dl>
<hr>
<h2><a name="introduction"></a>Introduction</h2>
<p><code>&lt;boost/python/iterator.hpp&gt;</code> provides types
and functions for creating <a
href="http://www.python.org/doc/current/lib/typeiter.html">Python
iterators</a> from <a
href="http://www.sgi.com/tech/stl/Container.html">C++
Containers</a> and <a
<p><code>&lt;boost/python/iterator.hpp&gt;</code> provides types and
functions for creating <a href=
"http://www.python.org/doc/current/lib/typeiter.html">Python
iterators</a> from <a href=
"http://www.sgi.com/tech/stl/Container.html">C++ Containers</a> and <a
href="http://www.sgi.com/tech/stl/Iterators.html">Iterators</a>. Note
that if your <code>class_</code> supports random-access iterators,
implementing
<code><a
href="http://www.python.org/doc/current/ref/sequence-types.html#l2h-128">__getitem__</a></code>
(also known as the Sequence Protocol) may serve you better than
using this facility: Python will automatically create an iterator
type for you (see <a
href="http://www.python.org/doc/current/lib/built-in-funcs.html#l2h-35">iter()</a>),
and each access can be range-checked, leaving no possiblity of
accessing through an invalidated C++ iterator.
implementing <code><a href=
"http://www.python.org/doc/current/ref/sequence-types.html#l2h-128">__getitem__</a></code>
(also known as the Sequence Protocol) may serve you better than using
this facility: Python will automatically create an iterator type for you
(see <a href=
"http://www.python.org/doc/current/lib/built-in-funcs.html#l2h-35">iter()</a>),
and each access can be range-checked, leaving no possiblity of accessing
through an invalidated C++ iterator.</p>
<h2><a name="classes"></a>Classes</h2>
<h3><a name="iterator-spec"></a>Class Template <code>iterator</code></h3>
<p>Instances of <code>iterator&lt;C,P&gt;</code> hold a reference
to a callable Python object which, when invoked from Python,
expects a single argument <code>c</code> convertible to
<code>C</code> and creates a Python iterator that traverses
[<code>c.begin()</code>,
<code>c.end()</code>). The optional <a
href="CallPolicies.html">CallPolicies</a>
<code>P</code> can be used to control how elements are returned
during iteration.
<p>Instances of <code>iterator&lt;C,P&gt;</code> hold a reference to a
callable Python object which, when invoked from Python, expects a single
argument <code>c</code> convertible to <code>C</code> and creates a
Python iterator that traverses [<code>c.begin()</code>,
<code>c.end()</code>). The optional <a href=
"CallPolicies.html">CallPolicies</a> <code>P</code> can be used to
control how elements are returned during iteration.</p>
<p>In the table below, <code><b>c</b></code> is an instance of <code>Container</code>.
<p>In the table below, <code><b>c</b></code> is an instance of
<code>Container</code>.</p>
<table border="1" summary="iterator template parameters">
<tr>
<th>Template Parameter
<th>Template Parameter</th>
<th>Requirements
<th>Requirements</th>
<th>Semantics
<th>Semantics</th>
<th>Default
<th>Default</th>
</tr>
<tr>
<td><code>Container</code>
<td><code>Container</code></td>
<td>[c.begin(),c.end()) is a valid <a
href="http://www.sgi.com/tech/stl/Iterators.html">Iterator
range</a>.
<td>The result will convert its argument to
<code>c</code> and call
<code>c.begin()</code> and <code>c.end()</code> to acquire
iterators. To invoke <code>Container</code>'s
<code>const</code> <code>begin()</code> and <code>end()</code>
functions, make it <code>const</code>.
<td>[c.begin(),c.end()) is a valid <a href=
"http://www.sgi.com/tech/stl/Iterators.html">Iterator range</a>.</td>
<td>The result will convert its argument to <code>c</code> and call
<code>c.begin()</code> and <code>c.end()</code> to acquire iterators.
To invoke <code>Container</code>'s <code>const</code>
<code>begin()</code> and <code>end()</code> functions, make it
<code>const</code>.</td>
</tr>
<tr>
<td><code>NextPolicies</code>
<td><code>NextPolicies</code></td>
<td>A default-constructible model of <a
href="CallPolicies.html#CallPolicies-concept">CallPolicies</a>.
<td>A default-constructible model of <a href=
"CallPolicies.html#CallPolicies-concept">CallPolicies</a>.</td>
<td>Applied to the resulting iterators' <code>next()</code> method.
<td>An unspecified model of <a
href="CallPolicies.html#CallPolicies-concept">CallPolicies</a>
which always makes a copy of the
result of deferencing the underlying C++ iterator
<td>Applied to the resulting iterators' <code>next()</code>
method.</td>
<td>An unspecified model of <a href=
"CallPolicies.html#CallPolicies-concept">CallPolicies</a> which
always makes a copy of the result of deferencing the underlying C++
iterator</td>
</tr>
</table>
<h4><a name="iterator-spec-synopsis"></a>Class Template iterator synopsis</h4>
<h4><a name="iterator-spec-synopsis"></a>Class Template iterator
synopsis</h4>
<pre>
namespace boost { namespace python
{
template &lt;class Container
, class NextPolicies = <i>unspecified</i>&gt;
struct iterator : reference&lt;PyObject*&gt;
struct iterator : <a href="object.html#object-spec">object</a>
{
iterator();
};
}}
</pre>
<h4><a name="iterator-spec-constructors"></a>Class Template
iterator constructor</h4>
<h4><a name="iterator-spec-constructors"></a>Class Template iterator
constructor</h4>
<pre>
iterator()
</pre>
<dl class="function-semantics">
<dt><b>Effects:</b> Initializes its base class with the result
of:
<dt><b>Effects:</b></dt>
<dd>
Initializes its base class with the result of:
<pre>
range&lt;NextPolicies&gt;(&amp;iterators&lt;Container&gt;::begin, &amp;iterators&lt;Container&gt;::end)
</pre>
</dd>
<dt><b>Postconditions:</b> <code>this-&gt;get()</code> points to
a Python callable object which creates a Python iterator as
described above.
<dt><b>Postconditions:</b> <code>this-&gt;get()</code> points to a
Python callable object which creates a Python iterator as described
above.</dt>
<dt><b>Rationale:</b> Provides an easy way to create iterators
for the common case where a C++ class being wrapped provides
<code>begin()</code> and <code>end()</code>.
<dt><b>Rationale:</b> Provides an easy way to create iterators for the
common case where a C++ class being wrapped provides
<code>begin()</code> and <code>end()</code>.</dt>
</dl>
<!-- -->
<!-- -->
<h3><a name="iterators-spec"></a>Class Template
<code>iterators</code></h3>
<h3><a name="iterators-spec"></a>Class Template <code>iterators</code></h3>
<p>A utility class template which provides a way to reliably call its
argument's <code>begin()</code> and <code>end()</code> member functions.
Note that there is no portable way to take the address of a member
function of a C++ standard library container, so
<code>iterators&lt;&gt;</code> can be particularly helpful when wrapping
them.</p>
<p>A utility class template which provides a way to reliably call
its argument's <code>begin()</code> and <code>end()</code> member
functions. Note that there is no portable way to take the address
of a member function of a C++ standard library container, so
<code>iterators&lt;&gt;</code> can be particularly helpful when
wrapping them.
<p>In the table below, <code><b>x</b></code> is an instance of <code>C</code>.
<p>In the table below, <code><b>x</b></code> is an instance of
<code>C</code>.</p>
<table border="1" summary="iterator template parameters">
<tr>
<th>Required Valid Expression
<th>Required Valid Expression</th>
<th>Type
<th>Type</th>
</tr>
<tr>
<td><code>x.begin()</code>
<td>Convertible to <code>C::const_iterator</code> if <code>C</code> is a
<code>const</code> type; convertible to <code>C::iterator</code> otherwise.
<td><code>x.begin()</code></td>
<td>Convertible to <code>C::const_iterator</code> if <code>C</code>
is a <code>const</code> type; convertible to <code>C::iterator</code>
otherwise.</td>
</tr>
<tr>
<td><code>x.end()</code>
<td>Convertible to <code>C::const_iterator</code> if <code>C</code> is a
<code>const</code> type; convertible to <code>C::iterator</code> otherwise.
<td><code>x.end()</code></td>
<td>Convertible to <code>C::const_iterator</code> if <code>C</code>
is a <code>const</code> type; convertible to <code>C::iterator</code>
otherwise.</td>
</tr>
</table>
<h4><a name="iterators-spec-synopsis"></a>Class Template iterators synopsis</h4>
<h4><a name="iterators-spec-synopsis"></a>Class Template iterators
synopsis</h4>
<pre>
namespace boost { namespace python
{
@@ -224,141 +247,151 @@ namespace boost { namespace python
}}
</pre>
<h4><a name="iterators-spec-types"></a>Class Template
iterators nested types</h4>
If C is a <code>const</code> type,
<h4><a name="iterators-spec-types"></a>Class Template iterators nested
types</h4>
If C is a <code>const</code> type,
<pre>
typedef typename C::const_iterator iterator;
</pre>
Otherwise:
Otherwise:
<pre>
typedef typename C::iterator iterator;
</pre>
<h4><a name="iterators-spec-statics"></a>Class Template
iterators static functions</h4>
<h4><a name="iterators-spec-statics"></a>Class Template iterators static
functions</h4>
<pre>
static iterator begin(C&amp;);
</pre>
<dl class="function-semantics">
<dt><b>Returns:</b> <code>x.begin()</code>
<dt><b>Returns:</b> <code>x.begin()</code></dt>
</dl>
<pre>
static iterator end(C&amp;);
</pre>
<dl class="function-semantics">
<dt><b>Returns:</b> <code>x.end()</code>
<dt><b>Returns:</b> <code>x.end()</code></dt>
</dl>
<!-- -->
<!-- -->
<h2><a name="functions"></a>Functions</h2>
<pre>
<a name=
"range-spec">template</a> &lt;class NextPolicies, class Target, class Accessor1, class Accessor2&gt;
reference&lt;PyObject*&gt range(Accessor1 start, Accessor2 finish);
<a href=
"object.html#object-spec">object</a> range(Accessor1 start, Accessor2 finish);
template &lt;class NextPolicies, class Accessor1, class Accessor2&gt;
reference&lt;PyObject*&gt range(Accessor1 start, Accessor2 finish);
<a href=
"object.html#object-spec">object</a> range(Accessor1 start, Accessor2 finish);
template &lt;class Accessor1, class Accessor2&gt;
reference&lt;PyObject*&gt range(Accessor1 start, Accessor2 finish);
<a href=
"object.html#object-spec">object</a> range(Accessor1 start, Accessor2 finish);
</pre>
<dl class="range-semantics">
<dt><b>Requires:</b> <code>NextPolicies</code> is a
default-constructible model of <a
href="CallPolicies.html#CallPolicies-concept">CallPolicies</a>.
default-constructible model of <a href=
"CallPolicies.html#CallPolicies-concept">CallPolicies</a>.</dt>
<dt><b>Effects:</b> <dl>
<dt><b>Effects:</b></dt>
The first form creates a Python callable
object which, when invoked, converts its argument to a
<code>Target</code> object
<code>x</code>, and creates a Python iterator which traverses
[<code><a
href="../../../bind/bind.html">bind</a>(start,_1)(x)</code>,&nbsp;<code><a
href="../../../bind/bind.html">bind</a>(finish,_1)(x)</code>),
applying <code>NextPolicies</code> to the iterator's
<code>next()</code> function.
<dd>
<dt>The second form is identical to
the first, except that <code>Target</code> is deduced from
<code>Accessor1</code> as follows:
<ol>
<li>If <code>Accessor1</code> is a function type,
<code>Target</code> is the type of its first argument.
<li>If <code>Accessor1</code> is a data member pointer of the
form <code>R&nbsp;(T::*)</code>, <code>Target</code> is
identical to <code>T</code>.
<li>If <code>Accessor1</code> is a member function pointer of
the form
<code>R&nbsp;(T::*)(</code><i>arguments...</i><code>)</code>&nbsp;<i>cv-opt</i>,
where <i>cv-opt</i> is an optional <code>cv-qualifier</code>,
<code>Target</code> is identical to <code>T</code>.
</ol>
<dd>
<dd>
<dl>
<dt>The first form creates a Python callable object which, when
invoked, converts its argument to a <code>Target</code> object
<code>x</code>, and creates a Python iterator which traverses
[<code><a href=
"../../../bind/bind.html">bind</a>(start,_1)(x)</code>,&nbsp;<code><a
href="../../../bind/bind.html">bind</a>(finish,_1)(x)</code>),
applying <code>NextPolicies</code> to the iterator's
<code>next()</code> function.</dt>
<dt>The third form is identical to the second, except that
<code>NextPolicies</code> is an unspecified model of <a
href="CallPolicies.html#CallPolicies-concept">CallPolicies</a>
which always makes a copy of the
result of deferencing the underlying C++ iterator<dd>
</dl>
<dt>The second form is identical to the first, except that
<code>Target</code> is deduced from <code>Accessor1</code> as
follows:</dt>
<dd>
<ol>
<li>If <code>Accessor1</code> is a function type,
<code>Target</code> is the type of its first argument.</li>
<dt><b>Rationale:</b> The use of <code><a
href="../../../bind/bind.html">boost::bind</a>()</code> allows
C++ iterators to be accessed through functions, member functions
or data member pointers. Customization of
<code>NextPolicies</code> (e.g. using <code><a
href="return_internal_reference.html#return_internal_reference-spec"
>return_internal_reference</a></code>) is useful when it is
expensive to copy sequence elements of a wrapped class
type. Customization of <code>Target</code> is useful when
<code>Accessor1</code> is a function object, or when a base
class of the intended target type would otherwise be deduced.
<li>If <code>Accessor1</code> is a data member pointer of the
form <code>R&nbsp;(T::*)</code>, <code>Target</code> is
identical to <code>T</code>.</li>
<li>If <code>Accessor1</code> is a member function pointer of
the form
<code>R&nbsp;(T::*)(</code><i>arguments...</i><code>)</code>&nbsp;
<i>cv-opt</i>, where <i>cv-opt</i> is an optional
<code>cv-qualifier</code>, <code>Target</code> is identical to
<code>T</code>.</li>
</ol>
</dd>
<dt>The third form is identical to the second, except that
<code>NextPolicies</code> is an unspecified model of <a href=
"CallPolicies.html#CallPolicies-concept">CallPolicies</a> which
always makes a copy of the result of deferencing the underlying C++
iterator</dt>
</dl>
</dd>
<dt><b>Rationale:</b> The use of <code><a href=
"../../../bind/bind.html">boost::bind</a>()</code> allows C++ iterators
to be accessed through functions, member functions or data member
pointers. Customization of <code>NextPolicies</code> (e.g. using
<code><a href=
"return_internal_reference.html#return_internal_reference-spec">return_internal_reference</a></code>)
is useful when it is expensive to copy sequence elements of a wrapped
class type. Customization of <code>Target</code> is useful when
<code>Accessor1</code> is a function object, or when a base class of
the intended target type would otherwise be deduced.</dt>
</dl>
<h2><a name="examples"></a>Examples</h2>
<pre>
#include &lt;boost/python/module.hpp&gt;
#include &lt;boost/python/class.hpp&gt;
#include &lt;boost/python/return_internal_reference.hpp&gt;
#include &lt;vector&gt;
using namespace boost::python;
BOOST_PYTHON_MODULE_INIT(demo)
BOOST_PYTHON_MODULE(demo)
{
module(&quot;demo&quot;)
.add(
class_&lt;std::vector&lt;double&gt; &gt;(&quot;dvec&quot;)
.def(&quot;__iter__&quot;, iterator&lt;std::vector&lt;double&gt; &gt;())
...
)
;
class_&lt;std::vector&lt;double&gt; &gt;("dvec")
.def("__iter__", iterator&lt;std::vector&lt;double&gt; &gt;())
;
}
</pre>
A more comprehensive example can be found in:
A more comprehensive example can be found in:
<code><dl>
<dt><a href="../../test/iterator.cpp">libs/python/test/iterator.cpp</a><dd>
<dt><a href="../../test/input_iterator.cpp">libs/python/test/input_iterator.cpp</a><dd>
<dt><a href="../../test/iterator.py">libs/python/test/input_iterator.py</a><dd>
</code>
<dl>
<dt><code><a href=
"../../test/iterator.cpp">libs/python/test/iterator.cpp</a></code></dt>
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
17 May, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
<dt><code><a href=
"../../test/input_iterator.cpp">libs/python/test/input_iterator.cpp</a></code></dt>
<dt><code><a href=
"../../test/iterator.py">libs/python/test/input_iterator.py</a></code></dt>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
Abrahams</a> 2002. All Rights Reserved.</i>
<dd>
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
29 September, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All
Rights Reserved.</i></p>
</dd>
</dl>
</body>
</html>

216
doc/v2/lvalue_from_pytype.html
View File

@@ -1,128 +1,145 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<meta name="generator" content="HTML Tidy, see www.w3.org">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - &lt;boost/python/lvalue_from_python.hpp&gt;</title>
</head>
<body>
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt=
"C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Header &lt;boost/python/lvalue_from_pytype.hpp&gt;</h2>
<h2 align="center">Header
&lt;boost/python/lvalue_from_pytype.hpp&gt;</h2>
</td>
</tr>
</table>
<hr>
<h2>Contents</h2>
<dl class="page-index">
<dt><a href="#introduction">Introduction</a>
<dt><a href="#introduction">Introduction</a></dt>
<dt><a href="#classes">Classes</a>
<dt><a href="#classes">Classes</a></dt>
<dd>
<dl class="page-index">
<dt><a href="#lvalue_from_pytype-spec">Class Template <code>lvalue_from_pytype</code></a>
<dt><a href="#lvalue_from_pytype-spec">Class Template
<code>lvalue_from_pytype</code></a></dt>
<dd>
<dl class="page-index">
<dt><a href="#lvalue_from_pytype-spec-synopsis">Class Template
<code>lvalue_from_pytype</code> synopsis</a>
<code>lvalue_from_pytype</code> synopsis</a></dt>
<dt><a href="#lvalue_from_pytype-spec-ctors">Class Template
<code>lvalue_from_pytype</code> constructor</a>
<code>lvalue_from_pytype</code> constructor</a></dt>
</dl>
</dd>
</dl>
<dl class="page-index">
<dt><a href="#extract_identity-spec">Class Template <code>extract_identity</code></a>
<dt><a href="#extract_identity-spec">Class Template
<code>extract_identity</code></a></dt>
<dd>
<dl class="page-index">
<dt><a href="#extract_identity-spec-synopsis">Class Template
<code>extract_identity</code> synopsis</a>
<code>extract_identity</code> synopsis</a></dt>
<dt><a href="#extract_identity-spec-statics">Class Template
<code>extract_identity</code> static functions</a>
<code>extract_identity</code> static functions</a></dt>
</dl>
<dt><a href="#extract_member-spec">Class Template <code>extract_member</code></a>
</dd>
<dt><a href="#extract_member-spec">Class Template
<code>extract_member</code></a></dt>
<dd>
<dl class="page-index">
<dt><a href="#extract_member-spec-synopsis">Class Template
<code>extract_member</code> synopsis</a>
<code>extract_member</code> synopsis</a></dt>
<dt><a href="#extract_member-spec-statics">Class Template
<code>extract_member</code> static functions</a>
<code>extract_member</code> static functions</a></dt>
</dl>
</dd>
</dl>
</dd>
<dt><a href="#examples">Example</a>
<dt><a href="#examples">Example</a></dt>
</dl>
<hr>
<h2><a name="introduction"></a>Introduction</h2>
<code>&lt;boost/python/lvalue_from_pytype.hpp&gt;</code> supplies
a facility for extracting C++ objects from within Python instances
of a given type. This is typically useful for dealing with
&quot;traditional&quot; Python extension types.
<code>&lt;boost/python/lvalue_from_pytype.hpp&gt;</code> supplies a
facility for extracting C++ objects from within Python instances of a
given type. This is typically useful for dealing with "traditional"
Python extension types.
<h2><a name="classes"></a>Classes</h2>
<h3><a name="lvalue_from_pytype-spec"></a>Class template <code>lvalue_from_pytype</code></h3>
<h3><a name="lvalue_from_pytype-spec"></a>Class template
<code>lvalue_from_pytype</code></h3>
<p>Class template <code>lvalue_from_pytype</code> will register
from_python converters which, given an object of the given Python
type, can extract references and pointers to a particular C++
type. Its template arguments are:
<p>
from_python converters which, given an object of the given Python type,
can extract references and pointers to a particular C++ type. Its
template arguments are:</p>
<table border="1" summary="lvalue_from_pytype template parameters">
<caption>
<b><code>lvalue_from_pytype</code> Requirements</b><br>
In the table below, <b><code>x</code></b> denotes an object of type <code>PythonObject&amp;</code>
In the table below, <b><code>x</code></b> denotes an object of type
<code>PythonObject&amp;</code>
</caption>
<tr>
<th>Parameter
<th>Requirements
<th>Semantics
<tr>
<td><code>Extractor</code>
<th>Parameter</th>
<td>a model of <a
href="Extractor.html#Extractor-concept">Extractor</a> whose
execute function returns a reference type.
<th>Requirements</th>
<td>Extracts the lvalue from the Python object once its type has been confirmed
<th>Semantics</th>
</tr>
<tr>
<td><code>python_type</code>
<td><code>Extractor</code></td>
<td>A compile-time constant <code><a
href="http://www.python.org/doc/2.2/ext/dnt-type-methods.html">PyTypeObject</a>*</code>
<td>a model of <a href=
"Extractor.html#Extractor-concept">Extractor</a> whose execute
function returns a reference type.</td>
<td>The Python type of instances convertible by this
converter. Python subtypes are also convertible.
<td>Extracts the lvalue from the Python object once its type has been
confirmed</td>
</tr>
<tr>
<td><code>python_type</code></td>
<td>A compile-time constant <code><a href=
"http://www.python.org/doc/2.2/ext/dnt-type-methods.html">PyTypeObject</a>*</code></td>
<td>The Python type of instances convertible by this converter.
Python subtypes are also convertible.</td>
</tr>
</table>
<h4><a name="lvalue_from_pytype-spec-synopsis"></a>Class template <code>lvalue_from_pytype</code> synopsis</h4>
<h4><a name="lvalue_from_pytype-spec-synopsis"></a>Class template
<code>lvalue_from_pytype</code> synopsis</h4>
<pre>
namespace boost { namespace python
{
@@ -134,25 +151,25 @@ namespace boost { namespace python
}}
</pre>
<h4><a name="lvalue_from_pytype-spec-ctors"></a>Class template <code>lvalue_from_pytype</code> constructor</h4>
<h4><a name="lvalue_from_pytype-spec-ctors"></a>Class template
<code>lvalue_from_pytype</code> constructor</h4>
<pre>
lvalue_from_pytype();
</pre>
<dl class="function-semantics">
<dt><b>Effects:</b> Registers converters which can convert
Python objects of the given type to lvalues of the type returned
by <code>Extractor::execute</code>.
<dt><b>Effects:</b> Registers converters which can convert Python
objects of the given type to lvalues of the type returned by
<code>Extractor::execute</code>.</dt>
</dl>
<h3><a name="extract_identity-spec"></a>Class template <code>extract_identity</code></h3>
<h3><a name="extract_identity-spec"></a>Class template
<code>extract_identity</code></h3>
<p><code>extract_identity</code> is a model of <a
href="Extractor.html#Extractor-concept">Extractor</a> which can be
used in the common case where the C++ type to be extracted is the
same as the Python object type.
<p><code>extract_identity</code> is a model of <a href=
"Extractor.html#Extractor-concept">Extractor</a> which can be used in the
common case where the C++ type to be extracted is the same as the Python
object type.</p>
<h4><a name="extract_identity-spec-synopsis"></a>Class template
<code>extract_identity</code> synopsis</h4>
@@ -167,26 +184,26 @@ namespace boost { namespace python
}}
</pre>
<h4><a name="extract_identity-spec-statics"></a>Class template <code>extract_identity</code> static functions</h4>
<h4><a name="extract_identity-spec-statics"></a>Class template
<code>extract_identity</code> static functions</h4>
<pre>
InstanceType&amp; execute(InstanceType&amp; c);
</pre>
<dl class="function-semantics">
<dt><b>Returns:</b> <code>c</code>
<dt><b>Returns:</b> <code>c</code></dt>
</dl>
<h3><a name="extract_member-spec"></a>Class template
<code>extract_member</code></h3>
<h3><a name="extract_member-spec"></a>Class template <code>extract_member</code></h3>
<p><code>extract_member</code> is a model of <a href=
"Extractor.html#Extractor-concept">Extractor</a> which can be used in the
common case in the common case where the C++ type to be extracted is a
member of the Python object.</p>
<p><code>extract_member</code> is a model of <a
href="Extractor.html#Extractor-concept">Extractor</a> which can be
used in the common case in the common case where the C++
type to be extracted is a member of the Python object.
<h4><a name="extract_member-spec-synopsis"></a>Class template <code>extract_member</code> synopsis</h4>
<h4><a name="extract_member-spec-synopsis"></a>Class template
<code>extract_member</code> synopsis</h4>
<pre>
namespace boost { namespace python
{
@@ -198,31 +215,28 @@ namespace boost { namespace python
}}
</pre>
<h4><a name="extract_member-spec-statics"></a>Class template <code>extract_member</code> static functions</h4>
<h4><a name="extract_member-spec-statics"></a>Class template
<code>extract_member</code> static functions</h4>
<pre>
static MemberType&amp; execute(InstanceType&amp; c);
</pre>
<dl class="function-semantics">
<dt><b>Returns:</b> <code>c.*member</code>
<dt><b>Returns:</b> <code>c.*member</code></dt>
</dl>
<h2><a name="examples"></a>Example</h2>
This example presumes that someone has implemented the standard <a href=
"http://www.python.org/doc/2.2/ext/dnt-basics.html">noddy example
module</a> from the Python documentation, and we want to build a module
which manipulates <code>Noddy</code>s. Since
<code>noddy_NoddyObject</code> is so simple that it carries no
interesting information, the example is a bit contrived: it assumes you
want to keep track of one particular object for some reason. This module
would have to be dynamically linked to the module which defines
<code>noddy_NoddyType</code>.
This example presumes that someone has implemented the standard <a
href="http://www.python.org/doc/2.2/ext/dnt-basics.html">noddy
example module</a> from the Python documentation, and we want to build
a module which manipulates <code>Noddy</code>s. Since
<code>noddy_NoddyObject</code> is so simple that it carries no
interesting information, the example is a bit contrived: it assumes
you want to keep track of one particular object for some reason. This
module would have to be dynamically linked to the module which defines
<code>noddy_NoddyType</code>.
<h3>C++ module definition</h3>
<h3>C++ module definition</h3>
<pre>
#include &lt;boost/python/reference.hpp&gt;
#include &lt;boost/python/module.hpp&gt;
@@ -245,20 +259,17 @@ void set_cache(noddy_NoddyObject* x)
cache.reset((PyObject*)x, ref::increment_count);
}
BOOST_PYTHON_MODULE_INIT(noddy_cache)
BOOST_PYTHON_MODULE(noddy_cache)
{
module noddy_cache(&quot;noddy_cache&quot;)
.def(&quot;is_cached&quot;, is_cached)
.def(&quot;set_cache&quot;, set_cache)
;
def("is_cached", is_cached);
def("set_cache", set_cache);
// register Noddy lvalue converter
lvalue_from_pytype&lt;extract_identity&lt;noddy_NoddyObject&gt;,&amp;noddy_NoddyType&gt;();
}
</pre>
<h3>Python code</h3>
<h3>Python code</h3>
<pre>
&gt;&gt;&gt; import noddy
&gt;&gt;&gt; n = noddy.new_noddy()
@@ -274,10 +285,13 @@ BOOST_PYTHON_MODULE_INIT(noddy_cache)
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
05 November, 2001
29 September, 2001
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
Abrahams</a> 2002. All Rights Reserved.</i>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</i></p>
</body>
</html>

139
doc/v2/make_function.html
View File

@@ -1,39 +1,50 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<meta name="generator" content="HTML Tidy, see www.w3.org">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - &lt;boost/python/make_function.hpp&gt;</title>
</head>
<body>
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt=
"C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Header &lt;boost/python/make_function.hpp&gt;</h2>
<h2 align="center">Header
&lt;boost/python/make_function.hpp&gt;</h2>
</td>
</tr>
</table>
<hr>
<h2>Contents</h2>
<dl class="page-index">
<dt><a href="#introduction">Introduction</a>
<dt><a href="#introduction">Introduction</a></dt>
<dt><a href="#functions">Functions</a>
<dt><a href="#functions">Functions</a></dt>
<dd>
<dl class="page-index">
<dt><a href="#make_function-spec">make_function</a>
<dt><a href="#make_function-spec">make_function</a></dt>
<dt><a href="#make_constructor-spec">make_constructor</a>
<dt><a href="#make_constructor-spec">make_constructor</a></dt>
</dl>
</dd>
<dt><a href="#examples">Example</a>
<dt><a href="#examples">Example</a></dt>
</dl>
<hr>
@@ -41,78 +52,90 @@
<p><code><a href="#make_function-spec">make_function</a>()</code> and
<code><a href="#make_constructor-spec">make_constructor</a>()</code> are
the functions used internally by <code>class_&lt;&gt;::<a href=
"class.html#class_-spec-modifiers">def</a></code>, <code>class_&lt;&gt;::<a
href="module.html#module-spec-modifiers">def</a></code>, and
<code>class_&lt;&gt;::<a href=
"class.html#class_-spec-modifiers">def_init</a></code> to produce Python
callable objects which wrap C++ functions and member functions.
the functions used internally by <code><a href=
"def.html#def-spec">def</a>()</code> and <code>class_&lt;&gt;::<a href=
"class.html#class_-spec-modifiers">def</a>()</code> to produce Python
callable objects which wrap C++ functions and member functions.</p>
<h2><a name="functions"></a>Functions</h2>
<pre>
<a name="make_function-spec">template &lt;class F&gt;</a>
objects::function* make_function(F f)
<a href="object.html#object-spec">object</a> make_function(F f)
template &lt;class F, class Policies&gt;
objects::function* make_function(F f, Policies const&amp; policies)
<a href=
"object.html#object-spec">object</a> make_function(F f, Policies const&amp; policies)
template &lt;class F, class Policies, class Keywords&gt;
<a href=
"object.html#object-spec">object</a> make_function(F f, Policies const&amp; policies, Keywords const&amp; keywords)
</pre>
<dl class="function-semantics">
<dt><b>Requires:</b> <code>F</code> is a function pointer or member
function pointer type
function pointer type. If <code>policies</code> are supplied, it must
be a model of <a href="CallPolicies.html">CallPolicies</a>. If
<code>kewords</code> are supplied, it must be the result of a <a href=
"args.html#keyword-expression"><em>keyword-expression</em></a>
specifying no more arguments than the <a href=
"definitions.html#arity">arity</a> of <code>f</code>.</dt>
<dt><b>Effects:</b> Creates a Python callable object which, when called
from Python, converts its arguments to C++ and calls <code>f</code>. If
<code>F</code> is a pointer-to-member-function type, the target object of
the function call (<code>*this</code>) will be taken from the first
<code>F</code> is a pointer-to-member-function type, the target object
of the function call (<code>*this</code>) will be taken from the first
Python argument, and subsequent Python arguments will be used as the
arguments to <code>f</code>. If <code>policies</code> are supplied, it
must be a model of <a href="CallPolicies.html">CallPolicies</a>, and will
be applied to the function as described <a href=
"CallPolicies.html">here</a>.
will be applied to the function as described <a href=
"CallPolicies.html">here</a>. If <code>keywords</code> are
supplied, the keywords will be applied in order to the final
arguments of the resulting function.</dt>
<dt><b>Returns:</b> A pointer convertible to <code>PyObject*</code> which
refers to the new Python callable object.
<dt><b>Returns:</b> An instance of <a href=
"object.html#object-spec">object</a> which holds the new Python
callable object.</dt>
</dl>
<pre>
<a name=
"make_constructor-spec">template &lt;class T, class ArgList, class Generator&gt;
objects::function* make_constructor();</a>
"make_constructor-spec"></a>template &lt;class T, class ArgList, class Generator&gt;
<a href="object.html#object-spec">object</a> make_constructor();
template &lt;class ArgList, class Generator, class Policies&gt;
objects::function* make_constructor(Policies const&amp; policies)
<a href=
"object.html#object-spec">object</a> make_constructor(Policies const&amp; policies)
</pre>
<dl class="function-semantics">
<dt><b>Requires:</b> <code>T</code> is a class
type. <code>Policies</code> is a model of <a
href="CallPolicies.html">CallPolicies</a>. <code>ArgList</code>
is an <a href="../../../mpl/doc/Sequences.html">MPL sequence</a>
of C++ argument types (<i>A1, A2,... AN</i>) such that if
<code>a1, a2</code>... <code>aN</code> are objects of type
<i>A1, A2,... AN</i> respectively, the expression <code>new
Generator::apply&lt;T&gt;::type(a1, a2</code>... <code>aN</code>) is
valid. Generator is a model of <a href=
"HolderGenerator.html">HolderGenerator</a>.
<dt><b>Requires:</b> <code>T</code> is a class type.
<code>Policies</code> is a model of <a href=
"CallPolicies.html">CallPolicies</a>. <code>ArgList</code> is an <a
href="../../../mpl/doc/Sequences.html">MPL sequence</a> of C++ argument
types (<i>A1,&nbsp;A2,...&nbsp;AN</i>) such that if
<code>a1,&nbsp;a2</code>...&nbsp;<code>aN</code> are objects of type
<i>A1,&nbsp;A2,...&nbsp;AN</i> respectively, the expression <code>new
Generator::apply&lt;T&gt;::type(a1,&nbsp;a2</code>...&nbsp;<code>aN</code>)
is valid. Generator is a model of <a href=
"HolderGenerator.html">HolderGenerator</a>.</dt>
<dt><b>Effects:</b> Creates a Python callable object which, when called
from Python, expects its first argument to be a Boost.Python extension
class object. It converts its remaining its arguments to C++ and passes
them to the constructor of a dynamically-allocated
<code>Generator::apply&lt;T&gt;::type</code> object, which is
then installed in the extension class object. In the second
form, the <code>policies</code> are applied to the arguments and
result (<a
href="http://www.python.org/doc/current/lib/bltin-null-object.html">None</a>)
of the Python callable object
<code>Generator::apply&lt;T&gt;::type</code> object, which is then
installed in the extension class object. In the second form, the
<code>policies</code> are applied to the arguments and result (<a href=
"http://www.python.org/doc/current/lib/bltin-null-object.html">None</a>)
of the Python callable object</dt>
<dt><b>Returns:</b> The new Python callable object
<dt><b>Returns:</b> An instance of <a href=
"object.html#object-spec">object</a> which holds the new Python
callable object.</dt>
</dl>
<h2><a name="examples"></a>Example</h2>
<p>C++ function exposed below returns a callable object wrapping one of two
functions.
<p>C++ function exposed below returns a callable object wrapping one of
two functions.</p>
<pre>
#include &lt;boost/python/make_function.hpp&gt;
#include &lt;boost/python/module.hpp&gt;
@@ -120,7 +143,8 @@ objects::function* make_constructor(Policies const&amp; policies)
char const* foo() { return "foo"; }
char const* bar() { return "bar"; }
PyObject* choose_function(bool selector)
using namespace boost::python;
object choose_function(bool selector)
{
if (selector)
return boost::python::make_function(foo);
@@ -128,10 +152,9 @@ PyObject* choose_function(bool selector)
return boost::python::make_function(bar);
}
BOOST_PYTHON_MODULE_INIT(make_function_test)
BOOST_PYTHON_MODULE(make_function_test)
{
module("make_function_test")
.def("choose_function", choose_function);
def("choose_function", choose_function);
}
</pre>
It can be used this way in Python:
@@ -147,9 +170,13 @@ BOOST_PYTHON_MODULE_INIT(make_function_test)
<p>
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
14 February 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
29 September 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
Abrahams</a> 2002. All Rights Reserved.</i>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</i></p>
</body>
</html>

67
doc/v2/manage_new_object.html
View File

@@ -1,46 +1,57 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<meta name="generator" content="HTML Tidy, see www.w3.org">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - &lt;boost/python/manage_new_object.hpp&gt;</title>
</head>
<body>
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt=
"C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Header
&lt;boost/python/manage_new_object.hpp&gt;</h2>
</td>
</tr>
</table>
<hr>
<h2>Contents</h2>
<dl class="page-index">
<dt><a href="#classes">Classes</a>
<dt><a href="#classes">Classes</a></dt>
<dd>
<dl class="page-index">
<dt><a href="#manage_new_object-spec">Class
<code>manage_new_object</code></a>
<code>manage_new_object</code></a></dt>
<dd>
<dl class="page-index">
<dt><a href="#manage_new_object-spec-synopsis">Class
<code>manage_new_object</code> synopsis</a>
<code>manage_new_object</code> synopsis</a></dt>
<dt><a href="#manage_new_object-spec-metafunctions">Class
<code>manage_new_object</code> metafunctions</a>
<code>manage_new_object</code> metafunctions</a></dt>
</dl>
</dd>
</dl>
</dd>
<dt><a href="#examples">Example</a>
<dt><a href="#examples">Example</a></dt>
</dl>
<hr>
@@ -50,10 +61,10 @@
<code>manage_new_object</code></h3>
<p><code>manage_new_object</code> is a model of <a href=
"ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a> which can be
used to wrap C++ functions which return a pointer to an object allocated
with a <i>new-expression</i>, and expect the caller to take responsibility
for deleting that object.
"ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a>
which can be used to wrap C++ functions which return a pointer to an
object allocated with a <i>new-expression</i>, and expect the caller to
take responsibility for deleting that object.</p>
<h4><a name="manage_new_object-spec-synopsis"></a>Class
<code>manage_new_object</code> synopsis</h4>
@@ -75,16 +86,16 @@ template &lt;class T&gt; struct apply
<dl class="metafunction-semantics">
<dt><b>Requires:</b> <code>T</code> is <code>U*</code> for some
<code>U</code>.
<code>U</code>.</dt>
<dt><b>Returns:</b> <code>typedef <a href=
"to_python_indirect.html#to_python_indirect-spec">to_python_indirect</a>&lt;T&gt;
type;</code>
type;</code></dt>
</dl>
<h2><a name="examples"></a>Example</h2>
<p>In C++:
<p>In C++:</p>
<pre>
#include &lt;boost/python/module.hpp&gt;
#include &lt;boost/python/class.hpp&gt;
@@ -102,17 +113,15 @@ Foo* make_foo(int x) { return new Foo(x); }
// Wrapper code
using namespace boost::python;
BOOST_PYTHON_MODULE_INIT(my_module)
BOOST_PYTHON_MODULE(my_module)
{
module("my_module")
.def("make_foo", make_foo, return_value_policy&lt;manage_new_object&gt;)
.add(
class_&lt;Foo&gt;()
.def("get_x", &amp;Foo::get_x)
)
def("make_foo", make_foo, return_value_policy&lt;manage_new_object&gt;())
class_&lt;Foo&gt;("Foo")
.def("get_x", &amp;Foo::get_x)
;
}
</pre>
In Python:
In Python:
<pre>
&gt;&gt;&gt; from my_module import *
&gt;&gt;&gt; f = make_foo(3) # create a Foo object
@@ -122,9 +131,13 @@ In Python:
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
14 February 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
29 September 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
Abrahams</a> 2002. All Rights Reserved.</i>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</i></p>
</body>
</html>

205
doc/v2/module.html
View File

@@ -29,29 +29,7 @@
<dd>
<dl class="page-index">
<dt><a href=
"#BOOST_PYTHON_MODULE_INIT-spec">BOOST_PYTHON_MODULE_INIT</a>
</dl>
<dt><a href="#classes">Classes</a>
<dd>
<dl class="page-index">
<dt><a href="#module-spec">Class <code>module</code></a>
<dd>
<dl class="page-index">
<dt><a href="#module-spec-synopsis">Class <code>module</code>
synopsis</a>
<dt><a href="#module-spec-ctors">Class <code>module</code>
constructor</a>
<dt><a href="#module-spec-modifiers">Class <code>module</code>
modifier functions</a>
<dt><a href="#module-spec-observers">Class <code>module</code>
observer functions</a>
</dl>
"#BOOST_PYTHON_MODULE-spec">BOOST_PYTHON_MODULE</a>
</dl>
<dt><a href="#examples">Example(s)</a>
@@ -60,13 +38,13 @@
<h2><a name="introduction"></a>Introduction</h2>
<p>This header provides the basic facilities needed to create an
extension module.
<p>This header provides the basic facilities needed to create a
Boost.Python extension module.
<h2><a name="macros"></a>Macros</h2>
<p><a name=
"BOOST_PYTHON_MODULE_INIT-spec"><code>BOOST_PYTHON_MODULE_INIT(name)</code></a>
"BOOST_PYTHON_MODULE-spec"><code>BOOST_PYTHON_MODULE(name)</code></a>
is used to declare Python <a href=
"http://www.python.org/doc/2.2/ext/methodTable.html#SECTION003400000000000000000">
module initialization functions</a>. The <code>name</code> argument must
@@ -75,157 +53,29 @@
"http://www.python.org/doc/2.2/ref/identifiers.html">identifier naming
rules</a>. Where you would normally write
<pre>
void init<i>name</i>()
extern &quot;C&quot; void init<i>name</i>()
{
...
}
</pre>
Boost.Python modules should be initialized with
<pre>
BOOST_PYTHON_MODULE_INIT(<i>name</i>)
BOOST_PYTHON_MODULE(<i>name</i>)
{
...
}
</pre>
<h2><a name="classes"></a>Classes</h2>
<h3><a name="module-spec">Class <code>module</code></a></h3>
<p>This class represents the Python extension module under construction. It
provides functions for adding attributes and for retrieving the underlying
Python module object.
<h4><a name="module-spec-synopsis"></a>Class <code>module</code>
synopsis</h4>
<pre>
namespace boost { namespace python
{
class module : public module_base
{
public:
module(const char* name);
// modifier functions
module&amp; setattr(const char* name, PyObject*);
module&amp; setattr(const char* name, PyTypeObject*);
module&amp; setattr(const char* name, ref const&amp;);
module&amp; add(PyTypeObject* x);
template &lt;class T, class Bases, class HolderGenerator&gt;
module&amp; add(class_&lt;T,Bases,HolderGenerator&gt; const&amp; c);
template &lt;class Fn&gt;
module&amp; def(char const* name, Fn fn);
template &lt;class Fn, class ResultHandler&gt;
module&amp; def(char const* name, Fn fn, ResultHandler handler);
// observer function
ref object() const;
};
}}
</pre>
<h4><a name="module-spec-ctors">Class <code>module</code></a>
constructor</h4>
<pre>
module(const char* name);
</pre>
<dl class="function-semantics">
<dt><b>Requires:</b> <code>name</code> is a ntbs whose value matches the
argument passed to <a href=
"#BOOST_PYTHON_MODULE_INIT-spec">BOOST_PYTHON_MODULE_INIT</a>.
<dt><b>Effects:</b> Creates a <code>module</code> object representing a
Python module named <code>name</code>.
</dl>
<h4><a name="module-spec-modifiers">Class <code>module</code></a> modifier
functions</h4>
<pre>
module&amp; setattr(const char* name, PyObject* obj);
module&amp; setattr(const char* name, PyTypeObject* obj);
module&amp; setattr(const char* name, ref const&amp; r);
</pre>
<dl class="function-semantics">
<dt><b>Requires:</b> <code>name</code> is a ntbs which conforms to
Python's <a href=
"http://www.python.org/doc/2.2/ref/identifiers.html">identifier
naming rules</a>. In the first two forms, <code>obj</code> is non-null.
In the third form, <code>r.get()</code> is non-null.
<dt><b>Effects:</b> Adds the given Python object to the module. If the
object is a product of <code><a href=
"make_function.html#make_function-spec">make_function</a>()</code>, the
usual <a href="overloading.html">overloading procedure</a> applies.
In the first two forms, ownership of a reference to obj is transferred
from caller to callee, even if an exception is thrown.
<dt><b>Returns:</b> <code>*this</code>
</dl>
<pre>
module&amp; add(PyTypeObject* x);
template &lt;class T, class Bases, class HolderGenerator&gt;
module&amp; add(class_&lt;T,Bases,HolderGenerator&gt; const&amp; c);
</pre>
<dl class="function-semantics">
<dt><b>Requires:</b> In the first form, <code>x</code> is non-null
<dt><b>Effects:</b> The first form adds the Python type object named by
<code>x</code> to the Python module under construction, with the name
given by the type's <code><a href=
"http://www.python.org/doc/2.2/ext/dnt-type-methods.html">tp_name</a></code>
field. The second form adds the extension class object being constructed
by <code>c</code> to the module, with the same name that was passed to
<code>c</code>'s constructor.
<dt><b>Returns:</b> <code>*this</code>
<dt><b>Rationale:</b> Provides a way to set type attributes in the module
without having to explicitly specify the name.
</dl>
<pre>
template &lt;class Fn&gt;
module&amp; def(char const* name, Fn f);
template &lt;class Fn, class ResultHandler&gt;
module&amp; def(char const* name, Fn f, ResultHandler handler);
</pre>
<dl class="function-semantics">
<dt><b>Requires:</b> <code>f</code> is a non-null pointer-to-function or
pointer-to-member-function. <code>name</code> is a ntbs which conforms to
Python's <a href=
"http://www.python.org/doc/2.2/ref/identifiers.html">identifier
naming rules</a>. In the first form, the return type of
<code>f</code> is not a reference and is not a pointer other
than <code>char const*</code> or <code>PyObject*</code>. In the
second form <code>policy</code> is a model of <a
href="CallPolicy.html">CallPolicy</a>.
<dt><b>Effects:</b> Adds the result of <code><a href=
"make_function.html#make_function-spec">make_function</a>(f)</code> to
the extension module being defined, with the given <code>name</code>. If
the module already has an attribute named <code><i>name</i></code>, the
usual <a href="http:overloading.html">overloading procedure</a> applies.
<dt><b>Returns:</b> <code>*this</code>
</dl>
<h4><a name="module-spec-observers">Class <code>module</code></a> observer
functions</h4>
<pre>
ref object() const;
</pre>
<dl class="function-semantics">
<dt><b>Returns:</b> A <code>ref</code> object which holds a reference to
the Python module object created by the <code>module</code> constructor.
</dl>
This macro generates two functions in the scope where it is used:
<code>extern&nbsp;&quot;C&quot;&nbsp;void&nbsp;init<i>name</i>()</code>,
and <code>void&nbsp;init_module_<i>name</i>()</code>, whose body must
follow the macro invocation. <code>init_<i>name</i></code> passes
<code>init_module_<i>name</i></code> to <code><a
href="errors.html#handle_exception">handle_exception</a>()</code> so
that any C++ exceptions generated are safely processeed. During the
body of <code>init_<i>name</i></code>, the current <code><a
href="scope.html#scope-spec">scope</a></code> refers to the module
being initialized.
<h2><a name="examples"></a>Example(s)</h2>
@@ -233,28 +83,23 @@ ref object() const;
<pre>
#include &lt;boost/python/module.hpp&gt;
char const* greet()
BOOST_PYTHON_MODULE(xxx)
{
return "hello, Boost.Python!";
}
BOOST_PYTHON_MODULE_INIT(boost_greet)
{
module("boost_greet")
.def("greet", greet);
throw &quot;something bad happened&quot;
}
</pre>
Interactive Python:
<pre>
&gt;&gt;&gt; import boost_greet
&gt;&gt;&gt; boost_greet.greet()
'hello, Boost.Python!'
&gt;&gt;&gt; import xxx
Traceback (most recent call last):
File "<stdin>", line 1, in ?
RuntimeError: Unidentifiable C++ Exception
</pre>
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
14 February, 2002
2 October, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->

1004
doc/v2/operators.html
View File

File diff suppressed because it is too large Load Diff

2
doc/v2/ptr.html
View File

@@ -175,6 +175,8 @@ Ptr get() const;
better to have an explicit way to retrieve the pointer.
</dl>
<h2><a name="metafunctions"></a>Metafunctions</h2>
<h3><a name="is_pointer_wrapper-spec"></a>Class template <code>is_pointer_wrapper</code></h3>
<p>A unary metafunction whose <code>value</code> is true iff its

704
doc/v2/reference.html
View File

File diff suppressed because it is too large Load Diff

83
doc/v2/reference_existing_object.html
View File

@@ -1,47 +1,59 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<meta name="generator" content="HTML Tidy, see www.w3.org">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python -
&lt;boost/python/reference_existing_object.hpp&gt;</title>
</head>
<body>
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt=
"C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Header
&lt;boost/python/reference_existing_object.hpp&gt;</h2>
</td>
</tr>
</table>
<hr>
<h2>Contents</h2>
<dl class="page-index">
<dt><a href="#classes">Classes</a>
<dt><a href="#classes">Classes</a></dt>
<dd>
<dl class="page-index">
<dt><a href="#reference_existing_object-spec">Class
<code>reference_existing_object</code></a>
<code>reference_existing_object</code></a></dt>
<dd>
<dl class="page-index">
<dt><a href="#reference_existing_object-spec-synopsis">Class
<code>reference_existing_object</code> synopsis</a>
<code>reference_existing_object</code> synopsis</a></dt>
<dt><a href="#reference_existing_object-spec-metafunctions">Class
<code>reference_existing_object</code> metafunctions</a>
<dt><a href=
"#reference_existing_object-spec-metafunctions">Class
<code>reference_existing_object</code> metafunctions</a></dt>
</dl>
</dd>
</dl>
</dd>
<dt><a href="#examples">Example</a>
<dt><a href="#examples">Example</a></dt>
</dl>
<hr>
@@ -51,19 +63,20 @@
<code>reference_existing_object</code></h3>
<p><code>reference_existing_object</code> is a model of <a href=
"ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a> which can be
used to wrap C++ functions which return a reference or pointer to a C++
object. When the wrapped function is called, the value referenced by its
return value is not copied. A new Python object is created which contains a
pointer to the referent, and no attempt is made to ensure that the lifetime
of the referent is at least as long as that of the corresponding Python
object. Thus, it can be <font color="#ff0000"><b>highly
dangerous</b></font> to use <code>reference_existing_object</code> without
additional lifetime management from such models of <a href=
"ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a>
which can be used to wrap C++ functions which return a reference or
pointer to a C++ object. When the wrapped function is called, the value
referenced by its return value is not copied. A new Python object is
created which contains a pointer to the referent, and no attempt is made
to ensure that the lifetime of the referent is at least as long as that
of the corresponding Python object. Thus, it can be <font color=
"#ff0000"><b>highly dangerous</b></font> to use
<code>reference_existing_object</code> without additional lifetime
management from such models of <a href=
"CallPolicies.html">CallPolicies</a> as <a href=
"with_custodian_and_ward.html#with_custodian_and_ward-spec">with_custodian_and_ward</a>.
This class is used in the implementation of <a href=
"return_internal_reference.html#return_internal_reference-spec">return_internal_reference</a>.
"return_internal_reference.html#return_internal_reference-spec">return_internal_reference</a>.</p>
<h4><a name="reference_existing_object-spec-synopsis"></a>Class
<code>reference_existing_object</code> synopsis</h4>
@@ -85,20 +98,20 @@ template &lt;class T&gt; struct apply
<dl class="metafunction-semantics">
<dt><b>Requires:</b> <code>T</code> is <code>U&amp;</code> or
<code>U*</code>for some <code>U</code>.
<code>U*</code>for some <code>U</code>.</dt>
<dt><b>Returns:</b> <code>typedef <a href=
"to_python_indirect.html#to_python_indirect-spec">to_python_indirect</a>&lt;T,V&gt;
type</code>, where <code>V</code> is a <a href=
"to_python_indirect.html#HolderObjectGenerator">HolderObjectGenerator</a>
which constructs an instance holder containing an <i>unowned</i>
<code>U*</code> pointing to the referent of the wrapped function's return
value.
<code>U*</code> pointing to the referent of the wrapped function's
return value.</dt>
</dl>
<h2><a name="examples"></a>Example</h2>
<p>In C++:
<p>In C++:</p>
<pre>
#include &lt;boost/python/module.hpp&gt;
#include &lt;boost/python/class.hpp&gt;
@@ -128,14 +141,12 @@ Singleton&amp; get_it()
// Wrapper code
using namespace boost::python;
BOOST_PYTHON_MODULE_INIT(singleton)
BOOST_PYTHON_MODULE(singleton)
{
module("singleton")
.def("get_it", get_it)
.add(
class_&lt;Singleton&gt;()
.def("exchange", &amp;Singleton::exchange)
);
def("get_it", get_it, reference_existing_object());
class_&lt;Singleton&gt;("Singleton")
.def("exchange", &amp;Singleton::exchange)
;
}
</pre>
In Python:
@@ -153,9 +164,13 @@ BOOST_PYTHON_MODULE_INIT(singleton)
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
14 February 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
29 September 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
Abrahams</a> 2002. All Rights Reserved.</i>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</i></p>
</body>
</html>

177
doc/v2/return_internal_reference.html
View File

@@ -1,114 +1,129 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<meta name="generator" content="HTML Tidy, see www.w3.org">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - &lt;boost/python/return_internal_reference.hpp&gt;</title>
<title>Boost.Python -
&lt;boost/python/return_internal_reference.hpp&gt;</title>
</head>
<body>
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt=
"C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Header &lt;boost/python/return_internal_reference.hpp&gt;</h2>
<h2 align="center">Header
&lt;boost/python/return_internal_reference.hpp&gt;</h2>
</td>
</tr>
</table>
<hr>
<h2>Contents</h2>
<dl class="page-index">
<dt><a href="#introduction">Introduction</a>
<dt><a href="#introduction">Introduction</a></dt>
<dt><a href="#classes">Classes</a>
<dt><a href="#classes">Classes</a></dt>
<dd>
<dl class="page-index">
<dt><a href="#return_internal_reference-spec">Class Template <code>return_internal_reference</code></a>
<dt><a href="#return_internal_reference-spec">Class Template
<code>return_internal_reference</code></a></dt>
<dd>
<dl class="page-index">
<dt><a href="#return_internal_reference-spec-synopsis">Class Template
<code>return_internal_reference</code> synopsis</a>
<dt><a href="#return_internal_reference-spec-synopsis">Class
Template <code>return_internal_reference</code>
synopsis</a></dt>
<dt><a href="#return_internal_reference-spec-statics">Class
<code>return_internal_reference</code> static functions</a>
<code>return_internal_reference</code> static
functions</a></dt>
</dl>
</dd>
</dl>
</dd>
<dt><a href="#examples">Example</a>
<dt><a href="#examples">Example</a></dt>
</dl>
<hr>
<h2><a name="introduction"></a>Introduction</h2>
<code>return_internal_reference</code> instantiations are models of <a href=
"CallPolicies.html">CallPolicies</a> which allow pointers and
<code>return_internal_reference</code> instantiations are models of <a
href="CallPolicies.html">CallPolicies</a> which allow pointers and
references to objects held internally by a free or member function
argument or from the target of a member function to be returned
safely without making a copy of the referent. The default for its
first template argument handles the common case where the
containing object is the target (<code>*this</code>) of a wrapped
member function.
argument or from the target of a member function to be returned safely
without making a copy of the referent. The default for its first template
argument handles the common case where the containing object is the
target (<code>*this</code>) of a wrapped member function.
<h2><a name="classes"></a>Classes</h2>
<h3><a name="return_internal_reference-spec"></a>Class template <code>return_internal_reference</code></h3>
<h3><a name="return_internal_reference-spec"></a>Class template
<code>return_internal_reference</code></h3>
<table border="1" summary="return_internal_reference template parameters">
<table border="1" summary=
"return_internal_reference template parameters">
<caption>
<b><code>return_internal_reference</code> template parameters</b>
</caption>
<tr>
<th>Parameter
<th>Requirements
<th>Description
<th>Default
<tr>
<td><code>owner_arg</code>
<th>Parameter</th>
<th>Requirements</th>
<th>Description</th>
<th>Default</th>
</tr>
<tr>
<td><code>owner_arg</code></td>
<td>A positive compile-time constant of type
<code>std::size_t</code>.
<code>std::size_t</code>.</td>
<td>The index of the parameter which contains the object to
which the reference or pointer is being returned. If used to
wrap a member function, parameter 1 is the target object
(<code>*this</code>). Note that if the target Python object
type doesn't support weak references, a Python
<code>TypeError</code> exception will be raised when the
function being wrapped is called.
<td>The index of the parameter which contains the object to which the
reference or pointer is being returned. If used to wrap a member
function, parameter 1 is the target object (<code>*this</code>). Note
that if the target Python object type doesn't support weak
references, a Python <code>TypeError</code> exception will be raised
when the function being wrapped is called.</td>
<td>1
<td>1</td>
</tr>
<tr>
<td><code>Base</code>
<td><code>Base</code></td>
<td>A model of <a href="CallPolicies.html">CallPolicies</a>
<td>A model of <a href="CallPolicies.html">CallPolicies</a></td>
<td>Used for policy composition. Any
<code>result_converter</code> it supplies will be overridden by
<code>return_internal_reference</code>, but its
<code>precall</code> and <code>postcall</code> policies are
composed as described here <a
href="CallPolicies.html#composition">CallPolicies</a>.
<td><code><a href="default_call_policies.html#default_call_policies-spec">default_call_policies</a></code>
<td>Used for policy composition. Any <code>result_converter</code> it
supplies will be overridden by
<code>return_internal_reference</code>, but its <code>precall</code>
and <code>postcall</code> policies are composed as described here <a
href="CallPolicies.html#composition">CallPolicies</a>.</td>
<td><code><a href=
"default_call_policies.html#default_call_policies-spec">default_call_policies</a></code></td>
</tr>
</table>
<h4><a name="return_internal_reference-spec-synopsis"></a>Class template <code>return_internal_reference</code> synopsis</h4>
<h4><a name="return_internal_reference-spec-synopsis"></a>Class template
<code>return_internal_reference</code> synopsis</h4>
<pre>
namespace boost { namespace python
{
@@ -116,29 +131,32 @@ namespace boost { namespace python
struct return_internal_reference : Base
{
static PyObject* postcall(PyObject*, PyObject* result);
typedef <a href="reference_existing_object.html#reference_existing_object-spec">reference_existing_object</a> result_converter;
typedef <a href=
"reference_existing_object.html#reference_existing_object-spec">reference_existing_object</a> result_converter;
};
}}
</pre>
<h4><a name="default_call_policies-spec-statics"></a>Class
<code>default_call_policies</code> static functions</h4>
<pre>
PyObject* postcall(PyObject* args, PyObject* result);
</pre>
<dl class="function-semantics">
<dt><b>Requires:</b> <code><a href="http://www.python.org/doc/2.2/api/tupleObjects.html#l2h-476">PyTuple_Check</a>(args) != 0</code>
<dt><b>Requires:</b> <code><a href=
"http://www.python.org/doc/2.2/api/tupleObjects.html#l2h-476">PyTuple_Check</a>(args)
!= 0</code></dt>
<dt><b>Returns:</b> <code><a href="with_custodian_and_ward.html#with_custodian_and_ward_postcall-spec-statics">with_custodian_and_ward_postcall::postcall(args, result)</a></code>
<dt><b>Returns:</b> <code><a href=
"with_custodian_and_ward.html#with_custodian_and_ward_postcall-spec-statics">
with_custodian_and_ward_postcall::postcall(args,
result)</a></code></dt>
</dl>
<h2><a name="examples"></a>Example</h2>
<h3>C++ module definition</h3>
<h3>C++ module definition</h3>
<pre>
#include &lt;boost/python/module.hpp&gt;
#include &lt;boost/python/class.hpp&gt;
@@ -166,26 +184,21 @@ class Foo
};
using namespace boost::python;
BOOST_PYTHON_MODULE_INIT(internal_refs)
BOOST_PYTHON_MODULE(internal_refs)
{
module m(&quot;internal_refs&quot;)
.add(
class_&lt;Bar&gt;()
.def(&quot;get_x&quot;, &amp;Bar::get_x)
.def(&quot;set_x&quot;, &amp;Bar::set_x)
)
.add(
class_&lt;Foo&gt;()
.def_init(args&lt;int&gt;())
.def(&quot;get_bar&quot;, &amp;Foo::get_bar
, return_internal_reference&lt;&gt;())
)
class_&lt;Bar&gt;("Bar")
.def("get_x", &amp;Bar::get_x)
.def("set_x", &amp;Bar::set_x)
;
class_&lt;Foo&gt;("Foo", init&lt;int&gt;())
.def("get_bar", &amp;Foo::get_bar
, return_internal_reference&lt;&gt;())
;
}
</pre>
<h3>Python code</h3>
<h3>Python code</h3>
<pre>
&gt;&gt;&gt; from internal_refs import *
&gt;&gt;&gt; f = Foo(3)
@@ -202,9 +215,13 @@ BOOST_PYTHON_MODULE_INIT(internal_refs)
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
15 February, 2002
15 February, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
Abrahams</a> 2002. All Rights Reserved.</i>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</i></p>
</body>
</html>

119
doc/v2/return_value_policy.html
View File

@@ -1,89 +1,106 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<meta name="generator" content="HTML Tidy, see www.w3.org">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - &lt;boost/python/return_value_policy.hpp&gt;</title>
<title>Boost.Python -
&lt;boost/python/return_value_policy.hpp&gt;</title>
</head>
<body>
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt=
"C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Header &lt;boost/python/return_value_policy.hpp&gt;</h2>
<h2 align="center">Header
&lt;boost/python/return_value_policy.hpp&gt;</h2>
</td>
</tr>
</table>
<hr>
<h2>Contents</h2>
<dl class="page-index">
<dt><a href="#introduction">Introduction</a>
<dt><a href="#introduction">Introduction</a></dt>
<dt><a href="#classes">Classes</a>
<dt><a href="#classes">Classes</a></dt>
<dd>
<dl class="page-index">
<dt><a href="#return_value_policy-spec">Class Template <code>return_value_policy</code></a>
<dt><a href="#return_value_policy-spec">Class Template
<code>return_value_policy</code></a></dt>
<dd>
<dl class="page-index">
<dt><a href="#return_value_policy-spec-synopsis">Class Template
<code>return_value_policy</code> synopsis</a>
<code>return_value_policy</code> synopsis</a></dt>
</dl>
</dd>
</dl>
</dd>
<dt><a href="#examples">Example</a>
<dt><a href="#examples">Example</a></dt>
</dl>
<hr>
<h2><a name="introduction"></a>Introduction</h2>
<code>return_value_policy</code> instantiations are simply models
of <a href=
"CallPolicies.html">CallPolicies</a> which are composed of a <a href=
"ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a> and optional <code>Base</code> <a href=
"CallPolicies.html">CallPolicies</a>.
<code>return_value_policy</code> instantiations are simply models of <a
href="CallPolicies.html">CallPolicies</a> which are composed of a <a
href=
"ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a>
and optional <code>Base</code> <a href=
"CallPolicies.html">CallPolicies</a>.
<h2><a name="classes"></a>Classes</h2>
<h3><a name="return_value_policy-spec"></a>Class template <code>return_value_policy</code></h3>
<h3><a name="return_value_policy-spec"></a>Class template
<code>return_value_policy</code></h3>
<table border="1" summary="return_value_policy template parameters">
<caption>
<b><code>return_value_policy</code> template parameters</b>
</caption>
<tr>
<th>Parameter
<th>Requirements
<th>Default
<tr>
<td><a href="ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a>
<th>Parameter</th>
<th>Requirements</th>
<th>Default</th>
</tr>
<tr>
<td><a href=
"ResultConverter.html#ResultConverterGenerator-concept">ResultConverterGenerator</a></td>
<td>A model of <a href=
"ResultConverterGenerator.html">ResultConverterGenerator</a>.
"ResultConverterGenerator.html">ResultConverterGenerator</a>.</td>
</tr>
<tr>
<td><code>Base</code>
<td><code>Base</code></td>
<td>A model of <a href="CallPolicies.html">CallPolicies</a>
<td><code><a href="default_call_policies.html#default_call_policies-spec">default_call_policies</a></code>
<td>A model of <a href="CallPolicies.html">CallPolicies</a></td>
<td><code><a href=
"default_call_policies.html#default_call_policies-spec">default_call_policies</a></code></td>
</tr>
</table>
<h4><a name="return_value_policy-spec-synopsis"></a>Class template <code>return_value_policy</code> synopsis</h4>
<h4><a name="return_value_policy-spec-synopsis"></a>Class template
<code>return_value_policy</code> synopsis</h4>
<pre>
namespace boost { namespace python
{
@@ -97,7 +114,7 @@ namespace boost { namespace python
<h2><a name="examples"></a>Example</h2>
<h3>C++ Module Definition</h3>
<h3>C++ Module Definition</h3>
<pre>
#include &lt;boost/python/module.hpp&gt;
#include &lt;boost/python/class.hpp&gt;
@@ -116,22 +133,18 @@ struct Foo {
// Wrapper code
using namespace boost::python;
BOOST_PYTHON_MODULE_INIT(my_module)
BOOST_PYTHON_MODULE(my_module)
{
module("my_module")
.add(
class_&lt;Bar&gt;()
)
.add(
class_&lt;Foo&gt;()
.def_init(args&lt;int&gt;())
.def("get_bar", &amp;Foo::get_bar
, return_value_policy&lt;copy_const_reference&gt;())
)
;
class_&lt;Bar&gt;("Bar");
class_&lt;Foo&gt;("Foo", init&lt;int&gt;())
.def("get_bar", &amp;Foo::get_bar
, return_value_policy&lt;copy_const_reference&gt;())
;
}
</pre>
<h3>Python Code</h3>
<h3>Python Code</h3>
<pre>
&gt;&gt;&gt; from my_module import *
&gt;&gt;&gt; f = Foo(3) # create a Foo object
@@ -140,9 +153,13 @@ BOOST_PYTHON_MODULE_INIT(my_module)
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
15 February, 2002
15 February, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
Abrahams</a> 2002. All Rights Reserved.</i>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</i></p>
</body>
</html>

141
doc/v2/to_python_converter.html
View File

@@ -1,96 +1,114 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<meta name="generator" content="HTML Tidy, see www.w3.org">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="../boost.css">
<title>Boost.Python - &lt;boost/python/to_python_converter.hpp&gt;</title>
<title>Boost.Python -
&lt;boost/python/to_python_converter.hpp&gt;</title>
</head>
<body>
<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
"header">
<tr>
<td valign="top" width="300">
<h3><a href="../../../../index.htm"><img height="86" width="277" alt=
"C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
<h3><a href="../../../../index.htm"><img height="86" width="277"
alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
</td>
<td valign="top">
<h1 align="center">Boost.Python</h1>
<h2 align="center">Header &lt;boost/python/to_python_converter.hpp&gt;</h2>
<h2 align="center">Header
&lt;boost/python/to_python_converter.hpp&gt;</h2>
</td>
</tr>
</table>
<hr>
<h2>Contents</h2>
<dl class="page-index">
<dt><a href="#introduction">Introduction</a>
<dt><a href="#introduction">Introduction</a></dt>
<dt><a href="#classes">Classes</a>
<dt><a href="#classes">Classes</a></dt>
<dd>
<dl class="page-index">
<dt><a href="#to_python_converter-spec">Class Template <code>to_python_converter</code></a>
<dt><a href="#to_python_converter-spec">Class Template
<code>to_python_converter</code></a></dt>
<dd>
<dl class="page-index">
<dt><a href="#to_python_converter-spec-synopsis">Class Template
<code>to_python_converter</code> synopsis</a>
<code>to_python_converter</code> synopsis</a></dt>
<dt><a href="#to_python_converter-spec-ctors">Class Template
<code>to_python_converter</code> constructor</a>
<code>to_python_converter</code> constructor</a></dt>
</dl>
</dd>
</dl>
</dd>
<dt><a href="#examples">Example</a>
<dt><a href="#examples">Example</a></dt>
</dl>
<hr>
<h2><a name="introduction"></a>Introduction</h2>
<code>to_python_converter</code> registers a conversion from
objects of a given C++ type into a Python object.
<code>to_python_converter</code> registers a conversion from objects of a
given C++ type into a Python object.
<h2><a name="classes"></a>Classes</h2>
<h3><a name="to_python_converter-spec"></a>Class template <code>to_python_converter</code></h3>
<code>to_python_converter</code> adds a wrapper around a static
member function of its second template parameter, handling
low-level details such as insertion into the converter registry.
<h3><a name="to_python_converter-spec"></a>Class template
<code>to_python_converter</code></h3>
<code>to_python_converter</code> adds a wrapper around a static member
function of its second template parameter, handling low-level details
such as insertion into the converter registry.
<table border="1" summary="to_python_converter template parameters">
<caption>
<b><code>to_python_converter</code> template parameters</b><br>
In the table below, <b><code>x</code></b> denotes an object of type <code>T</code>
In the table below, <b><code>x</code></b> denotes an object of type
<code>T</code>
</caption>
<tr>
<th>Parameter
<th>Requirements
<th>Description
<tr>
<td><code>T</code>
<th>Parameter</th>
<th>Requirements</th>
<th>Description</th>
</tr>
<tr>
<td><code>T</code></td>
<td>
</td>
<td>The C++ type of the source object in the conversion
<td>The C++ type of the source object in the conversion</td>
</tr>
<tr>
<td><code>Conversion</code>
<td><code>Conversion</code></td>
<td><code>PyObject*&nbsp;p&nbsp;=&nbsp;Conversion::convert(x)</code>,<br>
if <code>p&nbsp;==&nbsp;0</code>, <code><a href="http://www.python.org/doc/2.2/api/exceptionHandling.html#l2h-71">PyErr_Occurred</a>()&nbsp;!=&nbsp;0</code>.
<td>
<code>PyObject*&nbsp;p&nbsp;=&nbsp;Conversion::convert(x)</code>,<br>
if <code>p&nbsp;==&nbsp;0</code>, <code><a href=
"http://www.python.org/doc/2.2/api/exceptionHandling.html#l2h-71">PyErr_Occurred</a>()&nbsp;!=&nbsp;0</code>.</td>
<td>A class type whose static member function
<code>convert</code> does the real work of the conversion.
<tr>
<td>A class type whose static member function <code>convert</code>
does the real work of the conversion.</td>
</tr>
</table>
<h4><a name="to_python_converter-spec-synopsis"></a>Class template <code>to_python_converter</code> synopsis</h4>
<h4><a name="to_python_converter-spec-synopsis"></a>Class template
<code>to_python_converter</code> synopsis</h4>
<pre>
namespace boost { namespace python
{
@@ -102,34 +120,31 @@ namespace boost { namespace python
}}
</pre>
<h4><a name="to_python_converter-spec-ctors"></a>Class template <code>to_python_converter</code> constructor</h4>
<h4><a name="to_python_converter-spec-ctors"></a>Class template
<code>to_python_converter</code> constructor</h4>
<pre>
to_python_converter();
</pre>
<dl class="function-semantics">
<dt><b>Effects:</b> Registers a to_python converter which uses
<code>Conversion::convert()</code> to do its work.
<code>Conversion::convert()</code> to do its work.</dt>
</dl>
<h2><a name="examples"></a>Example</h2>
This example presumes that someone has implemented the standard <a href=
"http://www.python.org/doc/2.2/ext/dnt-basics.html">noddy example
module</a> from the Python documentation, and placed the corresponding
declarations in <code>"noddy.h"</code>. Because
<code>noddy_NoddyObject</code> is the ultimate trivial extension type,
the example is a bit contrived: it wraps a function for which all
information is contained in the <i>type</i> of its return value.
This example presumes that someone has implemented the standard <a
href="http://www.python.org/doc/2.2/ext/dnt-basics.html">noddy example
module</a> from the Python documentation, and placed the corresponding
declarations in <code>&quot;noddy.h&quot;</code>. Because
<code>noddy_NoddyObject</code> is the ultimate trivial extension type,
the example is a bit contrived: it wraps a function for which all
information is contained in the <i>type</i> of its return value.
<h3>C++ module definition</h3>
<h3>C++ module definition</h3>
<pre>
#include &lt;boost/python/reference.hpp&gt;
#include &lt;boost/python/module.hpp&gt;
#include &quot;noddy.h&quot;
#include "noddy.h"
struct tag {};
tag make_tag() { return tag(); }
@@ -144,17 +159,14 @@ struct tag_to_noddy
}
};
BOOST_PYTHON_MODULE_INIT(to_python_converter)
BOOST_PYTHON_MODULE(to_python_converter)
{
module(&quot;to_python_converter&quot;)
.def(&quot;make_tag&quot;, make_tag)
;
def("make_tag", make_tag);
to_python_converter&lt;tag, tag_to_noddy&gt;();
}
</pre>
<h3>Python code</h3>
<h3>Python code</h3>
<pre>
&gt;&gt;&gt; import to_python_converter
&gt;&gt;&gt; def always_none():
@@ -180,10 +192,13 @@ BOOST_PYTHON_MODULE_INIT(to_python_converter)
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
05 November, 2001
29 September, 2002
<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
</p>
<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
Abrahams</a> 2002. All Rights Reserved.</i>
<p><i>&copy; Copyright <a href=
"../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
Reserved.</i></p>
</body>
</html>

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

7
include/boost/python/args.hpp
View File

@@ -7,7 +7,6 @@
# define KEYWORDS_DWA2002323_HPP
# include <boost/python/args_fwd.hpp>
# include <boost/python/handle.hpp>
# include <boost/config.hpp>
# include <boost/python/detail/preprocessor.hpp>
# include <boost/python/detail/type_list.hpp>
@@ -32,12 +31,6 @@ namespace boost { namespace python {
namespace detail
{
struct keyword
{
char const* name;
handle<> default_value;
};
template <std::size_t nkeywords>
struct keywords
{

8
include/boost/python/args_fwd.hpp
View File

@@ -6,6 +6,7 @@
#ifndef ARGS_FWD_DWA2002927_HPP
# define ARGS_FWD_DWA2002927_HPP
# include <boost/python/handle.hpp>
# include <boost/config.hpp>
# include <cstddef>
# include <utility>
@@ -14,7 +15,12 @@ namespace boost { namespace python {
namespace detail
{
struct keyword;
struct keyword
{
char const* name;
handle<> default_value;
};
template <std::size_t nkeywords = 0> struct keywords;
typedef std::pair<keyword const*, keyword const*> keyword_range;

11
include/boost/python/class.hpp
View File

@@ -13,7 +13,6 @@
# include <boost/python/object.hpp>
# include <boost/python/type_id.hpp>
# include <boost/python/detail/member_function_cast.hpp>
# include <boost/python/object/class_converters.hpp>
# include <boost/type_traits/ice.hpp>
# include <boost/type_traits/same_traits.hpp>
@@ -25,17 +24,19 @@
# include <boost/python/object/make_instance.hpp>
# include <boost/python/data_members.hpp>
# include <boost/utility.hpp>
# include <boost/python/detail/operator_id.hpp>
# include <boost/python/object/pickle_support.hpp>
# include <boost/python/make_function.hpp>
# include <boost/python/object/add_to_namespace.hpp>
# include <boost/python/detail/def_helper.hpp>
# include <boost/python/detail/force_instantiate.hpp>
# include <boost/python/detail/defaults_def.hpp>
# include <boost/python/signature.hpp>
# include <boost/python/init.hpp>
# include <boost/python/args_fwd.hpp>
# include <boost/python/detail/overloads_fwd.hpp>
# include <boost/python/detail/operator_id.hpp>
# include <boost/python/detail/member_function_cast.hpp>
# include <boost/python/detail/def_helper.hpp>
# include <boost/python/detail/force_instantiate.hpp>
namespace boost { namespace python {
enum no_init_t { no_init };

2
include/boost/python/def.hpp
View File

@@ -9,7 +9,7 @@
# include <boost/python/object_fwd.hpp>
# include <boost/python/make_function.hpp>
# include <boost/python/detail/def_helper.hpp>
# include <boost/python/detail/defaults_def.hpp>
# include <boost/python/detail/overloads_fwd.hpp>
# include <boost/python/scope.hpp>
# include <boost/python/signature.hpp>
# include <boost/python/detail/scope.hpp>

2
include/boost/python/detail/defaults_def.hpp
View File

@@ -219,7 +219,7 @@ namespace detail
char const* name,
OverloadsT const& overloads,
NameSpaceT& name_space,
SigT sig)
SigT const& sig)
{
typedef typename mpl::front<SigT>::type return_type;
typedef typename OverloadsT::void_return_type void_return_type;

45
include/boost/python/detail/defaults_gen.hpp
View File

@@ -24,8 +24,7 @@
#include <boost/preprocessor/empty.hpp>
#include <boost/preprocessor/comma_if.hpp>
#include <boost/config.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/front.hpp>
#include <boost/mpl/begin_end.hpp>
namespace boost { namespace python {
@@ -211,7 +210,7 @@ namespace detail
{ \
typedef typename ::boost::python::detail:: \
error::more_keywords_than_function_arguments< \
Keywords::size,(n_args+n_dflts)>::too_many_keywords assertion; \
Keywords::size,n_args>::too_many_keywords assertion; \
} \
template <class Keywords> \
fstubs_name(Keywords const& keywords, char const* doc = 0) \
@@ -220,59 +219,57 @@ namespace detail
{ \
typedef typename ::boost::python::detail:: \
error::more_keywords_than_function_arguments< \
Keywords::size,(n_args+n_dflts)>::too_many_keywords assertion; \
Keywords::size,n_args>::too_many_keywords assertion; \
}
# if defined(BOOST_NO_VOID_RETURNS)
# define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \
BOOST_PYTHON_GEN_FUNCTION( \
fname, BOOST_PP_CAT(fstubs_name, NonVoid), n_args, n_dflts, return) \
BOOST_PYTHON_GEN_FUNCTION( \
fname, BOOST_PP_CAT(fstubs_name, Void), n_args, n_dflts, ;) \
struct fstubs_name \
: public ::boost::python::detail::overloads_common<fstubs_name> \
{ \
typedef BOOST_PP_CAT(fstubs_name, NonVoid) non_void_return_type; \
typedef BOOST_PP_CAT(fstubs_name, Void) void_return_type; \
BOOST_PYTHON_GEN_FUNCTION( \
fname, non_void_return_type, n_args, n_dflts, return) \
BOOST_PYTHON_GEN_FUNCTION( \
fname, void_return_type, n_args, n_dflts, ;) \
\
BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts) \
};
# define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \
BOOST_PYTHON_GEN_MEM_FUNCTION( \
fname, BOOST_PP_CAT(fstubs_name, NonVoid), n_args, n_dflts, return) \
BOOST_PYTHON_GEN_MEM_FUNCTION( \
fname, BOOST_PP_CAT(fstubs_name, Void), n_args, n_dflts, ;) \
struct fstubs_name \
: public ::boost::python::detail::overloads_common<fstubs_name> \
{ \
typedef BOOST_PP_CAT(fstubs_name, NonVoid) non_void_return_type; \
typedef BOOST_PP_CAT(fstubs_name, Void) void_return_type; \
BOOST_PYTHON_GEN_MEM_FUNCTION( \
fname, non_void_return_type, n_args, n_dflts, return) \
BOOST_PYTHON_GEN_MEM_FUNCTION( \
fname, void_return_type, n_args, n_dflts, ;) \
\
BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts) \
};
# else // !defined(BOOST_NO_VOID_RETURNS)
# define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \
BOOST_PYTHON_GEN_FUNCTION( \
fname, BOOST_PP_CAT(fstubs_name, NonVoid), n_args, n_dflts, return) \
struct fstubs_name \
: public ::boost::python::detail::overloads_common<fstubs_name> \
{ \
typedef BOOST_PP_CAT(fstubs_name, NonVoid) non_void_return_type; \
typedef BOOST_PP_CAT(fstubs_name, NonVoid) void_return_type; \
BOOST_PYTHON_GEN_FUNCTION( \
fname, non_void_return_type, n_args, n_dflts, return) \
\
typedef non_void_return_type void_return_type; \
BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts) \
};
# define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \
BOOST_PYTHON_GEN_MEM_FUNCTION( \
fname, BOOST_PP_CAT(fstubs_name, NonVoid), n_args, n_dflts, return) \
struct fstubs_name \
: public ::boost::python::detail::overloads_common<fstubs_name> \
{ \
typedef BOOST_PP_CAT(fstubs_name, NonVoid) non_void_return_type; \
typedef BOOST_PP_CAT(fstubs_name, NonVoid) void_return_type; \
BOOST_PYTHON_GEN_MEM_FUNCTION( \
fname, non_void_return_type, n_args, n_dflts, return) \
\
typedef non_void_return_type void_return_type; \
BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts) \
};

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

4
include/boost/python/detail/type_list_impl_no_pts.hpp
View File

@@ -95,9 +95,9 @@ struct type_list_impl_chooser<N>
>
struct result_
{
typedef BOOST_PP_CAT(mpl::list,N)<
typedef typename BOOST_PP_CAT(mpl::list,N)<
BOOST_PP_ENUM_PARAMS(N, T)
> type;
>::type type;
};
};

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_

142
include/boost/python/dict.hpp
View File

@@ -8,110 +8,126 @@
namespace boost { namespace python {
class dict : public object
class dict;
namespace detail
{
public:
struct BOOST_PYTHON_DECL dict_base : object
{
// D.clear() -> None. Remove all items from D.
void clear();
// D.copy() -> a shallow copy of D
dict copy();
// D.get(k[,d]) -> D[k] if D.has_key(k), else d. d defaults to None.
object get(object_cref k) const;
object get(object_cref k, object_cref d) const;
// D.has_key(k) -> 1 if D has a key k, else 0
bool has_key(object_cref k) const;
// D.items() -> list of D's (key, value) pairs, as 2-tuples
list items() const;
// D.iteritems() -> an iterator over the (key, value) items of D
object iteritems() const;
// D.iterkeys() -> an iterator over the keys of D
object iterkeys() const;
// D.itervalues() -> an iterator over the values of D
object itervalues() const;
// D.keys() -> list of D's keys
list keys() const;
// D.popitem() -> (k, v), remove and return some (key, value) pair as a
// 2-tuple; but raise KeyError if D is empty
tuple popitem();
// D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if not D.has_key(k)
object setdefault(object_cref k);
object setdefault(object_cref k, object_cref d);
// D.update(E) -> None. Update D from E: for k in E.keys(): D[k] = E[k]
void update(object_cref E);
// D.values() -> list of D's values
list values() const;
protected:
// dict() -> new empty dictionary.
// dict(mapping) -> new dictionary initialized from a mapping object's
// (key, value) pairs.
// dict(seq) -> new dictionary initialized as if via:
dict_base(); // new dict
explicit dict_base(object_cref data);
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(dict_base, object)
private:
static detail::new_reference call(object const&);
};
}
class dict : public detail::dict_base
{
typedef detail::dict_base base;
public:
// dict() -> new empty dictionary.
// dict(mapping) -> new dictionary initialized from a mapping object's
// (key, value) pairs.
// dict(seq) -> new dictionary initialized as if via:
BOOST_PYTHON_DECL dict(); // new dict
explicit BOOST_PYTHON_DECL dict(object_cref data);
dict() {} // new dict
template <class T>
explicit dict(T const& data)
: object(dict::call(object(data)))
: base(object(data))
{
}
// D.clear() -> None. Remove all items from D.
BOOST_PYTHON_DECL void clear();
// D.copy() -> a shallow copy of D
BOOST_PYTHON_DECL dict copy();
// D.get(k[,d]) -> D[k] if D.has_key(k), else d. d defaults to None.
BOOST_PYTHON_DECL object get(object_cref k) const;
template<class T>
object get(T const& k) const
{
return this->get(object(k));
return base::get(object(k));
}
BOOST_PYTHON_DECL object get(object_cref k, object_cref d) const;
template<class T1, class T2>
object get(T1 const& k, T2 const& d) const
{
return this->get(object(k),object(d));
return base::get(object(k),object(d));
}
// D.has_key(k) -> 1 if D has a key k, else 0
BOOST_PYTHON_DECL bool has_key(object_cref k) const;
template<class T>
bool has_key(T const& k) const
{
return this->has_key(object(k));
return base::has_key(object(k));
}
// D.items() -> list of D's (key, value) pairs, as 2-tuples
BOOST_PYTHON_DECL list items() const;
// D.iteritems() -> an iterator over the (key, value) items of D
BOOST_PYTHON_DECL object iteritems() const;
// D.iterkeys() -> an iterator over the keys of D
BOOST_PYTHON_DECL object iterkeys() const;
// D.itervalues() -> an iterator over the values of D
BOOST_PYTHON_DECL object itervalues() const;
// D.keys() -> list of D's keys
BOOST_PYTHON_DECL list keys() const;
// D.popitem() -> (k, v), remove and return some (key, value) pair as a
// 2-tuple; but raise KeyError if D is empty
BOOST_PYTHON_DECL tuple popitem();
// D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if not D.has_key(k)
BOOST_PYTHON_DECL object setdefault(object_cref k);
template<class T>
object setdefault(T const& k)
{
return this->setdefault(object(k));
return base::setdefault(object(k));
}
BOOST_PYTHON_DECL object setdefault(object_cref k, object_cref d);
template<class T1, class T2>
object setdefault(T1 const& k, T2 const& d)
{
return this->setdefault(object(k),object(d));
return base::setdefault(object(k),object(d));
}
// D.update(E) -> None. Update D from E: for k in E.keys(): D[k] = E[k]
BOOST_PYTHON_DECL void update(object_cref E);
template<class T>
void update(T const& E)
{
this->update(object(E));
base::update(object(E));
}
// D.values() -> list of D's values
BOOST_PYTHON_DECL list values() const;
public: // implementation detail -- for internal use only
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(dict, object)
private:
static BOOST_PYTHON_DECL detail::new_reference call(object const&);
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(dict, base)
};
//
// Converter Specializations
//

30
include/boost/python/init.hpp
View File

@@ -12,6 +12,8 @@
#include <boost/python/detail/type_list.hpp>
#include <boost/python/args_fwd.hpp>
#include <boost/python/detail/make_keyword_range_fn.hpp>
#include <boost/mpl/fold_backward.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/apply_if.hpp>
@@ -281,34 +283,6 @@ class init : public init_base<init<BOOST_PYTHON_OVERLOAD_ARGS> >
BOOST_STATIC_CONSTANT(int, n_arguments = mpl::size<reversed_args>::value);
};
# if 1
template <> // specialization for zero args
class init<> : public init_base<init<> >
{
typedef init_base<init<> > base;
public:
typedef init<> self_t;
init(char const* doc_ = 0)
: base(doc_)
{
}
template <class CallPoliciesT>
init_with_call_policies<CallPoliciesT, self_t>
operator[](CallPoliciesT const& policies) const
{
return init_with_call_policies<CallPoliciesT, self_t>(
policies, this->doc_string(), this->keywords());
}
BOOST_STATIC_CONSTANT(int, n_defaults = 0);
BOOST_STATIC_CONSTANT(int, n_arguments = 0);
typedef detail::type_list<> reversed_args;
};
# endif
///////////////////////////////////////////////////////////////////////////////
//
// optional

97
include/boost/python/list.hpp
View File

@@ -11,93 +11,116 @@
namespace boost { namespace python {
class list : public object
namespace detail
{
struct BOOST_PYTHON_DECL list_base : object
{
void append(object_cref); // append object to end
long count(object_cref value) const; // return number of occurrences of value
void extend(object_cref sequence); // extend list by appending sequence elements
long index(object_cref value) const; // return index of first occurrence of value
void insert(int index, object_cref); // insert object before index
void insert(object const& index, object_cref);
object pop(); // remove and return item at index (default last)
object pop(long index);
object pop(object const& index);
void remove(object_cref value); // remove first occurrence of value
void reverse(); // reverse *IN PLACE*
void sort(); // sort *IN PLACE*; if given, cmpfunc(x, y) -> -1, 0, 1
void sort(object_cref cmpfunc);
protected:
list_base(); // new list
explicit list_base(object_cref sequence); // new list initialized from sequence's items
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(list_base, object)
private:
static detail::new_non_null_reference call(object const&);
};
}
class list : public detail::list_base
{
typedef detail::list_base base;
public:
BOOST_PYTHON_DECL list(); // new list
explicit BOOST_PYTHON_DECL list(object_cref sequence); // new list initialized from sequence's items
list() {} // new list
template <class T>
explicit list(T const& sequence)
: object(list::call(object(sequence)))
: base(object(sequence))
{
}
BOOST_PYTHON_DECL void append(object_cref); // append object to end
template <class T>
void append(T const& x)
{
this->append(object(x));
base::append(object(x));
}
BOOST_PYTHON_DECL long count(object_cref value) const; // return number of occurrences of value
template <class T>
long count(T const& value) const
{
return this->count(object(value));
return base::count(object(value));
}
BOOST_PYTHON_DECL void extend(object_cref sequence); // extend list by appending sequence elements
template <class T>
void extend(T const& x)
{
this->extend(object(x));
base::extend(object(x));
}
BOOST_PYTHON_DECL long index(object_cref value) const; // return index of first occurrence of value
template <class T>
long index(T const& x) const
{
return this->index(object(x));
return base::index(object(x));
}
BOOST_PYTHON_DECL void insert(int index, object_cref); // insert object before index
BOOST_PYTHON_DECL void insert(object const& index, object_cref);
template <class T>
void insert(int index, T const& x) // insert object before index
{
this->insert(index, object(x));
base::insert(index, object(x));
}
template <class T>
void insert(object const& index, T const& x) // insert object before index
{
this->insert(index, object(x));
base::insert(index, object(x));
}
BOOST_PYTHON_DECL object pop(); // remove and return item at index (default last)
BOOST_PYTHON_DECL object pop(long index);
BOOST_PYTHON_DECL object pop(object const& index);
BOOST_PYTHON_DECL void remove(object_cref value); // remove first occurrence of value
object pop() { return base::pop(); }
object pop(long index) { return base::pop(index); }
template <class T>
object pop(T const& index)
{
return base::pop(object(index));
}
template <class T>
void remove(T const& value)
{
this->remove(object(value));
base::remove(object(value));
}
void sort() { base::sort(); }
BOOST_PYTHON_DECL void reverse(); // reverse *IN PLACE*
BOOST_PYTHON_DECL void sort(); // sort *IN PLACE*; if given, cmpfunc(x, y) -> -1, 0, 1
BOOST_PYTHON_DECL void sort(object_cref cmpfunc);
template <class T>
void sort(T const& value)
{
this->sort(object(value));
base::sort(object(value));
}
public: // implementation detail -- for internal use only
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(list, object)
private:
static BOOST_PYTHON_DECL detail::new_non_null_reference call(object const&);
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(list, base)
};
//

36
include/boost/python/long.hpp
View File

@@ -11,31 +11,43 @@
namespace boost { namespace python {
class long_ : public object
namespace detail
{
struct BOOST_PYTHON_DECL long_base : object
{
protected:
long_base(); // new long_
explicit long_base(object_cref rhs);
explicit long_base(object_cref rhs, object_cref base);
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(long_base, object)
private:
static detail::new_non_null_reference call(object const&);
static detail::new_non_null_reference call(object const&, object const&);
};
}
class long_ : public detail::long_base
{
typedef detail::long_base base;
public:
BOOST_PYTHON_DECL long_(); // new long_
explicit BOOST_PYTHON_DECL long_(object_cref rhs);
long_() {} // new long_
template <class T>
explicit long_(T const& rhs)
: object(long_::call(object(rhs)))
: base(object(rhs))
{
}
explicit BOOST_PYTHON_DECL long_(object_cref rhs, object_cref base);
template <class T, class U>
explicit long_(T const& rhs, U const& base)
: object(long_::call(object(rhs), object(base)))
: base(object(rhs), object(base))
{
}
public: // implementation detail -- for internal use only
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(long_, object)
private:
static BOOST_PYTHON_DECL detail::new_non_null_reference call(object const&);
static BOOST_PYTHON_DECL detail::new_non_null_reference call(object const&, object const&);
public: // implementation detail -- for internal use only
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(long_, base)
};
//

99
include/boost/python/module.hpp
View File

@@ -6,104 +6,7 @@
#ifndef MODULE_DWA2001128_HPP
# define MODULE_DWA2001128_HPP
# include <boost/python/errors.hpp>
# include <boost/python/detail/config.hpp>
# include <boost/python/make_function.hpp>
# include <boost/python/class_fwd.hpp>
# include <boost/python/detail/module_base.hpp>
# include <boost/python/module_init.hpp>
# include <boost/python/object_core.hpp>
# include <boost/python/detail/def_helper.hpp>
# include <boost/python/detail/defaults_def.hpp>
# include <boost/python/signature.hpp>
namespace boost { namespace python {
class module : public detail::module_base
{
public:
typedef detail::module_base base;
module(char const* name, char const* doc = 0)
: base(name, doc) {}
// Add elements to the module
template <class T>
module& setattr(const char* name, T const& x)
{
this->base::setattr_doc(name, python::object(x), 0);
return *this;
}
module& add(type_handle x); // just use the type's name
template <class T1, class T2 , class T3, class T4>
module& add(class_<T1,T2,T3,T4> const& c)
{
// Soon to disappear...
return *this;
}
template <class Fn>
module& def(char const* name, Fn fn)
{
this->setattr_doc(
name, boost::python::make_function(fn), 0);
return *this;
}
template <class Arg1T, class Arg2T>
module& def(char const* name, Arg1T arg1, Arg2T const& arg2, char const* doc = 0)
{
dispatch_def(name, arg1, arg2, doc, &arg2);
return *this;
}
private:
template <class Fn, class CallPolicyOrDoc>
void
dispatch_def(
char const* name,
Fn fn,
CallPolicyOrDoc const& policy_or_doc,
char const* doc,
void const*)
{
detail::def_helper<CallPolicyOrDoc,char const*> helper(policy_or_doc, doc);
this->setattr_doc(
name
, boost::python::make_function(fn, helper.policies())
, helper.doc());
}
template <typename StubsT, typename SigT>
void
dispatch_def(
char const* name,
SigT sig,
StubsT const& stubs,
char const* doc,
detail::overloads_base const*)
{
// convert sig to a type_list (see detail::get_signature in signature.hpp)
// before calling detail::define_with_defaults.
detail::define_with_defaults(
name, stubs, *this, detail::get_signature(sig));
}
};
//
// inline implementations
//
inline module& module::add(type_handle x)
{
this->base::add(x);
return *this;
}
}} // namespace boost::python
# define BOOST_PYTHON_MODULE BOOST_PYTHON_MODULE_INIT
#endif // MODULE_DWA20011221_HPP

5
include/boost/python/object/class.hpp
View File

@@ -35,7 +35,6 @@ struct BOOST_PYTHON_DECL class_base : python::api::object
void add_property(char const* name, object const& fget);
void add_property(char const* name, object const& fget, object const& fset);
void setattr(char const* name, object const&);
void enable_pickling(bool getstate_manages_dict);
// Set a special attribute in the class which tells Boost.Python
// to allocate extra bytes for embedded C++ objects in Python
@@ -45,6 +44,10 @@ struct BOOST_PYTHON_DECL class_base : python::api::object
// Set an __init__ function which throws an appropriate exception
// for abstract classes.
void def_no_init();
// Implementation detail. Hiding this in the private section would
// require use of template friend declarations.
void enable_pickling(bool getstate_manages_dict);
};
}}} // namespace boost::python::objects

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