...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
slice_nil
const_attribute_policies
const_attribute_policies
static functionsattribute_policies
attribute_policies
static
functionsconst_objattribute_policies
const_objattribute_policies
static functionsobjattribute_policies
objattribute_policies
static
functionsconst_item_policies
const_item_policies
static
functionsitem_policies
item_policies
static functionsconst_slice_policies
const_slice_policies
static
functionsslice_policies
slice_policies
static functionsobject_operators
object_operators
observer functionsobject
object
constructors and destructorobject
modifiersproxy
proxy
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; }