[aspectc-user] Defining an Aspect Instantiation Model with ac++1.0

Olaf Spinczyk Olaf.Spinczyk at informatik.uni-erlangen.de
Tue Nov 15 09:09:04 CET 2005


Hi,

it looks as if the problem is only a syntax error in your advice code. 
The argument to purge_pending_notifications() should be a value. "int a" 
is a declaration. That means, you can either pass a value of your choice 
"...::purge_pending_notifications(42)" or use the original argument 
value(s) from the replaced function call:

...::purge_pending_notifications(*tjp->arg<0>(), *tjp->arg<1>())

Note that *tjp->arg<X>() will only return a valid object if the argument 
with the index X was passed in the function call expression. In the case 
of functions with variable argument list or default arguments you have 
to be careful and check JoinPoint::ARGS.

- Olaf

Dimple wrote:
> Hi Olaf,
> 
> I have following aspect :
> 
> 
> ****************************************************************************
> aspect ChildInsteadOfParent {
>    
> advice call("% Reactor_Impl::resumable_handler()") : around () {
>     printf("redirecting call of %s to ", JoinPoint::signature());
>     ((Select_Reactor_Impl*)tjp->target
> ())->Select_Reactor_Impl::resumable_handler();
> }
> 
> advice call("% Reactor_Impl::purge_pending_notifications(...)") : around ()
> {
>      printf("redirecting call of %s to ", JoinPoint::signature());
>      ((Select_Reactor_Impl*)tjp->target
> ())->Select_Reactor_Impl::purge_pending_notifications(int a);
>    }
> }
> ****************************************************************************
> In this aspect, first advice is working properly and it is replacing
> resumable_handler() of parent with child method. In first case as you see
> method is without any parameters. 
> But in second advice I am getting compilation error because here I am trying
> to use purge_pending_notifications(int a) method which has a argument. 
> 
> For methods having argument, in pointcut I can specify (…) as per tutorial
> but how do deal in target??
> 
> 
> Thanks,
> Dimple
> 
> -----Original Message-----
> From: Olaf Spinczyk [mailto:Olaf.Spinczyk at informatik.uni-erlangen.de] 
> Sent: Saturday, November 12, 2005 6:29 AM
> To: dkaul at isis.vanderbilt.edu
> Cc: aspectc-user at aspectc.org
> Subject: Re: [aspectc-user] Defining an Aspect Instantiation Model with
> ac++1.0
> 
> Hi,
> 
> AspectC++ supports advice for the construction and destruction of 
> objects with the pointcut functions "construction" and "destruction". 
> "construction" advice can be understood as advice for the execution of 
> the constructor *after* the base classes and attributes listed in the 
> base class init list have been initialized.
> 
> - Olaf
> 
> Dimple wrote:
>>Hi Olaf,
>>Does new version of AspectC++ support replacing of Constructors or
>>Destructors using aspect?
>>class Parent1;
>>class Parent2;
>>I want to use Parent2 class in place of Parent1. is this supported?
>>
>>Thanks,
>>Dimple
>>
>>
>>
>>-----Original Message-----
>>From: Olaf Spinczyk [mailto:Olaf.Spinczyk at informatik.uni-erlangen.de] 
>>Sent: Friday, November 11, 2005 8:53 AM
>>To: dkaul at isis.vanderbilt.edu
>>Cc: aspectc-user at aspectc.org
>>Subject: Re: [aspectc-user] Defining an Aspect Instantiation Model with
>>ac++1.0
>>
>>Hi Dimple,
>>
>>in the listing I've sent to you only the function Child1::xa1 prints 
>>"void Child1::xa1()\n". It is NOT the aspect. Therefore, I am pretty 
>>sure that everything works as expected. Here is the code fragment:
>>
>>>class Child1:public Parent_Impl {
>>>public:
>>>   Child1();
>>>   ~Child1();
>>>   void xa1();
>>>   void a2();
>>>   void a3();
>>>
>>>};
>>>
>>>
>>>Child1::Child1():Parent_Impl()
>>>{
>>>}
>>>
>>>Child1::~Child1()
>>>{
>>>}
>>>
>>>void Child1::xa1()  { printf("void Child1::xa1()\n"); }
>>>void Child1::a2() { printf("child1   a2\n"); }
>>>void Child1::a3() { printf("void Child1::a3()\n"); }
>>BTW, it makes no sense to call tjp->proceed(), because this will perform 
>>the original *virtual* function call.
>>
>>Best regards,
>>
>>Olaf
>>
>>
>>Dimple wrote:
>> 
>>>Hi,
>>>Using this aspect 
>>>
>>>aspect ChildInsteadOfParent {
>>>  advice call ("% Parent_Impl::a1()") : around () {
>>>    printf("redirecting call of %s to ", JoinPoint::signature());
>>>    ((Child1*)tjp->target ())->xa1 ();
>>>  }
>>>  advice call ("% Parent_Impl::a3()") : around () {
>>>    printf("redirecting call of %s to ", JoinPoint::signature());
>>>    ((Child1*)tjp->target ())->Child1::a3 ();
>>>  }
>>>};
>>>
>>>The output is:
>>>
>>>redirecting call of void Parent_Impl::a1() to void Child1::xa1()
>>>child1   a2
>>>redirecting call of void Parent_Impl::a3() to void Child1::a3()
>>>
>>>it printing "redirecting call to child class and method" but it is not
>>>printing message that I have put in child method means it is not
>>>   
>>proceeding
>> 
>>>in Child1::xa1 method. 
>>>It should have print 
>>>child1 xa1 also
>>>
>>>Means output should have been like this:
>>>
>>>1)redirecting call of void Parent_Impl::a1() to void Child1::xa1()
>>>2)child1   xa1
>>>3)child1   a2
>>>4)redirecting call of void Parent_Impl::a3() to void Child1::a3()
>>>5)child1   a3
>>>
>>>Line 1,2 becoz of first advice 
>>>Line 3 Normal call no changes
>>>Line 4,5 becoz of second advice
>>>
>>>Actually if I call tjp->proceed() in advice it calls parent method.
>>>And I tried doing tjp->target()->proceed() it is giving me some error :(.
>>>
>>>
>>>
>>>-----Original Message-----
>>>From: Olaf Spinczyk [mailto:Olaf.Spinczyk at informatik.uni-erlangen.de] 
>>>Sent: Friday, November 11, 2005 2:33 AM
>>>To: dkaul at isis.vanderbilt.edu
>>>Cc: aspectc-user at aspectc.org
>>>Subject: Re: [aspectc-user] Defining an Aspect Instantiation Model with
>>>ac++1.0
>>>
>>>Hi Dimple,
>>>
>>>now I got it. You want to avoid the virtual function call if you know 
>>>the exact object type at compile time. This reminds me very much of my 
>>>work on "open components" some years ago. If you need some related work:
>>>
>>>Andreas Gal, Wolfgang Schröder-Preikschat, Olaf Spinczyk, "Open 
>>>Components", Proceedings of the First OOPSLA Workshop on Language 
>>>Mechanisms for Programming Software Components, Tampa, Florida, 15th 
>>>Oktober 2001.
>>>
>>>Now back to your problem: Your goal is to redirect a call to a virtual 
>>>function, i.e. a function that is defined in Parent_Impl, to another 
>>>function, which is defined in Child1. This can be achieved with the 
>>>following advice:
>>>
>>>  advice call ("% Parent_Impl::a1()") : around () {
>>>    printf("redirecting call of %s to ", JoinPoint::signature());
>>>    ((Child1*)tjp->target ())->xa1 ();
>>>  }
>>>
>>>The virtual function call to a1 will be completely replaced by the 
>>>non-virtual call to xa1. Here I used the name xa1 in Child1 instead of 
>>>a1 to make sure that the function is not virtual. A function with the 
>>>same name would also be virtual, because it overrides a virtual function 
>>>with the same name and argument types.
>>>
>>>If you want the function in Child1 to have the same name, you can use a 
>>>scope operator. By this means a virtual function call mechanism is also 
>>>disabled. However, if there was another class derived from Child1 that 
>>>overrides the function again, this final specialization wouldn't be 
>>>called. Here is the advice:
>>>
>>>  advice call ("% Parent_Impl::a3()") : around () {
>>>    printf("redirecting call of %s to ", JoinPoint::signature());
>>>    ((Child1*)tjp->target ())->Child1::a3 ();
>>>  }
>>>
>>>Your next question will probably be: Is there any generic way to 
>>>redirect *all* calls to virtual functions of Parent_Impl to a function 
>>>with the same name in Child1? This is not possible with AspectC++ at the 
>>>moment.
>>>
>>>Here is the complete listing:
>>>
>>>#include <stdio.h>
>>>
>>>class Parent_Impl {
>>>public:
>>>  Parent_Impl();
>>>  ~Parent_Impl();
>>>  virtual void a1();
>>>  virtual void a2();
>>>  virtual void a3();
>>>};
>>>
>>>class Child:public Parent_Impl {
>>>public:
>>>  Child();
>>>  ~Child();
>>>  void a1();
>>>  void a2();
>>>  void a3();
>>>
>>>};
>>>
>>>Parent_Impl::Parent_Impl()
>>>{
>>>}
>>>
>>>Parent_Impl::~Parent_Impl()
>>>{
>>>}
>>>
>>>void Parent_Impl::a1()
>>>{
>>> printf("parent a1\n");
>>>
>>>}
>>>
>>>void Parent_Impl::a2()
>>>{
>>> printf("parent a2\n");
>>>}
>>>
>>>void Parent_Impl::a3()
>>>{
>>> printf("parent a3\n");
>>>}
>>>redirecting call of void Parent_Impl::a1() to void Child1::xa1()
>>>child1   a2
>>>redirecting call of void Parent_Impl::a3() to void Child1::a3()
>>>
>>>Child::Child():Parent_Impl()
>>>{
>>>}
>>>
>>>Child::~Child()
>>>{
>>>}
>>>
>>>
>>>void Child::a1()
>>>{
>>>    printf("child a1\n");
>>>}
>>>
>>>void Child::a2()
>>>{
>>>    printf("child a2\n");
>>>}
>>>
>>>void Child::a3()
>>>{
>>>    printf("child a3\n");
>>>}
>>>
>>>class Child1:public Parent_Impl {
>>>public:
>>>  Child1();
>>>  ~Child1();
>>>  void xa1();
>>>  void a2();
>>>  void a3();
>>>
>>>};
>>>
>>>
>>>Child1::Child1():Parent_Impl()
>>>{
>>>}
>>>
>>>Child1::~Child1()
>>>{
>>>}
>>>
>>>void Child1::xa1()  { printf("void Child1::xa1()\n"); }
>>>void Child1::a2() { printf("child1   a2\n"); }
>>>void Child1::a3() { printf("void Child1::a3()\n"); }
>>>
>>>int main ()
>>>{
>>>  Parent_Impl *r_impl = new Child1();
>>>  r_impl->a1();
>>>  r_impl->a2();
>>>  r_impl->a3();
>>>  return 0;
>>>}
>>>
>>>aspect ChildInsteadOfParent {
>>>  advice call ("% Parent_Impl::a1()") : around () {
>>>    printf("redirecting call of %s to ", JoinPoint::signature());
>>>    ((Child1*)tjp->target ())->xa1 ();
>>>  }
>>>  advice call ("% Parent_Impl::a3()") : around () {
>>>    printf("redirecting call of %s to ", JoinPoint::signature());
>>>    ((Child1*)tjp->target ())->Child1::a3 ();
>>>  }
>>>};
>>>
>>>The output is:
>>>
>>>redirecting call of void Parent_Impl::a1() to void Child1::xa1()
>>>child1   a2
>>>redirecting call of void Parent_Impl::a3() to void Child1::a3()
>>>
>>>What do you think about this solution?
>>>
>>>- Olaf
>>>
>>>
>>>Dimple wrote:
>>>   
>>>>Hi,
>>>>
>>>>There are different classes like "Child" and "Child1" with various
>>>>functionalities.
>>>>To work transparently across all frameworks, an abstract base class
> called
>>>>"Parent_Impl" has been added that delegates to concreter subclasses via
>>>>virtual method calls.
>>>>
>>>>I want to specialize my framework with a concrete subclass (i.e., a
>>>>     
>>>subclass
>>>   
>>>>with no virtual methods) and thus eliminate the generality by using a
>>>>particular child instance directly.
>>>>For example I know child class Child1 is to be used, I want to define
> that
>>>>in my aspect and thus bypass parent.
>>>>
>>>>Hope I have made things little clearer :)
>>>>
>>>>Thanks,
>>>>Dimple 
>>>>
>>>>
>>>>-----Original Message-----
>>>>From: Olaf Spinczyk [mailto:Olaf.Spinczyk at informatik.uni-erlangen.de] 
>>>>Sent: Thursday, November 10, 2005 11:29 AM
>>>>To: dkaul at isis.vanderbilt.edu
>>>>Cc: aspectc-user at aspectc.org
>>>>Subject: Re: [aspectc-user] Defining an Aspect Instantiation Model with
>>>>ac++1.0
>>>>
>>>>Hi,
>>>>
>>>>sorry for the late answer.
>>>>
>>>>I have to say that I don't understand what you want to achieve. 
>>>>Redirecting the execution of parent functions to child functions sounds 
>>>>like the normal late binding mechanism with virtual functions. Do you 
>>>>want to achieve the same without having to declare the functions as 
>>>>'virtual'?
>>>>
>>>>Please describe your goal a bit more precise.
>>>>
>>>>- Olaf
>>>>
>>>>
>>>>Dimple wrote:
>>>>     
>>>>>Hi Olaf,
>>>>>I have read your AspectC++ 2005 tutorial slides and 
>>>>>I have been trying to implement aspects for the attached example
> program.
>>>>>Based on your example code 
>>>>>aspect AlwaysDoThirdBeforeSecond {
>>>>>advice execution("void C1::second()") : before () {
>>>>>  tjp->that ()->third ();
>>>>>}
>>>>>};
>>>>>I tried all different types advices.
>>>>>However, in this scenario I wanted to call child class instead of parent
>>>>>class. I am not sure if this is possible in AspectC++.
>>>>>I also tried using Ordering of aspects and using around for parent but
>>>>>       
>>>>that
>>>>     
>>>>>is also not working.
>>>>>
>>>>>Plz see enclosed example code.
>>>>>Thanks,
>>>>>Dimple
>>>>>
>>>>>
>>>>>-----Original Message-----
>>>>>From: Olaf Spinczyk [mailto:Olaf.Spinczyk at informatik.uni-erlangen.de] 
>>>>>Sent: Friday, November 04, 2005 2:26 AM
>>>>>To: dkaul at isis.vanderbilt.edu
>>>>>Subject: Re: [aspectc-user] Defining an Aspect Instantiation Model with
>>>>>ac++1.0
>>>>>
>>>>>Hi,
>>>>>
>>>>>you could use the following aspect:
>>>>>
>>>>>aspect DoThirdBeforeSecondInMain {
>>>>>advice call("void C1::second()") && within("int main()") : before () {
>>>>>  tjp->target ()->third ();
>>>>>}
>>>>>};
>>>>>
>>>>>It matches all calls to second that are located within main.
>>>>>
>>>>>If you *always* want third to be executed before second, you could also
>>>>>       
>>>>use:
>>>>     
>>>>>aspect AlwaysDoThirdBeforeSecond {
>>>>>advice execution("void C1::second()") : before () {
>>>>>  tjp->that ()->third ();
>>>>>}
>>>>>};
>>>>>
>>>>>This one call third before every execution of second.
>>>>>
>>>>>I hope this helps. Did you already read out AOSD 2005 tutorial slides? 
>>>>>They contain a step-by-step introduction into the pointcut language.
>>>>>
>>>>>Olaf
>>>>>
>>>>>PS: You've sent your mail to (CC:) "aspectc-user-bounces at aspectc.org". 
>>>>>This is probably not what you wanted. The mailing list is 
>>>>>aspectc-user at aspectc.org.
>>>>>
>>>>>
>>>>>Dimple wrote:
>>>>>       
>>>>>>Hi Olaf,
>>>>>>I was trying out one example code
>>>>>>
>>>>>>#include <stdio.h>
>>>>>>
>>>>>>// ------------------------------- normal C++
>>>>>>         
>>>----------------------------
>>>   
>>>>>>class C1 {
>>>>>>public:
>>>>>>void first()  { printf("First\n"); }
>>>>>>void second() { printf("Second\n"); }
>>>>>>void third() { printf("Third\n"); }
>>>>>>};
>>>>>>
>>>>>>int main () {
>>>>>>C1 c1;
>>>>>>
>>>>>>c1.first();
>>>>>>
>>>>>>
>>>>>>         
>>printf("**************************************************************\n\n"
> )
>> 
>>>>>>;
>>>>>>c1.second();
>>>>>>}
>>>>>>
>>>>>>
>>>>>>I wanted to figure out how I can do this in aspectc++
>>>>>>What I want is I want to run c1.first() normally, then I want to call
>>>>>>c1.third() before c1.second(). 
>>>>>>Means to say that I want to insert c1.third() method between c1.first()
>>>>>>         
>>>>>and
>>>>>       
>>>>>>c1.second().
>>>>>>I checked all the examples given in aspectC++ but could not figure out
>>>>>>         
>>>how
>>>   
>>>>>>to do it.
>>>>>>
>>>>>>Thanks in advance,
>>>>>>Dimple
>>>>>>
>>>>>>
>>>>>>
>>>>>>-----Original Message-----
>>>>>>From: aspectc-user-bounces at aspectc.org
>>>>>>[mailto:aspectc-user-bounces at aspectc.org] On Behalf Of Olaf Spinczyk
>>>>>>Sent: Wednesday, November 02, 2005 9:41 AM
>>>>>>To: Sergio Queiroz
>>>>>>Cc: aspectc-user at aspectc.org
>>>>>>Subject: Re: [aspectc-user] Defining an Aspect Instantiation Model with
>>>>>>ac++1.0
>>>>>>
>>>>>>Hi,
>>>>>>
>>>>>>the bug has number 267 in bugzilla and I've just fixed it.
>>>>>>
>>>>>>Thanks again for reporting this problem!
>>>>>>
>>>>>>Olaf
>>>>>>
>>>>>>
>>>>>>Olaf Spinczyk wrote:
>>>>>>         
>>>>>>>Hi Sergio,
>>>>>>>
>>>>>>>I tried to compile your example and got the following error message:
>>>>>>>
>>>>>>><ac>: In member function `void 
>>>>>>>TJP__ZN6DCache16page_replacementEv_0::proceed()
>>>>>>>':
>>>>>>><ac>:26: error: `_that' undeclared (first use this function)
>>>>>>>
>>>>>>>Did you mean this problem? It seems to be a code generation bug :-(.
>>>>>>>           
>>The
>> 
>>>>>>>member _that is referenced but not generated.
>>>>>>>
>>>>>>>As a workaround (until 1.0pre2) you can add the following line to your
> 
>>>>>>>execution/around advice:
>>>>>>>
>>>>>>>if (0) tjp->proceed()
>>>>>>>
>>>>>>>After adding this line I was able to compile your example.
>>>>>>>
>>>>>>>-Olaf
>>>>>>>
>>>>>>>
>>>>>>>Sergio Queiroz wrote:
>>>>>>>           
>>>>>>>>Hi!
>>>>>>>>
>>>>>>>>I downloaded the new AspectC++ version and I was trying to compile 
>>>>>>>>some code
>>>>>>>>that worked pretty nice with version 0.92.
>>>>>>>>
>>>>>>>>The problem is that ac++ 1.0 could not compile my examples :(
>>>>>>>>
>>>>>>>>I tried to reduce the source code and I am sending my files, some
>>>>>>>>             
>>>>problem
>>>>     
>>>>>>>>occurred during parsing. I am using linux.
>>>>>>>>
>>>>>>>>This is the output of the command "g++ -v":
>>>>>>>>
>>>>>>>>Reading specs from /usr/lib/gcc-lib/i486-linux/3.3.5/specs
>>>>>>>>Configured with: ../src/configure -v
>>>>>>>>--enable-languages=c,c++,java,f77,pascal,objc,ada,treelang
>>>>>>>>             
>>>--prefix=/usr
>>>   
>>>>>>>>--mandir=/usr/share/man --infodir=/usr/share/info
>>>>>>>>--with-gxx-include-dir=/usr/include/c++/3.3 --enable-shared 
>>>>>>>>--with-system-zlib
>>>>>>>>--enable-nls --without-included-gettext --enable-__cxa_atexit
>>>>>>>>--enable-clocale=gnu --enable-debug --enable-java-gc=boehm
>>>>>>>>--enable-java-awt=xlib --enable-objc-gc i486-linux
>>>>>>>>Thread model: posix
>>>>>>>>gcc version 3.3.5 (Debian 1:3.3.5-8)
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>Sérgio
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>---------------------------------------------------------------------
> -
>>>>>>>>             
>>-
>> 
>>>-
>>>   
>>>>>>>>#include "DCache.h"
>>>>>>>>
>>>>>>>>void DCache::doit()
>>>>>>>>{
>>>>>>>>total_cycles++;
>>>>>>>>
>>>>>>>>}
>>>>>>>>
>>>>>>>>void DCache::reset()
>>>>>>>>{        total_cycles = 0;
>>>>>>>>}
>>>>>>>>
>>>>>>>>
>>>>>>>>int DCache::page_replacement()
>>>>>>>>{
>>>>>>>>return 0;
>>>>>>>>}
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>---------------------------------------------------------------------
> -
>>>>>>>>             
>>-
>> 
>>>-
>>>   
>>>>>>>>#ifndef DCACHE_H
>>>>>>>>#define DCACHE_H
>>>>>>>>
>>>>>>>>#include "systemc.h"
>>>>>>>>#include <iostream.h>
>>>>>>>>
>>>>>>>>SC_MODULE (DCache)
>>>>>>>>{
>>>>>>>>sc_in<bool> clock;
>>>>>>>> void doit();
>>>>>>>>void reset();
>>>>>>>>int page_replacement();
>>>>>>>> float total_cycles;
>>>>>>>>     SC_CTOR(DCache)
>>>>>>>>{
>>>>>>>>    reset();
>>>>>>>>             SC_METHOD(doit);
>>>>>>>>    sensitive_pos << clock;
>>>>>>>>}
>>>>>>>>};
>>>>>>>>
>>>>>>>>#endif
>>>>>>>>
>>>>>>>>
>>>>>>>>---------------------------------------------------------------------
> -
>>>>>>>>             
>>-
>> 
>>>-
>>>   
>>>>>>>>#include "DCache.h"
>>>>>>>>
>>>>>>>>int
>>>>>>>>sc_main (int argc, char **argv) {
>>>>>>>>sc_signal <bool> clock;
>>>>>>>>
>>>>>>>>DCache dcache ("dcache");
>>>>>>>>dcache.clock (clock);
>>>>>>>>
>>>>>>>>int i = 0;
>>>>>>>>
>>>>>>>>sc_initialize ();
>>>>>>>>
>>>>>>>>while (i++ < 10) {
>>>>>>>>   clock.write (0);
>>>>>>>>
>>>>>>>>   cout << dcache.page_replacement () << endl;
>>>>>>>>  
>>>>>>>>   clock.write (1);
>>>>>>>>}
>>>>>>>>
>>>>>>>>return 0;
>>>>>>>>}
>>>>>>>>
>>>>>>>>
>>>>>>>>---------------------------------------------------------------------
> -
>>>>>>>>             
>>-
>> 
>>>-
>>>   
>>>>>>>>_______________________________________________
>>>>>>>>aspectc-user mailing list
>>>>>>>>aspectc-user at aspectc.org
>>>>>>>>http://www.aspectc.org/mailman/listinfo/aspectc-user
>>>>>>>>             
>>>>>>>_______________________________________________
>>>>>>>aspectc-user mailing list
>>>>>>>aspectc-user at aspectc.org
>>>>>>>http://www.aspectc.org/mailman/listinfo/aspectc-user
>>>>>>>           
>>>>>>_______________________________________________
>>>>>>aspectc-user mailing list
>>>>>>aspectc-user at aspectc.org
>>>>>>http://www.aspectc.org/mailman/listinfo/aspectc-user
>>>>>>
>>>>>>
>>>>>>         
>>>>>------------------------------------------------------------------------
>>>>>
>>>>>#include <stdio.h>
>>>>>aspect ChildInsteadOfParent 
>>>>>{
>>>>>
>>>>>pointcut Parent_Methods () = "% Parent_Impl::%(...)";
>>>>>pointcut Child_Methods () = "% Child::%(...)";
>>>>>
>>>>>//advice call(Parent_Methods()) || call (Child_Methods()):around() //
>>>>>       
>>>>Nothing is displayed
>>>>     
>>>>>//advice call (Parent_Methods()) :before()
>>>>>//advice execution (Parent_Methods ()) && target (Child_Methods
>>>>>       
>>>>()):around()
>>>>     
>>>>>advice execution (Parent_Methods ()):around()
>>>>>{
>>>>> printf("Signature is  %s\n", JoinPoint::signature());
>>>>> tjp->proceed();
>>>>> //printf("Result is  %s\n", tjp->result());
>>>>>}
>>>>>};
>>>>>
>>>>>
>>>>>class Parent_Impl {
>>>>>public:
>>>>>Parent_Impl();
>>>>>~Parent_Impl();
>>>>>virtual void a1(); 
>>>>>virtual void a2(); 
>>>>>virtual void a3(); 
>>>>>};
>>>>>
>>>>>class Child:public Parent_Impl {
>>>>>public:
>>>>>Child();
>>>>>~Child();
>>>>>void a1();
>>>>>void a2();
>>>>>void a3();
>>>>>
>>>>>};
>>>>>
>>>>>Parent_Impl::Parent_Impl()
>>>>>{
>>>>>}
>>>>>
>>>>>Parent_Impl::~Parent_Impl()
>>>>>{
>>>>>}
>>>>>
>>>>>void Parent_Impl::a1()
>>>>>{
>>>>>printf("parent a1\n");
>>>>>
>>>>>}
>>>>>
>>>>>void Parent_Impl::a2()
>>>>>{
>>>>>printf("parent a2\n");
>>>>>}
>>>>>
>>>>>void Parent_Impl::a3()
>>>>>{
>>>>>printf("parent a3\n");
>>>>>}
>>>>>
>>>>>Child::Child():Parent_Impl()
>>>>>{
>>>>>}
>>>>>
>>>>>Child::~Child()
>>>>>{
>>>>>}
>>>>>
>>>>>
>>>>>void Child::a1() 
>>>>>{ 
>>>>> printf("child a1\n");
>>>>>}
>>>>>
>>>>>void Child::a2()
>>>>>{ 
>>>>> printf("child a2\n");
>>>>>}
>>>>>
>>>>>void Child::a3()
>>>>>{ 
>>>>> printf("child a3\n");
>>>>>}
>>>>>
>>>>>class Child1:public Parent_Impl {
>>>>>public:
>>>>>Child1();
>>>>>~Child1();
>>>>>void a1();
>>>>>void a2();
>>>>>void a3();
>>>>>
>>>>>};
>>>>>
>>>>>
>>>>>Child1::Child1():Parent_Impl()
>>>>>{
>>>>>}
>>>>>
>>>>>Child1::~Child1()
>>>>>{
>>>>>}
>>>>>
>>>>>void Child1::a1()  { printf("child1   a1\n"); }
>>>>>void Child1::a2() { printf("child1   a2\n"); }
>>>>>void Child1::a3() { printf("child1   a3\n"); }
>>>>>
>>>>>int main () 
>>>>>{
>>>>>//Parent_Impl *r_impl = new Child1();
>>>>>Parent_Impl *r_impl= new Parent_Impl();
>>>>>r_impl->a1();
>>>>>r_impl->a2();
>>>>>r_impl->a3();
>>>>>	 
>>>>>return 0;
>>>>>}
>>>>>       
>>>_______________________________________________
>>>aspectc-user mailing list
>>>aspectc-user at aspectc.org
>>>http://www.aspectc.org/mailman/listinfo/aspectc-user
>>>   
>>
>>
>>_______________________________________________
>>aspectc-user mailing list
>>aspectc-user at aspectc.org
>>http://www.aspectc.org/mailman/listinfo/aspectc-user
>> 
> 
> 




More information about the aspectc-user mailing list