![]() |
slice_nilconst_attribute_policiesconst_attribute_policies
static functionsattribute_policiesattribute_policies static
functionsconst_objattribute_policiesconst_objattribute_policies
static functionsobjattribute_policiesobjattribute_policies static
functionsconst_item_policiesconst_item_policies static
functionsitem_policiesitem_policies static functionsconst_slice_policiesconst_slice_policies static
functionsslice_policiesslice_policies static functionsobject_operatorsobject_operators
observer functionsobjectobject constructors and destructorobject modifiersproxyproxy observer functionsproxy modifier functionsExposes the generic Python object wrapper class object, and related classes. In order to avoid some potenential problems with argument-dependent lookup and the generalized operators defined on object, all these facilities are defined in namespace boost::python::api, and object is imported into namespace boost::python with a using-declaration.
class slice_nil; static const _ = slice_nil();
A type that can be used to get the effect of leaving out an index in a Python slice expression:
>>> x[:-1] >>> x[::-1]
C++ equivalent:
x.slice(_,-1) x[slice(_,_,-1)]
The policies which are used for proxies representing an attribute access to a const object.
namespace boost { namespace python { namespace api { struct const_attribute_policies { typedef char const* key_type; static object get(object const& target, char const* key); }; }}}
static object get(object const& target, char const* key);
key is an ntbs.
accesses the attribute of target named by key.
An object managing the result of the attribute access.
error_already_set if a Python exception is raised.
The policies which are used for proxies representing an attribute access to a mutable object.
namespace boost { namespace python { namespace api { struct attribute_policies : const_attribute_policies { static object const& set(object const& target, char const* key, object const& value); static void del(object const&target, char const* key); }; }}}
static object const& set(object const& target, char const* key, object const& value);
key is an ntbs.
sets the attribute of target named by key to value.
error_already_set if a Python exception is raised.
static void del(object const&target, char const* key);
key is an ntbs.
deletes the attribute of target named by key.
error_already_set if a Python exception is raised.
The policies which are used for proxies representing an attribute access to a const object when the attribute name is given as a const object.
namespace boost { namespace python { namespace api { struct const_objattribute_policies { typedef object const& key_type; static object get(object const& target, object const& key); }; }}}
static object get(object const& target, object const& key);
key is an object holding a string.
accesses the attribute of target named by key.
An object managing the result of the attribute access.
error_already_set if a Python exception is raised.
The policies which are used for proxies representing an attribute access to a mutable object when the attribute name is given as a const object.
namespace boost { namespace python { namespace api { struct objattribute_policies : const_objattribute_policies { static object const& set(object const& target, object const& key, object const& value); static void del(object const&target, object const& key); }; }}}
static object const& set(object const& target, object const& key, object const& value);
key is an object holding a string.
sets the attribute of target named by key to value.
error_already_set if a Python exception is raised.
static void del(object const&target, object const& key);
key is an object holding a string.
deletes the attribute of target named by key.
error_already_set if a Python exception is raised.
The policies which are used for proxies representing an item access (via the Python bracket operators []) to a const object.
namespace boost { namespace python { namespace api { struct const_item_policies { typedef object key_type; static object get(object const& target, object const& key); }; }}}
static object get(object const& target, object const& key);
accesses the item of target specified by key.
An object managing the result of the item access.
error_already_set if a Python exception is raised.
The policies which are used for proxies representing an item access (via the Python bracket operators []) to a mutable object.
namespace boost { namespace python { namespace api { struct item_policies : const_item_policies { static object const& set(object const& target, object const& key, object const& value); static void del(object const& target, object const& key); }; }}}
static object const& set(object const& target, object const& key, object const& value);
sets the item of target specified by key to value.
error_already_set if a Python exception is raised.
static void del(object const& target, object const& key);
deletes the item of target specified by key.
error_already_set if a Python exception is raised.
The policies which are used for proxies representing an slice access (via the Python slice notation [x:y]) to a const object.
namespace boost { namespace python { namespace api { struct const_slice_policies { typedef std::pair<handle<>, handle<> > key_type; static object get(object const& target, key_type const& key); }; }}}
static object get(object const& target, key_type const& key);
accesses the slice of target specified by key.
An object managing the result of the slice access.
error_already_set if a Python exception is raised.
The policies which are used for proxies representing an slice access to a mutable object.
namespace boost { namespace python { namespace api { struct slice_policies : const_slice_policies { static object const& set(object const& target, key_type const& key, object const& value); static void del(object const& target, key_type const& key); }; }}}
static object const& set(object const& target, key_type const& key, object const& value);
sets the slice of target specified by key to value.
error_already_set if a Python exception is raised.
static void del(object const& target, key_type const& key);
deletes the slice of target specified by key.
error_already_set if a Python exception is raised.
This is the base class of object and its proxy template used to supply common interface: member functions, and operators which must be defined within the class body. Its template parameter U is expected to be a class derived from object_operators<U>. In practice users should never use this class directly, but it is documented here because it supplies important interface to object and its proxies.
namespace boost { namespace python { namespace api { template <class U> class object_operators { public: // function call // object operator()() const; template <class A0> object operator()(A0 const&) const; template <class A0, class A1> object operator()(A0 const&, A1 const&) const; ... template <class A0, class A1,...class An> object operator()(A0 const&, A1 const&,...An const&) const; detail::args_proxy operator* () const; object operator()(detail::args_proxy const &args) const; object operator()(detail::args_proxy const &args, detail::kwds_proxy const &kwds) const; // truth value testing // typedef unspecified bool_type; operator bool_type() const; // Attribute access // proxy<const_object_attribute> attr(char const*) const; proxy<object_attribute> attr(char const*); proxy<const_object_objattribute> attr(object const&) const; proxy<object_objattribute> attr(object const&); // item access // template <class T> proxy<const_object_item> operator[](T const& key) const; template <class T> proxy<object_item> operator[](T const& key); // slicing // template <class T, class V> proxy<const_object_slice> slice(T const& start, V const& end) const template <class T, class V> proxy<object_slice> slice(T const& start, V const& end); }; }}}
object operator()() const; template <class A0> object operator()(A0 const&) const; template <class A0, class A1> object operator()(A0 const&, A1 const&) const; ... template <class A0, class A1,...class An> object operator()(A0 const& a1, A1 const& a2,...An const& aN) const;
call<object>(object(*static_cast<U*>(this)).ptr(),
a1,
a2,...aN)
object operator()(detail::args_proxy const &args) const;
call object
with arguments
given by
the tuple
args
object operator()(detail::args_proxy const &args, detail::kwds_proxy const &kwds) const;
call object
with arguments
given by
the tuple
args,
and named
arguments given
by the
dictionary kwds
operator bool_type() const;
Tests truth value of *this.
call<object>(object(*static_cast<U*>(this)).ptr(),
a1,
a2,...aN)
proxy<const_object_attribute> attr(char const* name) const; proxy<object_attribute> attr(char const* name);
name is an ntbs.
accesses the named attribute of *this.
a proxy object which binds object(*static_cast<U*>(this)) as its target, and name as its
key.
proxy<const_object_objattribute> attr(const object& name) const; proxy<object_objattribute> attr(const object& name);
name is a object holding a string.
accesses the named attribute of *this.
a proxy object which binds object(*static_cast<U*>(this)) as its target, and name as its
key.
template <class T> proxy<const_object_item> operator[](T const& key) const; template <class T> proxy<object_item> operator[](T const& key);
accesses the item of *this indicated by key.
a proxy object which binds object(*static_cast<U*>(this)) as its target, and object(key)
as its key.
template <class T, class V> proxy<const_object_slice> slice(T const& start; start, V const& finish) const template <class T, class V> proxy<object_slice> slice(T const& start; start, V const& finish);
accesses the slice of *this indicated by std::make_pair(object(start), object(finish)).
a proxy object which binds object(*static_cast<U*>(this)) as its target, and std::make_pair(object(start),
object(finish))
as its key.
The intention is that object acts as much like a Python variable as possible.
Thus expressions you'd expect to work in Python should generally work in
the same way from C++. Most of object's interface is provided by its base
class object_operators<object>, and the free functions defined in
this header.
namespace boost { namespace python { namespace api { class object : public object_operators<object> { public: object(); object(object const&); template <class T> explicit object(T const& x); ~object(); object& operator=(object const&); PyObject* ptr() const; bool is_none() const; }; }}}
object();
Constructs an object managing a reference to the Python None object.
nothing.
template <class T> explicit object(T const& x);
converts x to python and manages a reference to it.
error_already_set and sets a Python TypeError exception if no such conversion is possible.
~object();
decrements the reference count of the internally-held object.
PyObject* ptr() const;
a pointer to the internally-held Python object.
bool is_none() const;
result of (ptr() == Py_None)
This template is instantiated with various Policies described in this document in order to implement attribute, item, and slice access for object. It stores an object of type Policies::key_type.
namespace boost { namespace python { namespace api { template <class Policies> class proxy : public object_operators<proxy<Policies> > { public: operator object() const; proxy const& operator=(proxy const&) const; template <class T> inline proxy const& operator=(T const& rhs) const; void del() const; template <class R> proxy operator+=(R const& rhs); template <class R> proxy operator-=(R const& rhs); template <class R> proxy operator*=(R const& rhs); template <class R> proxy operator/=(R const& rhs); template <class R> proxy operator%=(R const& rhs); template <class R> proxy operator<<=(R const& rhs); template <class R> proxy operator>>=(R const& rhs); template <class R> proxy operator&=(R const& rhs); template <class R> proxy operator|=(R const& rhs); }; }}}
operator object() const;
applies Policies::get(target, key) with the proxy's target and key
objects.
proxy const& operator=(proxy const& rhs) const; template <class T> inline proxy const& operator=(T const& rhs) const;
Policies::set(target,
key ,
object(rhs))
with the proxy's target and key objects.
template <class R> proxy operator+=(R const& rhs); template <class R> proxy operator-=(R const& rhs); template <class R> proxy operator*=(R const& rhs); template <class R> proxy operator/=(R const& rhs); template <class R> proxy operator%=(R const& rhs); template <class R> proxy operator<<=(R const& rhs); template <class R> proxy operator>>=(R const& rhs); template <class R> proxy operator&=(R const& rhs); template <class R> proxy operator|=(R const& rhs);
for a given operator@=,
object(*this) @= rhs;
*this
void del() const;
Policies::del(target, key ) with the proxy's target and key objects.
template <class T> void del(proxy<T> const& x);
x.del()
template<class L,class R> object operator>(L const&l,R const&r); template<class L,class R> object operator>=(L const&l,R const&r); template<class L,class R> object operator<(L const&l,R const&r); template<class L,class R> object operator<=(L const&l,R const&r); template<class L,class R> object operator==(L const&l,R const&r); template<class L,class R> object operator!=(L const&l,R const&r);
returns the result of applying the operator to object(l) and object(r), respectively, in Python.
template<class L,class R> object operator+(L const&l,R const&r); template<class L,class R> object operator-(L const&l,R const&r); template<class L,class R> object operator*(L const&l,R const&r); template<class L,class R> object operator/(L const&l,R const&r); template<class L,class R> object operator%(L const&l,R const&r); template<class L,class R> object operator<<(L const&l,R const&r); template<class L,class R> object operator>>(L const&l,R const&r); template<class L,class R> object operator&(L const&l,R const&r); template<class L,class R> object operator^(L const&l,R const&r); template<class L,class R> object operator|(L const&l,R const&r);
returns the result of applying the operator to object(l) and object(r), respectively, in Python.
template<class R> object& operator+=(object&l,R const&r); template<class R> object& operator-=(object&l,R const&r); template<class R> object& operator*=(object&l,R const&r); template<class R> object& operator/=(object&l,R const&r); template<class R> object& operator%=(object&l,R const&r); template<class R> object& operator<<=(object&l,R const&r) template<class R> object& operator>>=(object&l,R const&r); template<class R> object& operator&=(object&l,R const&r); template<class R> object& operator^=(object&l,R const&r); template<class R> object& operator|=(object&l,R const&r);
assigns to l the
result of applying the corresponding Python inplace operator to
l and object(r),
respectively.
l
long len(object const& obj);
PyObject_Length(obj.ptr())
len()
of object.
Python code:
def sum_items(seq): result = 0 for x in seq: result += x return result
C++ version
object sum_items(object seq) { object result = object(0); for (int i = 0; i < len(seq); ++i) result += seq[i]; return result; }