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

Introduction

Here is the source code for org.aspectj.weaver.patterns.ModifiersPattern.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.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;

import org.aspectj.weaver.CompressingDataOutputStream;
import org.aspectj.weaver.VersionedDataInputStream;

public class ModifiersPattern extends PatternNode {
    private int requiredModifiers;
    private int forbiddenModifiers;

    public static final ModifiersPattern ANY = new ModifiersPattern(0, 0);

    private static Map<String, Integer> modifierFlags = null;

    static {
        modifierFlags = new HashMap<String, Integer>();
        int flag = 1;
        while (flag <= Modifier.STRICT) {
            String flagName = Modifier.toString(flag);
            modifierFlags.put(flagName, new Integer(flag));
            flag = flag << 1;
        }
        modifierFlags.put("synthetic", new Integer(0x1000 /* Modifier.SYNTHETIC */));
    }

    public ModifiersPattern(int requiredModifiers, int forbiddenModifiers) {
        this.requiredModifiers = requiredModifiers;
        this.forbiddenModifiers = forbiddenModifiers;
    }

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

        String ret = Modifier.toString(requiredModifiers);
        if (forbiddenModifiers == 0) {
            return ret;
        } else {
            return ret + " !" + Modifier.toString(forbiddenModifiers);
        }
    }

    public boolean equals(Object other) {
        if (!(other instanceof ModifiersPattern)) {
            return false;
        }
        ModifiersPattern o = (ModifiersPattern) other;
        return o.requiredModifiers == this.requiredModifiers && o.forbiddenModifiers == this.forbiddenModifiers;
    }

    public int hashCode() {
        int result = 17;
        result = 37 * result + requiredModifiers;
        result = 37 * result + forbiddenModifiers;
        return result;
    }

    public boolean matches(int modifiers) {
        return ((modifiers & requiredModifiers) == requiredModifiers) && ((modifiers & forbiddenModifiers) == 0);
    }

    public static ModifiersPattern read(VersionedDataInputStream s) throws IOException {
        int requiredModifiers = s.readShort();
        int forbiddenModifiers = s.readShort();
        if (requiredModifiers == 0 && forbiddenModifiers == 0) {
            return ANY;
        }
        return new ModifiersPattern(requiredModifiers, forbiddenModifiers);
    }

    public void write(CompressingDataOutputStream s) throws IOException {
        // s.writeByte(MODIFIERS_PATTERN);
        s.writeShort(requiredModifiers);
        s.writeShort(forbiddenModifiers);
    }

    public static int getModifierFlag(String name) {
        Integer flag = modifierFlags.get(name);
        if (flag == null) {
            return -1;
        }
        return flag.intValue();
    }

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