pygccxml-development

[pygccxml-development] Pulling methods from base class without exposing base class

[Allen B. <al...@vr...>]

I am having trouble wrapping a class right now.  The problem is that the 
class uses template base classes to mixin functionality.  This makes it 
appear to pygccxml that the class has a half-dozen base classes.  But I 
don't want to expose these base classes, all I want to expose is the 
class that is composed from the mixin functionality.  To make matters 
worse there is something in the handling of these mixins that is making 
pyplusplus code creators expose them all as having the same name 
("Inherited").  I think this is because each mixin class uses a typedef 
called Inherited to keep track of the class that it is inheriting from.  
(I have attached a file that shows the basic idea, but it is a vast 
simplification of the case I am really trying to handle)

Anyway, to make a long story short, what I would like to do is just tell 
pyplusplus to ignore the base classes (ie. don't expose them) but to 
instead pull all of the methods defined in those base classes into the 
derived class I am trying to expose.  Then the generated code would only 
create a wrapper for the derived class and would just create "def"'s 
that reference the methods from the mixins. 

Is this possible?

-Allen

Re: [pygccxml-development] Pulling methods from base class without exposing base class

[Roman Y. <rom...@gm...>]

On 9/19/06, Allen Bierbaum <al...@vr...> wrote:
> I am having trouble wrapping a class right now.  The problem is that the
> class uses template base classes to mixin functionality.  This makes it
> appear to pygccxml that the class has a half-dozen base classes.  But I
> don't want to expose these base classes, all I want to expose is the
> class that is composed from the mixin functionality.

I understand.

>  To make matters
> worse there is something in the handling of these mixins that is making
> pyplusplus code creators expose them all as having the same name
> ("Inherited").  I think this is because each mixin class uses a typedef
> called Inherited to keep track of the class that it is inheriting from.

This is the right guess.

> (I have attached a file that shows the basic idea, but it is a vast
> simplification of the case I am really trying to handle)
>
> Anyway, to make a long story short, what I would like to do is just tell
> pyplusplus to ignore the base classes (ie. don't expose them) but to
> instead pull all of the methods defined in those base classes into the
> derived class I am trying to expose.  Then the generated code would only
> create a wrapper for the derived class and would just create "def"'s
> that reference the methods from the mixins.
>
> Is this possible?

What do you think? Before I answer the question, I would like to make it clear:
this is not  "the main success scenario", so you will have to touch
here and there
few low level details.

1. create module_builder_t object and pass  "optimize_queries=False"
as a parameter.
2. Using adopt_declaration and remove_declaration methods of
declarations.class_t
    put the method into right place. Be careful! Declaration can have
only 1 parent.
    So if you have few derived classes you will have to "copy"
declaration and to
    add the copy to every derived class.
3. after you finished to modify the declarations tree, run query optimizer
    mb.run_query_optimizer()
4. don't forget to exclude the base classes.

I think this should work and it does not require too much work.

-- 
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/

Re: [pygccxml-development] Pulling methods from base class without exposing base class

[Allen B. <al...@vr...>]

Roman Yakovenko wrote:

> On 9/19/06, Allen Bierbaum <al...@vr...> wrote:
>
>> I am having trouble wrapping a class right now.  The problem is that the
>> class uses template base classes to mixin functionality.  This makes it
>> appear to pygccxml that the class has a half-dozen base classes.  But I
>> don't want to expose these base classes, all I want to expose is the
>> class that is composed from the mixin functionality.
>
>
> I understand.
>
>>  To make matters
>> worse there is something in the handling of these mixins that is making
>> pyplusplus code creators expose them all as having the same name
>> ("Inherited").  I think this is because each mixin class uses a typedef
>> called Inherited to keep track of the class that it is inheriting from.
>
>
> This is the right guess.
>
>> (I have attached a file that shows the basic idea, but it is a vast
>> simplification of the case I am really trying to handle)
>>
>> Anyway, to make a long story short, what I would like to do is just tell
>> pyplusplus to ignore the base classes (ie. don't expose them) but to
>> instead pull all of the methods defined in those base classes into the
>> derived class I am trying to expose.  Then the generated code would only
>> create a wrapper for the derived class and would just create "def"'s
>> that reference the methods from the mixins.
>>
>> Is this possible?
>
>
> What do you think? Before I answer the question, I would like to make 
> it clear:
> this is not  "the main success scenario", so you will have to touch
> here and there
> few low level details.
>
> 1. create module_builder_t object and pass  "optimize_queries=False"
> as a parameter.
> 2. Using adopt_declaration and remove_declaration methods of
> declarations.class_t
>    put the method into right place. Be careful! Declaration can have
> only 1 parent.
>    So if you have few derived classes you will have to "copy"
> declaration and to
>    add the copy to every derived class.
> 3. after you finished to modify the declarations tree, run query 
> optimizer
>    mb.run_query_optimizer()
> 4. don't forget to exclude the base classes.
>
> I think this should work and it does not require too much work.
>
Step 2 may be the problem.  To do step 2 I would have to still find and 
reference all the mixin base classes in the system and use them.  Are 
you thinking I should/could build this using the recursive_bases property?

-Allen

Re: [pygccxml-development] Pulling methods from base class without exposing base class

[Roman Y. <rom...@gm...>]

On 9/19/06, Allen Bierbaum <al...@vr...> wrote:
> Roman Yakovenko wrote:
>
> > On 9/19/06, Allen Bierbaum <al...@vr...> wrote:
> >
> >> I am having trouble wrapping a class right now.  The problem is that the
> >> class uses template base classes to mixin functionality.  This makes it
> >> appear to pygccxml that the class has a half-dozen base classes.  But I
> >> don't want to expose these base classes, all I want to expose is the
> >> class that is composed from the mixin functionality.
> >
> >
> > I understand.
> >
> >>  To make matters
> >> worse there is something in the handling of these mixins that is making
> >> pyplusplus code creators expose them all as having the same name
> >> ("Inherited").  I think this is because each mixin class uses a typedef
> >> called Inherited to keep track of the class that it is inheriting from.
> >
> >
> > This is the right guess.
> >
> >> (I have attached a file that shows the basic idea, but it is a vast
> >> simplification of the case I am really trying to handle)
> >>
> >> Anyway, to make a long story short, what I would like to do is just tell
> >> pyplusplus to ignore the base classes (ie. don't expose them) but to
> >> instead pull all of the methods defined in those base classes into the
> >> derived class I am trying to expose.  Then the generated code would only
> >> create a wrapper for the derived class and would just create "def"'s
> >> that reference the methods from the mixins.
> >>
> >> Is this possible?
> >
> >
> > What do you think? Before I answer the question, I would like to make
> > it clear:
> > this is not  "the main success scenario", so you will have to touch
> > here and there
> > few low level details.
> >
> > 1. create module_builder_t object and pass  "optimize_queries=False"
> > as a parameter.
> > 2. Using adopt_declaration and remove_declaration methods of
> > declarations.class_t
> >    put the method into right place. Be careful! Declaration can have
> > only 1 parent.
> >    So if you have few derived classes you will have to "copy"
> > declaration and to
> >    add the copy to every derived class.
> > 3. after you finished to modify the declarations tree, run query
> > optimizer
> >    mb.run_query_optimizer()
> > 4. don't forget to exclude the base classes.
> >
> > I think this should work and it does not require too much work.
> >
> Step 2 may be the problem.  To do step 2 I would have to still find and
> reference all the mixin base classes in the system and use them.  Are
> you thinking I should/could build this using the recursive_bases property?

Yes, you also have recursive_derived property.

-- 
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/

Re: [pygccxml-development] Pulling methods from base class without exposing base class

[Allen B. <al...@vr...>]

Roman Yakovenko wrote:

> On 9/19/06, Allen Bierbaum <al...@vr...> wrote:
>
>> Roman Yakovenko wrote:
>>
>> > On 9/19/06, Allen Bierbaum <al...@vr...> wrote:
>> >
>> >> I am having trouble wrapping a class right now.  The problem is 
>> that the
>> >> class uses template base classes to mixin functionality.  This 
>> makes it
>> >> appear to pygccxml that the class has a half-dozen base classes.  
>> But I
>> >> don't want to expose these base classes, all I want to expose is the
>> >> class that is composed from the mixin functionality.
>> >
>> >
>> > I understand.
>> >
>> >>  To make matters
>> >> worse there is something in the handling of these mixins that is 
>> making
>> >> pyplusplus code creators expose them all as having the same name
>> >> ("Inherited").  I think this is because each mixin class uses a 
>> typedef
>> >> called Inherited to keep track of the class that it is inheriting 
>> from.
>> >
>> >
>> > This is the right guess.
>> >
>> >> (I have attached a file that shows the basic idea, but it is a vast
>> >> simplification of the case I am really trying to handle)
>> >>
>> >> Anyway, to make a long story short, what I would like to do is 
>> just tell
>> >> pyplusplus to ignore the base classes (ie. don't expose them) but to
>> >> instead pull all of the methods defined in those base classes into 
>> the
>> >> derived class I am trying to expose.  Then the generated code 
>> would only
>> >> create a wrapper for the derived class and would just create "def"'s
>> >> that reference the methods from the mixins.
>> >>
>> >> Is this possible?
>> >
>> >
>> > What do you think? Before I answer the question, I would like to make
>> > it clear:
>> > this is not  "the main success scenario", so you will have to touch
>> > here and there
>> > few low level details.
>
Sorry to reply to an old thread, but I was just dealing with this 
problem in another case and I started thinking about it again.

I agree that this it outside the normal usage scenario for py++, but I 
just thought of a reasonable way for the user to think about this in a 
way that may be useful to many more people.

Namely, I was thinking that if the user exposes a class Derived but the 
class Base is not exposed, I think it would be reasonable for Py++ to 
automatically expose all the methods of Base in Derived.  This seems 
like a fairly reasonable usecase because there may just be some times 
that users only want to expose a couple of classes and don't want to 
expose all of their base classes.

What do other people think, is this a common enough usage to make a 
feature request out of it?

-Allen

Re: [pygccxml-development] Pulling methods from base class without exposing base class

[Roman Y. <rom...@gm...>]

On 10/15/06, Allen Bierbaum <al...@vr...> wrote:
> I agree that this it outside the normal usage scenario for py++, but I
> just thought of a reasonable way for the user to think about this in a
> way that may be useful to many more people.
>
> Namely, I was thinking that if the user exposes a class Derived but the
> class Base is not exposed, I think it would be reasonable for Py++ to
> automatically expose all the methods of Base in Derived.  This seems
> like a fairly reasonable usecase because there may just be some times
> that users only want to expose a couple of classes and don't want to
> expose all of their base classes.

I am not sure whether it is reasonable or not. It is very easy to
implement it in Py++.
To tell you the True the functionality like this already presents in Py++:

http://language-binding.net/pyplusplus/documentation/apidocs/pyplusplus.decl_wrappers.class_wrapper.class_t-class.html#redefine_operators

It could be extended to member functions too.

You are welcome to prepare patches and unit test and I will commit
them after this release.

> What do other people think, is this a common enough usage to make a
> feature request out of it?

There is more interesting use case, that I would like to support: Lets
say that you already
have hand written code for base class and now you want to export
derived one, using Py++.
It could be nice if Py++ would support such mixes.

-- 
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/

Re: [pygccxml-development] Pulling methods from base class without exposing base class

[Allen B. <al...@vr...>]

I have this sort of working now, but I have run into an additional 
problem.  Because of the way the mixins work (I assume the templated 
base class), py++ is not figuring out that this class has a base class.  
Because of this I am not getting the standard support for using the 
methods of the base class that I have exposed.

Is there anyway to manually tell py++ about a class's base classes?  For 
example given a class decl could I manually tell it that it is derived 
from class "Base" somehow so this would influence the code creators and 
thus the generated code?

-Allen


Allen Bierbaum wrote:

> I am having trouble wrapping a class right now.  The problem is that 
> the class uses template base classes to mixin functionality.  This 
> makes it appear to pygccxml that the class has a half-dozen base 
> classes.  But I don't want to expose these base classes, all I want to 
> expose is the class that is composed from the mixin functionality.  To 
> make matters worse there is something in the handling of these mixins 
> that is making pyplusplus code creators expose them all as having the 
> same name ("Inherited").  I think this is because each mixin class 
> uses a typedef called Inherited to keep track of the class that it is 
> inheriting from.  (I have attached a file that shows the basic idea, 
> but it is a vast simplification of the case I am really trying to handle)
>
> Anyway, to make a long story short, what I would like to do is just 
> tell pyplusplus to ignore the base classes (ie. don't expose them) but 
> to instead pull all of the methods defined in those base classes into 
> the derived class I am trying to expose.  Then the generated code 
> would only create a wrapper for the derived class and would just 
> create "def"'s that reference the methods from the mixins.
> Is this possible?
>
> -Allen
>
>------------------------------------------------------------------------
>
>
>namespace test_ns
>{
>template <class ParentT>
>class MethodAMixin : public ParentT
>{
>public:
>   void methodA();   
>};
>
>template <class ParentT>
>class MethodBMixin : public ParentT
>{
>public:
>   void methodB();
>};
>
>template <class ParentT>
>class MethodCMixin : public ParentT
>{
>public:
>   void methodC();
>};
>
>class Base
>{
>public:
>  void methodBase();
>};
>
>typedef MethodAMixin< MethodBMixin< MethodCMixin< Base > > > ParentType;
>
>
>class MyClass : public ParentType
>{
>public:
>   MyClass();
>   bool getSomething();
>};
>
>
>} // namespace test_ns
>  
>
>------------------------------------------------------------------------
>
>-------------------------------------------------------------------------
>Take Surveys. Earn Cash. Influence the Future of IT
>Join SourceForge.net's Techsay panel and you'll get the chance to share your
>opinions on IT & business topics through brief surveys -- and earn cash
>http://www.techsay.com/default.php?page=join.php&p=sourceforge&CID=DEVDEV
>
>------------------------------------------------------------------------
>
>_______________________________________________
>pygccxml-development mailing list
>pyg...@li...
>https://lists.sourceforge.net/lists/listinfo/pygccxml-development
>  
>

Re: [pygccxml-development] Pulling methods from base class without exposing base class

[Roman Y. <rom...@gm...>]

On 10/16/06, Allen Bierbaum <al...@vr...> wrote:
> I have this sort of working now, but I have run into an additional
> problem.  Because of the way the mixins work (I assume the templated
> base class), py++ is not figuring out that this class has a base class.
> Because of this I am not getting the standard support for using the
> methods of the base class that I have exposed.
>
> Is there anyway to manually tell py++ about a class's base classes?  For
> example given a class decl could I manually tell it that it is derived
> from class "Base" somehow so this would influence the code creators and
> thus the generated code?

Allen I am pretty busy, can you create small test case that reproduce the
problem? ( C++ and Py++ files ).

Boost.Date_Time uses same pattern and it works okay. May be you should take
a look on it.

-- 
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/