org.aspectj.weaver.patterns.ThrowsPattern.java Source code

Introduction

Here is the source code for org.aspectj.weaver.patterns.ThrowsPattern.java

Source

/* *******************************************************************
 * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
 * All rights reserved. 
 * This program and the accompanying materials are made available 
 * under the terms of the Eclipse Public License v1.0 
 * which accompanies this distribution and is available at 
 * http://www.eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: 
 *     PARC     initial implementation 
 * ******************************************************************/

package org.aspectj.weaver.patterns;

import java.io.IOException;
import java.util.Map;

import org.aspectj.weaver.CompressingDataOutputStream;
import org.aspectj.weaver.ISourceContext;
import org.aspectj.weaver.ResolvedType;
import org.aspectj.weaver.UnresolvedType;
import org.aspectj.weaver.VersionedDataInputStream;
import org.aspectj.weaver.World;

public class ThrowsPattern extends PatternNode {
    private TypePatternList required;
    private TypePatternList forbidden;

    public static final ThrowsPattern ANY = new ThrowsPattern(TypePatternList.EMPTY, TypePatternList.EMPTY);

    public ThrowsPattern(TypePatternList required, TypePatternList forbidden) {
        this.required = required;
        this.forbidden = forbidden;
    }

    public TypePatternList getRequired() {
        return required;
    }

    public TypePatternList getForbidden() {
        return forbidden;
    }

    public String toString() {
        if (this == ANY) {
            return "";
        }

        String ret = "throws " + required.toString();
        if (forbidden.size() > 0) {
            ret = ret + " !(" + forbidden.toString() + ")";
        }
        return ret;
    }

    public boolean equals(Object other) {
        if (!(other instanceof ThrowsPattern)) {
            return false;
        }
        ThrowsPattern o = (ThrowsPattern) other;
        boolean ret = o.required.equals(this.required) && o.forbidden.equals(this.forbidden);
        return ret;
    }

    public int hashCode() {
        int result = 17;
        result = 37 * result + required.hashCode();
        result = 37 * result + forbidden.hashCode();
        return result;
    }

    public ThrowsPattern resolveBindings(IScope scope, Bindings bindings) {
        if (this == ANY) {
            return this;
        }
        required = required.resolveBindings(scope, bindings, false, false);
        forbidden = forbidden.resolveBindings(scope, bindings, false, false);
        return this;
    }

    public ThrowsPattern parameterizeWith(Map<String, UnresolvedType> typeVariableMap, World w) {
        ThrowsPattern ret = new ThrowsPattern(required.parameterizeWith(typeVariableMap, w),
                forbidden.parameterizeWith(typeVariableMap, w));
        ret.copyLocationFrom(this);
        return ret;
    }

    public boolean matches(UnresolvedType[] tys, World world) {
        if (this == ANY) {
            return true;
        }

        // System.out.println("matching: " + this + " with " + Arrays.asList(tys));

        ResolvedType[] types = world.resolve(tys);
        // int len = types.length;
        for (int j = 0, lenj = required.size(); j < lenj; j++) {
            if (!matchesAny(required.get(j), types)) {
                return false;
            }
        }
        for (int j = 0, lenj = forbidden.size(); j < lenj; j++) {
            if (matchesAny(forbidden.get(j), types)) {
                return false;
            }
        }
        return true;
    }

    private boolean matchesAny(TypePattern typePattern, ResolvedType[] types) {
        for (int i = types.length - 1; i >= 0; i--) {
            if (typePattern.matchesStatically(types[i])) {
                return true;
            }
        }
        return false;
    }

    public static ThrowsPattern read(VersionedDataInputStream s, ISourceContext context) throws IOException {
        TypePatternList required = TypePatternList.read(s, context);
        TypePatternList forbidden = TypePatternList.read(s, context);
        if (required.size() == 0 && forbidden.size() == 0) {
            return ANY;
        }
        ThrowsPattern ret = new ThrowsPattern(required, forbidden);
        // XXXret.readLocation(context, s);
        return ret;
    }

    public void write(CompressingDataOutputStream s) throws IOException {
        required.write(s);
        forbidden.write(s);
        // XXXwriteLocation(s);
    }

    public Object accept(PatternNodeVisitor visitor, Object data) {
        return visitor.visit(this, data);
    }

    public Object traverse(PatternNodeVisitor visitor, Object data) {
        Object ret = accept(visitor, data);
        forbidden.traverse(visitor, data);
        required.traverse(visitor, data);
        return ret;
    }
}