[jboss-cvs] jboss-aop/src/main/org/jboss/aop/pointcut TypeMatcher.java

[Bill B. <pat...@us...>]

  User: patriot1burke
  Date: 04/05/03 16:06:04

  Added:       src/main/org/jboss/aop/pointcut TypeMatcher.java
  Log:
  added complex type expressions to introductions
  
  Revision  Changes    Path
  1.1                  jboss-aop/src/main/org/jboss/aop/pointcut/TypeMatcher.java
  
  Index: TypeMatcher.java
  ===================================================================
  /*
   * JBoss, the OpenSource J2EE webOS
   *
   * Distributable under LGPL license.
   * See terms of license at gnu.org.
   */
  package org.jboss.aop.pointcut;
  
  import javassist.CtClass;
  import org.jboss.aop.ClassAdvisor;
  import org.jboss.aop.pointcut.ast.ASTAllParameter;
  import org.jboss.aop.pointcut.ast.ASTAnd;
  import org.jboss.aop.pointcut.ast.ASTAttribute;
  import org.jboss.aop.pointcut.ast.ASTBoolean;
  import org.jboss.aop.pointcut.ast.ASTClass;
  import org.jboss.aop.pointcut.ast.ASTComposite;
  import org.jboss.aop.pointcut.ast.ASTConstructor;
  import org.jboss.aop.pointcut.ast.ASTField;
  import org.jboss.aop.pointcut.ast.ASTHas;
  import org.jboss.aop.pointcut.ast.ASTHasField;
  import org.jboss.aop.pointcut.ast.ASTMethod;
  import org.jboss.aop.pointcut.ast.ASTNot;
  import org.jboss.aop.pointcut.ast.ASTOr;
  import org.jboss.aop.pointcut.ast.ASTParameter;
  import org.jboss.aop.pointcut.ast.ASTStart;
  import org.jboss.aop.pointcut.ast.ASTSub;
  import org.jboss.aop.pointcut.ast.Node;
  import org.jboss.aop.pointcut.ast.SimpleNode;
  import org.jboss.aop.pointcut.ast.TypeExpressionParserVisitor;
  
  /**
   * Comment
   *
   * @author <a href="mailto:bi...@jb...">Bill Burke</a>
   * @version $Revision: 1.1 $
   *
   **/
  public class TypeMatcher implements TypeExpressionParserVisitor
  {
     private ClassAdvisor advisor;
     private CtClass ctClass;
     private Class clazz;
  
     public TypeMatcher(ClassAdvisor advisor, Class clazz)
     {
        this.advisor = advisor;
        this.clazz = clazz;
     }
  
     public TypeMatcher(ClassAdvisor advisor, CtClass ctClass)
     {
        this.advisor = advisor;
        this.ctClass = ctClass;
     }
  
     public Object visit(ASTStart node, Object data)
     {
        return node.jjtGetChild(0).jjtAccept(this, data);
     }
  
     public Object visit(ASTBoolean node, Object data)
     {
        return node.jjtGetChild(0).jjtAccept(this, data);
     }
  
     public Object visit(ASTComposite node, Object data)
     {
        return node.jjtGetChild(0).jjtAccept(this, data);
     }
  
     public Object visit(ASTNot node, Object data)
     {
  
        Boolean bool = (Boolean)node.jjtGetChild(0).jjtAccept(this, data);
        boolean val = bool.booleanValue();
        return val ? Boolean.FALSE : Boolean.TRUE;
     }
  
     public Object visit(ASTSub node, Object data)
     {
        for (int i = 0; i < node.jjtGetNumChildren(); i++)
        {
           data = node.jjtGetChild(i).jjtAccept(this, data);
        }
        return data;
     }
  
     public Object visit(ASTAnd node, Object left)
     {
        Node andChild = node.jjtGetChild(0); // should only have one child
        boolean val = ((Boolean)left).booleanValue();
        return new Boolean(val && ((Boolean)andChild.jjtAccept(this, Boolean.FALSE)).booleanValue());
     }
  
     public Object visit(ASTOr node, Object left)
     {
        Node orChild = node.jjtGetChild(0); // should only have one child
        boolean val = ((Boolean)left).booleanValue();
        return new Boolean(val || ((Boolean)orChild.jjtAccept(this, Boolean.FALSE)).booleanValue());
     }
  
  
     public Object visit(SimpleNode node, Object data)
     {
        return null;
     }
  
  
     public Object visit(ASTHas node, Object data)
     {
        Node n = node.jjtGetChild(0);
        if (n instanceof ASTMethod)
        {
           if (clazz != null) return new Boolean(Util.has(clazz, (ASTMethod) n, advisor));
           if (ctClass != null) return new Boolean(Util.has(ctClass, (ASTMethod) n, advisor));
        }
        else
        {
           if (clazz != null) return new Boolean(Util.has(clazz, (ASTConstructor) n, advisor));
           if (ctClass != null) return new Boolean(Util.has(ctClass, (ASTConstructor) n, advisor));
        }
        return Boolean.FALSE;
     }
  
     public Object visit(ASTHasField node, Object data)
     {
        if (clazz == null) return Boolean.TRUE;
        ASTField f = (ASTField) node.jjtGetChild(0);
        return new Boolean(Util.has(clazz, f, (ClassAdvisor) advisor));
     }
  
     public Object visit(ASTClass node, Object data)
     {
        if (clazz != null)
        {
           return new Boolean(Util.matchesClassExpr(node.getClazz(), clazz, advisor));
        }
        else
        {
           return new Boolean(Util.matchesClassExpr(node.getClazz(), ctClass, advisor));
        }
     }
  
     public Object visit(ASTMethod node, Object data)
     {
        return Boolean.FALSE;
     }
  
     public Object visit(ASTAttribute node, Object data)
     {
        return Boolean.FALSE;
     }
  
     public Object visit(ASTConstructor node, Object data)
     {
        return Boolean.FALSE;
     }
  
     public Object visit(ASTParameter node, Object data)
     {
        return Boolean.FALSE;
     }
  
     public Object visit(ASTAllParameter node, Object data)
     {
        return Boolean.FALSE;
     }
  
     public Object visit(ASTField node, Object data)
     {
        return Boolean.FALSE;
     }
  
  }