Re: [aspectj-users] AJDT and eclipse 3.0RC3

[Andrew Clement <CLEMAS@xxxxxxxxxx>]

I meant to say that in my last note
actually.  it occurred to me on the way to work...

The visualiser doesn't show:

- intertype declarations
- declare error/warning 

In code example 1, log() is abstract
and I can't see the concrete implementation of it - there won't
be any matches if it is left abstract.
 In example 2, there are no abstract pointcuts.

Andy.

robert kuzelj <robert_kuzelj@xxxxxxxxx>
Sent by: aspectj-users-admin@xxxxxxxxxxx

23/06/2004 10:21

Please respond to
aspectj-users

To	aspectj-users@xxxxxxxxxxx
cc
Subject	Re: [aspectj-users] AJDT and eclipse 3.0RC3

hi andy,

> Multiple projects in the same workspace is fine.  As Ron pointed
out,
> AJDT works with the structure model for one project as a time, as
you
> flick between them, it switches to the structure model for the project
you
> select.  We do not currently support visualization across more
than one
> project.
thats ok. but currently it seems like it rebuilds that model on every
switch witch takes looooong. on my machine between half a minute
and a minute. also when i resize the the visualizer window it takes
enormously long to get it redrawn.
eclipse is certainly a monster when it comes to resource consumption
but i never had such problems on my machine before (2GH, 512MB).


NEWS UPDATE!
ok i am starting to realize whats going on. at least partly.
it seems like AJDT has a problem recognizing crosscutting when
there are no PCDs.

i use aspectj heavyly for introductions where the
introductions are sort of deferred.

example
<code>

interface BaseInterface{}
interface AspectedBaseInterface extends BaseInterface{}

public abstract aspect EnableBaseInterface{
   private int AspectedBaseInterface.foo_;

   public int AspectedBaseInterface.getFoo(){return foo_;}
}

public DefaultEnableBaseInterface extends EnableBaseInterface{
    declare parents: MyType implements AspectedBaseInterface;
}
</code>

now none of these is visualized.

for aspects with PCDs most of them are visualized but again not all.

<code example=1>
package org.pragmatico.util.aspects;

import org.pragmatico.util.Util;
import org.aspectj.lang.*;


public abstract aspect EnableLogging
{
     protected int indent_ = 0;
     protected String ws_ = "    ";
     protected String info_level_ = "SIG";  //SIG
OR ARGS

     protected abstract pointcut log();

     protected pointcut toString(): cflowbelow(execution(String
*.toString()));
     protected pointcut enter(): if(true);
     protected pointcut leave(): if(true);

     before():
         log() && enter() && !toString()
         {
                
        indent_++;
             printSignature(thisJoinPoint,
"ENTER", info_level_);

         }

     after():
         log() && leave() && !toString()
         {
             printSignature(thisJoinPoint,
"LEAVE", "SIG");
                
        indent_--;
         }

     private void printSignature(JoinPoint _jp, String  _type,
String 
_level)
     {
         Signature sig = _jp.getStaticPart().getSignature();
         String typename = Util.getTypeName(sig.getDeclaringType());
         String msg = _type + ": " + typename
+ "." + sig.getName();
         if (getInfoLevel().equals("ARGS"))
         {
             msg += createParameters(_jp);
         }
         printIndent();
         System.out.println(msg);
     }


     private String createParameters(JoinPoint _jp)
     {
         StringBuffer buffer = new StringBuffer("(");
         Object[] arguments = _jp.getArgs();
         for (int length = arguments.length, i = 0;
i < length; ++i)
         {
             Object argument = arguments[i];
             buffer.append(argument);
             if (i != length-1)
             {
                 buffer.append(',');
             }
         }
         buffer.append(")");
         return buffer.toString();
     }

     private void printIndent()
     {
         System.out.print(Util.indent(ws_, indent_));
     }

     public String getInfoLevel()
     {
        return "SIG";
     }
}
</code>

<code example=2>
package org.pragmatico.util.autoprop.aspects;

import org.pragmatico.util.autoprop.AspectedAutoProp;

public abstract aspect BaseEnableAutoProp //extends AutoPropImplAspect
{
     public pointcut getter():
             execution(public Object+ get*())
         &&  target(AspectedAutoProp+);


     Object around():
         getter()
         {
             Object result = proceed();
             try
             {
                 if (result ==
null)
                 {
                    
AspectedAutoProp ape = (AspectedAutoProp) 
thisJoinPoint.getThis();
                    
String name = 
thisJoinPoint.getSignature().getName().substring(3);
                    
result = ape.getValue(result, name);
                 }
             }
             catch(Exception ex)
             {
                 //
             }

             return result;
         }
}
</code>

example 1 is never shown example 2 is shown. whats the difference?
the only one i know is that i import classes on example 1 that are
not part of the project but reside within a jarfile.

any thoughts?

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