[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [List Home]
Re: [aspectj-users] Intertype declaration with methods returning instances of the class itself - correction

Hello,

Thanks for your answer. I appreciated it a lot (answering your question, yes, it makes sense and, by the way, I wanted that exactly to implement the Singleton pattern), even knowing now that it's not possible to do exactly what I wanted (inject the getInstance method for each Singleton class just from the Aspect - using the form "public {name} {name}.getInstance() { ... }". However, I can live with it :)

   Cheers,

     Paulo Zenida

Citando Wes Isberg <wes@xxxxxxxxxxxxxx>:

What I mean was
 		   public (@MyInterface *) getInstance() {
                         return new (@MyInterface *)();
                 }
         }
>         Is the previous possible?

You can declare a method

 aspect A {
   public MyInterface MyInterface.getInstance() { ... }
 }

But there's no macro facility in AspectJ to generate code
of the form

  aspect A {
    public {name} {name}.getInstance() { ... }
  }

  class A {
    public A getInstance() {...}
  }
  class B {
    public B getInstance() {...}
  }

For factories, you'd like to write type-specific
declarations and implementations anyway, e.g., here on C:

 aspect A_forC {
   public C C.getInstance() { return new C(); }
 }


Using a superinterface and covariant return types can help you specify a policy for all factories. You can even segregate results and factories if you want separate implementations:

 interface Result {}

 interface Factory {
    Result getInstance();
 }

 aspect A  {
   // default implementation
   public Result Factory.getInstance() {
     throw new UnsupportedOperationException();
   }
 }

 // C is both result and factory
 class C implements Result;
 aspect A_forC {
   declare parents: C implements Factory;
   // note covariant return type C for Result
   public C C.getInstance() {
     return new C();
   }
 }

 // D is factory for B
 class B implements Result {}
 aspect A_forB {
   declare parents: D implements Factory;
   public B D.getInstance() {
     return new B();
   }
 }

(warning: see bug 128443 for why I declared interfaces
directly on B,D:
 https://bugs.eclipse.org/bugs/show_bug.cgi?id=128443
)

Then you can implement any policies you like on all
factories.

e.g., to have only one result per factory instance,

 interface Factory {
   Result getInstance();
   pointcut factory() :
     execution(Result Factory.getInstance());
   // AspectJ 5 recognizes covariant return types, so you
   // don't have to say "Result+" in the execution
pointcut
 }

 aspect FactorySingleton perinstance(factory()) {
    Factory result;
    Factory around() : Factory.factory() {
      if (null == result) {
        result = proceed();
      }
      return result;
   }
 }

Does that make sense?

Wes


On Fri, 17 Feb 2006 14:04:58 +0000 Paulo Alexandre Corigo Zenida <paulo.zenida@xxxxxxxx> wrote:
Em Sexta, 17 de Fevereiro de 2006 09:54, o Paulo
Alexandre Corigo Zenida
escreveu:
> Hi all,
>
>         I wonder if, in Intertype declaration, is it
possible for me to add
> a method to any class with a common characteristic
(annotated with
> something, for example, that returns an instance of the
class itself? To
> better understand what I want, let me show an example:
>
>         @MyAnnotation
>         public class A {
>
>         }
>
>         @MyAnnotation
>         public class B {
>
>         }
>
>         public aspect MyAspect {
>
>                 // this does not compile
>                 public void (@MyAnnotation *).foo() {
>
>                 }
>
>                 // So, I have tried this:
>                 declare parents : (@MyAnnotation *)
implements MyInterface;
>
>                 interface MyInterface {
>
>                 }
>
>                 // this works ok
>                 public void MyInterface.foo() {
>                         System.out.println("In foo");
>                 }
>
>                 // But this does not compile! I would
like to create a
>                 // method returning an instance of the
class itself.
> 		   // Any ideas about how to do this?
> 		   public (@Singleton *) getInstance() {
>                         return new (@Singleton *)();
>                 }
What I mean was
 		   public (@MyInterface *) getInstance() {
                         return new (@MyInterface *)();
                 }
         }
>
>         Is the previous possible?
>
>         Thanks in advance. Cheers,
>
>                 Paulo Zenida

_______________________________________________ aspectj-users mailing list aspectj-users@xxxxxxxxxxx https://dev.eclipse.org/mailman/listinfo/aspectj-users




---------------------------------------------------------------- Mensagem enviada usando o IMP (Internet Messaging Program).