|
+ |
+
+ Boost.Python+Extractor Concept+ |
+
An Extractor is a class which Boost.Python can use to extract C++
+objects from Python objects, and is typically used by facilities that
+define from_python conversions for
+"traditional" Python extension types.
+
+
In the table below, X denotes a model of
+Extractor and a denotes an instance of a Python
+object type.
+
+
| Expression | +Type | +Semantics | +
X::execute(a) |
+ non-void + | Returns the C++ object being extracted. The
+ execute function must not be overloaded.
+ |
&a.ob_type
+ | PyTypeObject**
+ | Points to the ob_type field of an object which is
+ layout-compatible with PyObject
+ |
execute member must be a
+non-overloaded static function whose single argument is a Python
+object type. Acceptable Python object types include those publicly (and
+unambiguously) derived from PyObject, and POD types which
+are layout-compatible with PyObject.
+
+Revised + + 22 May, 2002 + +
+© Copyright Dave + Abrahams 2002. All Rights Reserved. + +
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. + + diff --git a/doc/v2/lvalue_from_pytype.html b/doc/v2/lvalue_from_pytype.html new file mode 100755 index 00000000..8b3cb49e --- /dev/null +++ b/doc/v2/lvalue_from_pytype.html @@ -0,0 +1,283 @@ + + + + + +
|
+ |
+ Boost.Python+ +Header <boost/python/lvalue_from_pytype.hpp>+ |
lvalue_from_pytype
+
+ <boost/python/lvalue_from_pytype.hpp> supplies
+ a facility for extracting C++ objects from within Python instances
+ of a given type. This is typically useful for dealing with
+ "traditional" Python extension types.
+
+ lvalue_from_pytypeClass template lvalue_from_pytype will register
+ from_python converters which, given an object of the given Python
+ type, can extract references and pointers to a particular C++
+ type. Its template arguments are:
+
+
+ + +
| Parameter + + | Requirements + + | Semantics + + |
|---|---|---|
Extractor
+
+ | a model of Extractor whose + execute function returns a reference type. + + | Extracts the lvalue from the Python object once its type has been confirmed + + |
python_type
+
+ | A compile-time constant PyTypeObject*
+
+ | The Python type of instances convertible by this + converter. Python subtypes are also convertible. + + |
lvalue_from_pytype synopsis
+namespace boost { namespace python
+{
+ template <class Extractor, PyTypeObject const* python_type>
+ struct lvalue_from_pytype
+ {
+ lvalue_from_pytype();
+ };
+}}
+
+
+ lvalue_from_pytype constructor+lvalue_from_pytype(); ++ +
Extractor::execute.
+
+ extract_identityextract_identity is a model of Extractor which can be
+ used in the common case where the C++ type to be extracted is the
+ same as the Python object type.
+
+
extract_identity synopsis
+namespace boost { namespace python
+{
+ template <class InstanceType>
+ struct extract_identity
+ {
+ static InstanceType& execute(InstanceType& c);
+ };
+}}
+
+
+ extract_identity static functions+InstanceType& execute(InstanceType& c); ++ +
c
+
+ extract_memberextract_member is a model of Extractor which can be
+ used in the common case in the common case where the C++
+ type to be extracted is a member of the Python object.
+
+
extract_member synopsis
+namespace boost { namespace python
+{
+ template <class InstanceType, class MemberType, MemberType (InstanceType::*member)>
+ struct extract_member
+ {
+ static MemberType& execute(InstanceType& c);
+ };
+}}
+
+
+ extract_member static functions+static MemberType& execute(InstanceType& c); ++ +
c.*member
+
+ Noddys. Since
+noddy_NoddyObject is so simple that it carries no
+interesting information, the example is a bit contrived: it assumes
+you want to keep track of one particular object for some reason. This
+module would have to be dynamically linked to the module which defines
+noddy_NoddyType.
+
+
+#include <boost/python/reference.hpp>
+#include <boost/python/module.hpp>
+
+// definition lifted from the Python docs
+typedef struct {
+ PyObject_HEAD
+} noddy_NoddyObject;
+
+using namespace boost::python;
+static reference<PyObject> cache;
+
+bool is_cached(noddy_NoddyObject* x)
+{
+ return x == cache.get();
+}
+
+void set_cache(noddy_NoddyObject* x)
+{
+ cache.reset((PyObject*)x, ref::increment_count);
+}
+
+BOOST_PYTHON_MODULE_INIT(noddy_cache)
+{
+ module noddy_cache("noddy_cache")
+ .def("is_cached", is_cached)
+ .def("set_cache", set_cache)
+ ;
+
+ // register Noddy lvalue converter
+ lvalue_from_pytype<extract_identity<noddy_NoddyObject>,&noddy_NoddyType>();
+}
+
+
++>>> import noddy +>>> n = noddy.new_noddy() +>>> import noddy_cache +>>> noddy_cache.is_cached(n) +0 +>>> noddy_cache.set_cache(n) +>>> noddy_cache.is_cached(n) +1 +>>> noddy_cache.is_cached(noddy.new_noddy()) +0 ++ +
Revised + + 05 November, 2001 + + + +
© Copyright Dave + Abrahams 2002. All Rights Reserved. + diff --git a/doc/v2/reference.html b/doc/v2/reference.html index 71191cee..06fc346f 100644 --- a/doc/v2/reference.html +++ b/doc/v2/reference.html @@ -61,6 +61,9 @@