StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
11472122
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
0
CommunityOwnedDate
CreationDate
2012-07-13T14:07:33.447
FavoriteCount
0
LastActivityDate
2013-09-18T21:59:36.847
LastEditDate
2013-09-18T21:59:36.847
LastEditorUserId
1053968
OwnerUserId
1053968
ParentId
11455578
PostTypeId
2
Score
6
ViewCount
0
LastEditorDisplayName
text
Body
It is possible with <code>__getattr__</code> and custom <code>%MethodCode</code>; however, there are a few points to take into consideration: <ul> <li>An intermediate type/object needs to be created, as <code>a.x</code> will return an object that provides <code>__getitem__</code> and <code>__setitem__</code>. Both methods should raise an <code>IndexError</code> when out of bounds occurs, as this is part of the old protocol used to iterate via <code>__getitem__</code>; without it, a crash would occur when iterating over <code>a.x</code>.</li> <li>In order to guarantee the lifetime of the vector, the <code>a.x</code> object needs to maintain a reference to the object that owns the vector (<code>a</code>). Consider the following code: <pre><code>a = A() x = a.x a = None # If 'x' has a reference to 'a.v' and not 'a', then it may have a # dangling reference, as 'a' is refcounted by python, and 'a.v' is # not refcounted. </code></pre></li> <li>Writing <code>%MethodCode</code> can be difficult, especially when having to manage the reference counting during error cases. It requires an understanding of the python C API and SIP.</li> </ul> For an alternative solution, consider: <ul> <li>Design the python bindings to provide functionality.</li> <li>Design class(es) in python to provide the pythonic interface that uses the bindings.</li> </ul> While the approach has a few drawbacks, such as the code is separated into more files that may need to be distributed with the library, it does provide some major benefits: <ul> <li>It is much easier to implement a pythonic interface in python than in C or the interoperability library's interface.</li> <li>Support for slicing, iterators, etc. can be more naturally implemented in python, instead of having to manage it through the C API.</li> <li>Can leverage python's garbage collector to manage the lifetime of the underlying memory.</li> <li>The pythonic interface is decoupled from whatever implementation is being used to provide interoperability between python and C++. With a flatter and simpler binding interface, changing between implementations, such as Boost.Python and SIP, is much easier.</li> </ul> <hr> Here is an walk-through demonstrating this approach. First, we start with the basic <code>A</code> class. In this example, I have provided a constructor that will set some initial data. <code>a.hpp</code>: <pre><code>#ifndef A_HPP #define A_HPP #include <vector> class A { std::vector< double > v; public: A() { for ( int i = 0; i < 6; ++i ) v.push_back( i ); } double& x( int i ) { return v[2*i]; } double x( int i ) const { return v[2*i]; } double& y( int i ) { return v[2*i+1]; } double y( int i ) const { return v[2*i+1]; } std::size_t size() const { return v.size() / 2; } }; #endif // A_HPP </code></pre> Before doing the bindings, lets examine the <code>A</code> interface. While it is an easy interface to use in C++, it has some difficulties in python: <ul> <li>Python does not support overloaded methods, and idioms to support overloading will fail when the argument type/counts are the same.</li> <li>The concept of a reference to a double (float in Python) is different between the two languages. In Python, the float is an immutable type, so its value cannot be changed. For example, in Python the statement <code>n = a.x[0]</code> binds <code>n</code> to reference the <code>float</code> object returned from <code>a.x[0]</code>. The assignment <code>n = 4</code> rebinds <code>n</code> to reference the <code>int(4)</code> object; it does not set <code>a.x[0]</code> to <code>4</code>.</li> <li><code>__len__</code> expects <code>int</code>, not <code>std::size_t</code>.</li> </ul> Lets create a basic intermediate class that will help simplify the bindings. <code>pya.hpp</code>: <pre><code>#ifndef PYA_HPP #define PYA_HPP #include "a.hpp" struct PyA: A { double get_x( int i ) { return x( i ); } void set_x( int i, double v ) { x( i ) = v; } double get_y( int i ) { return y( i ); } void set_y( int i, double v ) { y( i ) = v; } int length() { return size(); } }; #endif // PYA_HPP </code></pre> Great! <code>PyA</code> now provides member functions that do not return references, and length is returned as an <code>int</code>. It is not the best of interfaces, the bindings are being designed to provide the needed functionality, rather than the desired interface. Now, lets write some simple bindings that will create class <code>A</code> in the <code>cexample</code> module. Here is the bindings in SIP: <pre><code>%Module cexample class PyA /PyName=A/ { %TypeHeaderCode #include "pya.hpp" %End public: double get_x( int ); void set_x( int, double ); double get_y( int ); void set_y( int, double ); int __len__(); %MethodCode sipRes = sipCpp->length(); %End }; </code></pre> Or if you prefer Boost.Python: <pre><code>#include "pya.hpp" #include <boost/python.hpp> BOOST_PYTHON_MODULE(cexample) { using namespace boost::python; class_< PyA >( "A" ) .def( "get_x", &PyA::get_x ) .def( "set_x", &PyA::set_x ) .def( "get_y", &PyA::get_y ) .def( "set_y", &PyA::set_y ) .def( "__len__", &PyA::length ) ; } </code></pre> Due to the <code>PyA</code> intermediate class, both of the bindings are fairly simple. Additionally, this approach requires less SIP and Python C API knowledge, as it requires less code within <code>%MethodCode</code> blocks. Finally, create <code>example.py</code> that will provide the desired pythonic interface: <pre><code>class A: class __Helper: def __init__( self, data, getter, setter ): self.__data = data self.__getter = getter self.__setter = setter def __getitem__( self, index ): if len( self ) <= index: raise IndexError( "index out of range" ) return self.__getter( index ) def __setitem__( self, index, value ): if len( self ) <= index: raise IndexError( "index out of range" ) self.__setter( index, value ) def __len__( self ): return len( self.__data ) def __init__( self ): import cexample a = cexample.A() self.x = A.__Helper( a, a.get_x, a.set_x ) self.y = A.__Helper( a, a.get_y, a.set_y ) </code></pre> In the end, the bindings provide the functionality we need, and python creates the interface we want. It is possible to have the bindings provide the interface; however, this can require a rich understanding of the differences between the two languages and the binding implementation. <pre>>>> from example import A >>> a = A() >>> for x in a.x: ... print x ... 0.0 2.0 4.0 >>> a.x[0] = 4 >>> for x in a.x: ... print x ... 4.0 2.0 4.0 >>> x = a.x >>> a = None >>> print x[0] 4.0</pre>
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POPython binding for C++ operator overloading
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USTanner Sansbury
UserOwnerUserId
1. USTanner Sansbury
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. POPython binding for C++ operator overloading
 singulars
 PostTypePostTypeId
 PTQuestion
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
3. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
CommentsPostId
1. This table or related slice is empty.

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.