boost/python
2
0
Fork 0
mirror of https://github.com/boostorg/python.git synced 2026-01-28 07:22:31 +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

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

2
include/boost/python/object/instance.hpp
View File

@@ -12,7 +12,7 @@
namespace boost { namespace python
{
struct instance_holder;
struct BOOST_PYTHON_DECL instance_holder;
}} // namespace boost::python
namespace boost { namespace python { namespace objects {

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

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

314
include/boost/python/str.hpp
View File

@@ -15,347 +15,367 @@
namespace boost { namespace python {
class str : public object
{
public:
BOOST_PYTHON_DECL str(); // new str
BOOST_PYTHON_DECL str(const char* s); // new str
explicit BOOST_PYTHON_DECL str(object_cref other);
class str;
namespace detail
{
struct BOOST_PYTHON_DECL str_base : object
{
str capitalize() const;
str center(object_cref width) const;
long count(object_cref sub) const;
long count(object_cref sub, object_cref start) const;
long count(object_cref sub, object_cref start, object_cref end) const;
object decode() const;
object decode(object_cref encoding) const;
object decode(object_cref encoding, object_cref errors) const;
object encode() const;
object encode(object_cref encoding) const;
object encode(object_cref encoding, object_cref errors) const;
bool endswith(object_cref suffix) const;
bool endswith(object_cref suffix, object_cref start) const;
bool endswith(object_cref suffix, object_cref start, object_cref end) const;
str expandtabs() const;
str expandtabs(object_cref tabsize) const;
long find(object_cref sub) const;
long find(object_cref sub, object_cref start) const;
long find(object_cref sub, object_cref start, object_cref end) const;
long index(object_cref sub) const;
long index(object_cref sub, object_cref start) const;
long index(object_cref sub, object_cref start, object_cref end) const;
bool isalnum() const;
bool isalpha() const;
bool isdigit() const;
bool islower() const;
bool isspace() const;
bool istitle() const;
bool isupper() const;
str join(object_cref sequence) const;
str ljust(object_cref width) const;
str lower() const;
str lstrip() const;
str replace(object_cref old, object_cref new_) const;
str replace(object_cref old, object_cref new_, object_cref maxsplit) const;
long rfind(object_cref sub) const;
long rfind(object_cref sub, object_cref start) const;
long rfind(object_cref sub, object_cref start, object_cref end) const;
long rindex(object_cref sub) const;
long rindex(object_cref sub, object_cref start) const;
long rindex(object_cref sub, object_cref start, object_cref end) const;
str rjust(object_cref width) const;
str rstrip() const;
list split() const;
list split(object_cref sep) const;
list split(object_cref sep, object_cref maxsplit) const;
list splitlines() const;
list splitlines(object_cref keepends) const;
bool startswith(object_cref prefix) const;
bool startswith(object_cref prefix, object_cref start) const;
bool startswith(object_cref prefix, object_cref start, object_cref end) const;
str strip() const;
str swapcase() const;
str title() const;
str translate(object_cref table) const;
str translate(object_cref table, object_cref deletechars) const;
str upper() const;
protected:
str_base(); // new str
str_base(const char* s); // new str
explicit str_base(object_cref other);
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(str_base, object)
private:
static new_reference call(object const&);
};
}
class str : public detail::str_base
{
typedef detail::str_base base;
public:
str() {} // new str
str(const char* s) : base(s) {} // new str
template <class T>
explicit str(T const& other)
: object(str::call(object(other)))
: base(object(other))
{
}
BOOST_PYTHON_DECL str capitalize() const ;
BOOST_PYTHON_DECL str center(object_cref width) const ;
template <class T>
str center(T const& width) const
{
return this->center(object(width));
return base::center(object(width));
}
BOOST_PYTHON_DECL long count(object_cref sub) const;
template<class T>
long count(T const& sub) const
{
return this->count(object(sub));
return base::count(object(sub));
}
BOOST_PYTHON_DECL long count(object_cref sub, object_cref start) const;
template<class T1, class T2>
long count(T1 const& sub,T2 const& start) const
{
return this->count(object(sub), object(start));
return base::count(object(sub), object(start));
}
BOOST_PYTHON_DECL long count(object_cref sub, object_cref start, object_cref end) const;
template<class T1, class T2, class T3>
long count(T1 const& sub,T2 const& start, T3 const& end) const
{
return this->count(object(sub), object(start));
return base::count(object(sub), object(start));
}
BOOST_PYTHON_DECL object decode() const;
BOOST_PYTHON_DECL object decode(object_cref encoding) const;
object decode() const { return base::decode(); }
template<class T>
object decode(T const& encoding) const
{
return this->decode(object(encoding));
return base::decode(object(encoding));
}
BOOST_PYTHON_DECL object decode(object_cref encoding, object_cref errors) const;
template<class T1, class T2>
object decode(T1 const& encoding, T2 const& errors) const
{
return this->decode(object(encoding),object(errors));
return base::decode(object(encoding),object(errors));
}
BOOST_PYTHON_DECL object encode() const;
BOOST_PYTHON_DECL object encode(object_cref encoding) const;
object encode() const { return base::encode(); }
template <class T>
object encode(T const& encoding) const
{
return this->encode(object(encoding));
return base::encode(object(encoding));
}
BOOST_PYTHON_DECL object encode(object_cref encoding, object_cref errors) const;
template <class T1, class T2>
object encode(T1 const& encoding, T2 const& errors) const
{
return this->encode(object(encoding),object(errors));
return base::encode(object(encoding),object(errors));
}
BOOST_PYTHON_DECL bool endswith(object_cref suffix) const;
template <class T>
bool endswith(T const& suffix) const
{
return this->endswith(object(suffix));
return base::endswith(object(suffix));
}
BOOST_PYTHON_DECL bool endswith(object_cref suffix, object_cref start) const;
template <class T1, class T2>
bool endswith(T1 const& suffix, T2 const& start) const
{
return this->endswith(object(suffix), object(start));
return base::endswith(object(suffix), object(start));
}
BOOST_PYTHON_DECL bool endswith(object_cref suffix, object_cref start, object_cref end) const;
template <class T1, class T2, class T3>
bool endswith(T1 const& suffix, T2 const& start, T3 const& end) const
{
return this->endswith(object(suffix), object(start), object(end));
return base::endswith(object(suffix), object(start), object(end));
}
BOOST_PYTHON_DECL str expandtabs() const;
BOOST_PYTHON_DECL str expandtabs(object_cref tabsize) const;
str expandtabs() const { return base::expandtabs(); }
template <class T>
str expandtabs(T const& tabsize) const
{
return this->expandtabs(object(tabsize));
return base::expandtabs(object(tabsize));
}
BOOST_PYTHON_DECL long find(object_cref sub) const;
template <class T>
long find(T const& sub) const
{
return this->find(object(sub));
return base::find(object(sub));
}
BOOST_PYTHON_DECL long find(object_cref sub, object_cref start) const;
template <class T1, class T2>
long find(T1 const& sub, T2 const& start) const
{
return this->find(object(sub), object(start));
return base::find(object(sub), object(start));
}
BOOST_PYTHON_DECL long find(object_cref sub, object_cref start, object_cref end) const;
template <class T1, class T2, class T3>
long find(T1 const& sub, T2 const& start, T3 const& end) const
{
return this->find(object(sub), object(start), object(end));
return base::find(object(sub), object(start), object(end));
}
BOOST_PYTHON_DECL long index(object_cref sub) const;
template <class T>
long index(T const& sub) const
{
return this->index(object(sub));
return base::index(object(sub));
}
BOOST_PYTHON_DECL long index(object_cref sub, object_cref start) const;
template <class T1, class T2>
long index(T1 const& sub, T2 const& start) const
{
return this->index(object(sub), object(start));
return base::index(object(sub), object(start));
}
BOOST_PYTHON_DECL long index(object_cref sub, object_cref start, object_cref end) const;
template <class T1, class T2, class T3>
long index(T1 const& sub, T2 const& start, T3 const& end) const
{
return this->index(object(sub), object(start), object(end));
return base::index(object(sub), object(start), object(end));
}
BOOST_PYTHON_DECL bool isalnum() const;
BOOST_PYTHON_DECL bool isalpha() const;
BOOST_PYTHON_DECL bool isdigit() const;
BOOST_PYTHON_DECL bool islower() const;
BOOST_PYTHON_DECL bool isspace() const;
BOOST_PYTHON_DECL bool istitle() const;
BOOST_PYTHON_DECL bool isupper() const;
BOOST_PYTHON_DECL str join(object_cref sequence) const;
template <class T>
str join(T const& sequence) const
{
return this->join(object(sequence));
return base::join(object(sequence));
}
BOOST_PYTHON_DECL str ljust(object_cref width) const;
template <class T>
str ljust(T const& width) const
{
return this->ljust(object(width));
return base::ljust(object(width));
}
BOOST_PYTHON_DECL str lower() const;
BOOST_PYTHON_DECL str lstrip() const;
BOOST_PYTHON_DECL str replace(object_cref old, object_cref new_) const ;
template <class T1, class T2>
str replace(T1 const& old, T2 const& new_) const
{
return this->replace(object(old),object(new_));
return base::replace(object(old),object(new_));
}
BOOST_PYTHON_DECL str replace(object_cref old, object_cref new_, object_cref maxsplit) const ;
template <class T1, class T2, class T3>
str replace(T1 const& old, T2 const& new_, T3 const& maxsplit) const
{
return this->replace(object(old),object(new_),object(maxsplit));
return base::replace(object(old),object(new_), object(maxsplit));
}
BOOST_PYTHON_DECL long rfind(object_cref sub) const;
template <class T>
long rfind(T const& sub) const
{
return this->rfind(object(sub));
return base::rfind(object(sub));
}
BOOST_PYTHON_DECL long rfind(object_cref sub, object_cref start) const;
template <class T1, class T2>
long rfind(T1 const& sub, T2 const& start) const
{
return this->rfind(object(sub), object(start));
return base::rfind(object(sub), object(start));
}
BOOST_PYTHON_DECL long rfind(object_cref sub, object_cref start, object_cref end) const;
template <class T1, class T2, class T3>
long rfind(T1 const& sub, T2 const& start, T3 const& end) const
{
return this->rfind(object(sub), object(start), object(end));
return base::rfind(object(sub), object(start), object(end));
}
BOOST_PYTHON_DECL long rindex(object_cref sub) const;
template <class T>
long rindex(T const& sub) const
{
return this->rindex(object(sub));
return base::rindex(object(sub));
}
BOOST_PYTHON_DECL long rindex(object_cref sub, object_cref start) const;
template <class T1, class T2>
long rindex(T1 const& sub, T2 const& start) const
{
return this->rindex(object(sub), object(start));
return base::rindex(object(sub), object(start));
}
BOOST_PYTHON_DECL long rindex(object_cref sub, object_cref start, object_cref end) const;
template <class T1, class T2, class T3>
long rindex(T1 const& sub, T2 const& start, T3 const& end) const
{
return this->rindex(object(sub), object(start), object(end));
return base::rindex(object(sub), object(start), object(end));
}
BOOST_PYTHON_DECL str rjust(object_cref width) const;
template <class T>
str rjust(T const& width) const
{
return this->rjust(object(width));
return base::rjust(object(width));
}
BOOST_PYTHON_DECL str rstrip() const;
BOOST_PYTHON_DECL list split() const;
BOOST_PYTHON_DECL list split(object_cref sep) const;
list split() const { return base::split(); }
template <class T>
list split(T const& sep) const
{
return this->split(object(sep));
return base::split(object(sep));
}
BOOST_PYTHON_DECL list split(object_cref sep, object_cref maxsplit) const;
template <class T1, class T2>
list split(T1 const& sep, T2 const& maxsplit) const
{
return this->split(object(sep), object(maxsplit));
return base::split(object(sep), object(maxsplit));
}
BOOST_PYTHON_DECL list splitlines() const;
BOOST_PYTHON_DECL list splitlines(object_cref keepends) const;
list splitlines() const { return base::splitlines(); }
template <class T>
list splitlines(T const& keepends) const
{
return this->splitlines(object(keepends));
return base::splitlines(object(keepends));
}
BOOST_PYTHON_DECL bool startswith(object_cref prefix) const ;
template <class T>
bool startswith(T const& prefix) const
{
return this->startswith(object(prefix));
return base::startswith(object(prefix));
}
BOOST_PYTHON_DECL bool startswith(object_cref prefix, object_cref start) const ;
template <class T1, class T2>
bool startswidth(T1 const& prefix, T2 const& start) const
bool startswith(T1 const& prefix, T2 const& start) const
{
return this->startswidth(object(prefix), object(start));
return base::startswith(object(prefix), object(start));
}
BOOST_PYTHON_DECL bool startswith(object_cref prefix, object_cref start, object_cref end) const ;
template <class T1, class T2, class T3>
bool startswidth(T1 const& prefix, T2 const& start, T3 const& end) const
bool startswith(T1 const& prefix, T2 const& start, T3 const& end) const
{
return this->startswidth(object(prefix), object(start), object(end));
return base::startswith(object(prefix), object(start), object(end));
}
BOOST_PYTHON_DECL str strip() const ;
BOOST_PYTHON_DECL str swapcase() const ;
BOOST_PYTHON_DECL str title() const ;
BOOST_PYTHON_DECL str translate(object_cref table) const;
template <class T>
str translate(T const& table) const
{
return this->translate(object(table));
return base::translate(object(table));
}
BOOST_PYTHON_DECL str translate(object_cref table, object_cref deletechars) const;
template <class T1, class T2>
str translate(T1 const& table, T2 const& deletechars) const
{
return this->translate(object(table), object(deletechars));
return base::translate(object(table), object(deletechars));
}
BOOST_PYTHON_DECL str upper() const;
public: // implementation detail -- for internal use only
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(str, object)
private:
static BOOST_PYTHON_DECL detail::new_reference call(object const&);
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(str, base)
};
//

31
include/boost/python/tuple.hpp
View File

@@ -8,26 +8,35 @@
namespace boost { namespace python {
class tuple : public object
namespace detail
{
public:
// tuple() -> an empty tuple
BOOST_PYTHON_DECL tuple();
struct BOOST_PYTHON_DECL tuple_base : object
{
protected:
tuple_base();
tuple_base(object_cref sequence);
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(tuple_base, object)
// tuple(sequence) -> tuple initialized from sequence's items
BOOST_PYTHON_DECL tuple(object_cref sequence);
private:
static detail::new_reference call(object const&);
};
}
class tuple : public detail::tuple_base
{
typedef detail::tuple_base base;
public:
tuple() {}
template <class T>
explicit tuple(T const& sequence)
: object(tuple::call(object(sequence)))
: base(object(sequence))
{
}
public: // implementation detail -- for internal use only
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(tuple, object)
private:
static BOOST_PYTHON_DECL detail::new_reference call(object const&);
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(tuple, base)
};
//