John Labenski wrote:
>> obj = iter3:op_mul()
>
> This should error out since op_mul() expects an argument.
No it really works. And operator*() generates things different compared too
operator*( const a2dAffineMatrix& m )
Which is what i need, only the naming i don't like.
>
>> If possible adding an extra op_deref or something like that would be
>> nice.
>
> Can you explain why you need to dereference an object pushed into Lua?
> wxLua uses pointers to all class objects, gets them as pointers in the
> bindings and simply puts a * in front if necessary. Unless I'm
> misunderstanding, the operator will convert the pointer to the object,
> but then immediately convert it back to a pointer to push it into Lua.
First of all a2dCanvasObjectListIter is internal in my code a:
typedef a2dCanvasObjectList::iterator a2dCanvasObjectListIter;
and
a2dCanvasObjectList is derived from a template instantiation of a smart
pointer list called a2dSmrtPtrList<a2dCanvasObject>, which contain
a2dCanvasObjectPtr, this last is a
typedef a2dSmrtPtr<a2dCanvasObject> a2dCanvasObjectPtr;
a2dSmrtPtrList is on it turn a normal STL list containing Smart Pointers.
Now STL lists only work properly/best with complete objects in the list,
so not pointers. STL makes copies of the objects you put in the list,
and deletes them itself.
And that is why the STL list works very well with Smart Pointer, since
they are objects, which internal uses a pointer to the actual object,
which has a refcounter. Here that is a a2dCanvasObject. So copies are
cheap, just increment the refcounter. (Very similar to the typical
wxWidgest refcounting, but not copy on write here).
And deletion by STL, is calling a delete on the SmartPointer, which
means only decrementing the refcount of the a2dCanvasObject, unless 0.
Anyway, the STL list has an internal nested iterator class. So my
a2dCanvasObjectList above, has a a2dCanvasObjectList::iterator, which i
need to use to iterate the list. I can't derive that iterator, and nor
redefine its methods. So in order to use it in wxLua, i need to use its
methods as is.
And to bad that is mostly operatorXXX.
The iterator in STL always delivers references to the object it points too.
And it does that with operator*(). I need to write:
a2dCanvasObjectList::value_type obj = *iter;
So in my case i get a a2dCanvasObjectPtr from it. And to get to the real
object, i need to use the Get() method of my Smart Pointer
a2dCanvasObjectPtr, which delivers me a a2dCanvasObject*.
Here is what i have in the binding file.
%class %delete %encapsulate %noclassinfo a2dCanvasObjectPtr
a2dCanvasObject* Get() const
%endclass
%class %encapsulate %noclassinfo a2dCanvasObjectListIter
a2dCanvasObjectListIter()
%operator a2dCanvasObjectPtr operator*() const
....rest...
%endclass
%class %noclassinfo a2dCanvasObjectList, a2dSmrtPtrList
a2dCanvasObjectList()
a2dCanvasObjectListIter lbegin()
a2dCanvasObjectListIter lend()
....rest...
%endclass
And here is how it is use it inside a lua script.
iter3 = childs:lbegin()
for i=1,childs:size() do
obj = iter3:op_mul()
nameOfobj = obj:Get():GetName()
iter3:op_inc()
end
As you can see, op_mul() gives me a a2dCanvasObjectPtr, and i can even
call the Get() method on it.
Now if you say that is in fact not a a2dCanvasObjectPtr, but a
a2dCanvasObjectPtr*, i believe you, and i see it in the C++ binding code
:-) But that does not change the fact that in C++ the operator*() is
really use to get to the STL iterator. Which is the only way possible.
So some way or the other, currently op_mul() is correctly resulting in
the operator*(), which i need to get to the STL iterator its objects.
The a2dCanvasObjectPtr* returns = new a2dCanvasObjectPtr(*(*self))
is also interesting. First the iterator (*self) delivers a
"a2dCanvasObjectPtr&" using *(*self).
I can write it like this also:
a2dCanvasObjectPtr* returns = new a2dCanvasObjectPtr(self->operator
*());
That lua wants a a2dCanvasObjectPtr* is fine with me, it deletes it
himself, and its just an extra refcount behind the scenes inside the
a2dCanvasObject.
Therefore it makes no differnce who deletes it first (Lua or the list).
Down here the code that is generated for operator*(), which is different
compared to what is generated for // %operator a2dAffineMatrix
operator*( const a2dAffineMatrix& m ) const
There is contains:
a2dAffineMatrix* returns = new a2dAffineMatrix((*self)*(*m));
// %operator a2dCanvasObjectPtr operator*() const
static int LUACALL wxLua_a2dCanvasObjectListIter_op_mul(lua_State *L)
{
// get this
a2dCanvasObjectListIter * self = (a2dCanvasObjectListIter
*)wxluaT_getuserdatatype(L, 1, wxluatype_a2dCanvasObjectListIter);
// call op_mul
// allocate a new object using the copy constructor
a2dCanvasObjectPtr* returns = new a2dCanvasObjectPtr(*(*self));
// add the new object to the tracked memory list
wxluaO_addgcobject(L, (void*)returns, new
wxLua_wxObject_a2dCanvasObjectPtr((a2dCanvasObjectPtr*)returns));
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_a2dCanvasObjectPtr);
return 1;
}
So after all it looks this is really implemented, still i would like it
to be called not op_mul but op_deref :-)
Hope this helps to understand what is happening here,
Regards,
Klaas
>
-------------------------------------------------------------------------
This SF.Net email is sponsored by the Moblin Your Move Developer's challenge
Build the coolest Linux based applications with Moblin SDK & win great prizes
Grand prize is a trip for two to an Open Source event anywhere in the world
http://moblin-contest.org/redirect.php?banner_id=100&url=/
_______________________________________________
wxlua-users mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/wxlua-users
