| /******************************************************************************* |
| * Copyright (c) 2000, 2010 IBM Corporation and others. |
| * 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: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jdt.core.dom; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * Modifier node. |
| * <pre> |
| * Modifier: |
| * <b>public</b> |
| * <b>protected</b> |
| * <b>private</b> |
| * <b>static</b> |
| * <b>abstract</b> |
| * <b>final</b> |
| * <b>native</b> |
| * <b>synchronized</b> |
| * <b>transient</b> |
| * <b>volatile</b> |
| * <b>strictfp</b> |
| * </pre> |
| * <p> |
| * The numeric values of these flags match the ones for class |
| * files as described in the Java Virtual Machine Specification. |
| * Note that Java model class {@link org.eclipse.jdt.core.Flags} also |
| * provides the same constants as this class. |
| * </p> |
| * |
| * @since 2.0 |
| * @noinstantiate This class is not intended to be instantiated by clients. |
| */ |
| public final class Modifier extends ASTNode implements IExtendedModifier { |
| |
| /** |
| * Modifier keywords (typesafe enumeration). |
| * @since 3.0 |
| */ |
| public static class ModifierKeyword { |
| |
| /** "abstract" modifier with flag value {@link Modifier#ABSTRACT}. */ |
| public static final ModifierKeyword ABSTRACT_KEYWORD = new ModifierKeyword("abstract", ABSTRACT);//$NON-NLS-1$ |
| |
| /** "final" modifier with flag value {@link Modifier#FINAL}. */ |
| public static final ModifierKeyword FINAL_KEYWORD = new ModifierKeyword("final", FINAL);//$NON-NLS-1$ |
| |
| /** |
| * Map from token to operator (key type: <code>String</code>; |
| * value type: <code>Operator</code>). |
| */ |
| private static final Map KEYWORDS; |
| |
| /** "native" modifier with flag value {@link Modifier#NATIVE}. */ |
| public static final ModifierKeyword NATIVE_KEYWORD = new ModifierKeyword("native", NATIVE);//$NON-NLS-1$ |
| |
| /** "private" modifier with flag value {@link Modifier#PRIVATE}. */ |
| public static final ModifierKeyword PRIVATE_KEYWORD = new ModifierKeyword("private", PRIVATE);//$NON-NLS-1$ |
| |
| /** "protected" modifier with flag value {@link Modifier#PROTECTED}. */ |
| public static final ModifierKeyword PROTECTED_KEYWORD = new ModifierKeyword("protected", PROTECTED);//$NON-NLS-1$ |
| |
| /** "public" modifier with flag value {@link Modifier#PUBLIC}. */ |
| public static final ModifierKeyword PUBLIC_KEYWORD = new ModifierKeyword("public", PUBLIC);//$NON-NLS-1$ |
| |
| /** "static" modifier with flag value {@link Modifier#STATIC}. */ |
| public static final ModifierKeyword STATIC_KEYWORD = new ModifierKeyword("static", STATIC);//$NON-NLS-1$ |
| |
| /** "strictfp" modifier with flag value {@link Modifier#STRICTFP}. */ |
| public static final ModifierKeyword STRICTFP_KEYWORD = new ModifierKeyword("strictfp", STRICTFP);//$NON-NLS-1$ |
| |
| /** "synchronized" modifier with flag value {@link Modifier#SYNCHRONIZED}. */ |
| public static final ModifierKeyword SYNCHRONIZED_KEYWORD = new ModifierKeyword("synchronized", SYNCHRONIZED);//$NON-NLS-1$ |
| |
| /** "transient" modifier with flag value {@link Modifier#TRANSIENT}. */ |
| public static final ModifierKeyword TRANSIENT_KEYWORD = new ModifierKeyword("transient", TRANSIENT);//$NON-NLS-1$ |
| |
| /** "volatile" modifier with flag value {@link Modifier#VOLATILE}. */ |
| public static final ModifierKeyword VOLATILE_KEYWORD = new ModifierKeyword("volatile", VOLATILE);//$NON-NLS-1$ |
| static { |
| KEYWORDS = new HashMap(20); |
| ModifierKeyword[] ops = { |
| PUBLIC_KEYWORD, |
| PROTECTED_KEYWORD, |
| PRIVATE_KEYWORD, |
| STATIC_KEYWORD, |
| ABSTRACT_KEYWORD, |
| FINAL_KEYWORD, |
| NATIVE_KEYWORD, |
| SYNCHRONIZED_KEYWORD, |
| TRANSIENT_KEYWORD, |
| VOLATILE_KEYWORD, |
| STRICTFP_KEYWORD |
| }; |
| for (int i = 0; i < ops.length; i++) { |
| KEYWORDS.put(ops[i].toString(), ops[i]); |
| } |
| } |
| |
| /** |
| * Returns the modifier corresponding to the given single-bit flag value, |
| * or <code>null</code> if none or if more than one bit is set. |
| * <p> |
| * <code>fromFlagValue</code> is the converse of <code>toFlagValue</code>: |
| * that is, <code>ModifierKind.fromFlagValue(k.toFlagValue()) == k</code> for |
| * all modifier keywords <code>k</code>. |
| * </p> |
| * |
| * @param flagValue the single-bit flag value for the modifier |
| * @return the modifier keyword, or <code>null</code> if none |
| * @see #toFlagValue() |
| */ |
| public static ModifierKeyword fromFlagValue(int flagValue) { |
| for (Iterator it = KEYWORDS.values().iterator(); it.hasNext(); ) { |
| ModifierKeyword k = (ModifierKeyword) it.next(); |
| if (k.toFlagValue() == flagValue) { |
| return k; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the modifier corresponding to the given string, |
| * or <code>null</code> if none. |
| * <p> |
| * <code>toKeyword</code> is the converse of <code>toString</code>: |
| * that is, <code>ModifierKind.toKeyword(k.toString()) == k</code> for |
| * all modifier keywords <code>k</code>. |
| * </p> |
| * |
| * @param keyword the lowercase string name for the modifier |
| * @return the modifier keyword, or <code>null</code> if none |
| * @see #toString() |
| */ |
| public static ModifierKeyword toKeyword(String keyword) { |
| return (ModifierKeyword) KEYWORDS.get(keyword); |
| } |
| |
| /** |
| * The flag value for the modifier. |
| */ |
| private int flagValue; |
| |
| /** |
| * The keyword modifier string. |
| */ |
| private String keyword; |
| |
| /** |
| * Creates a new modifier with the given keyword. |
| * <p> |
| * Note: this constructor is private. The only instances |
| * ever created are the ones for the standard modifiers. |
| * </p> |
| * |
| * @param keyword the character sequence for the modifier |
| * @param flagValue flag value as described in the Java Virtual Machine Specification |
| */ |
| private ModifierKeyword(String keyword, int flagValue) { |
| this.keyword = keyword; |
| this.flagValue = flagValue; |
| } |
| |
| /** |
| * Returns the modifier flag value corresponding to this modifier keyword. |
| * These flag values are as described in the Java Virtual Machine Specification. |
| * |
| * @return one of the <code>Modifier</code> constants |
| * @see #fromFlagValue(int) |
| */ |
| public int toFlagValue() { |
| return this.flagValue; |
| } |
| |
| /** |
| * Returns the keyword for the modifier. |
| * |
| * @return the keyword for the modifier |
| * @see #toKeyword(String) |
| */ |
| public String toString() { |
| return this.keyword; |
| } |
| } |
| |
| /** |
| * "abstract" modifier constant (bit mask). |
| * Applicable to types and methods. |
| * @since 2.0 |
| */ |
| public static final int ABSTRACT = 0x0400; |
| |
| /** |
| * "final" modifier constant (bit mask). |
| * Applicable to types, methods, fields, and variables. |
| * @since 2.0 |
| */ |
| public static final int FINAL = 0x0010; |
| |
| /** |
| * The "keyword" structural property of this node type (type: {@link Modifier.ModifierKeyword}). |
| * @since 3.0 |
| */ |
| public static final SimplePropertyDescriptor KEYWORD_PROPERTY = |
| new SimplePropertyDescriptor(Modifier.class, "keyword", Modifier.ModifierKeyword.class, MANDATORY); //$NON-NLS-1$ |
| |
| /** |
| * "native" modifier constant (bit mask). |
| * Applicable only to methods. |
| * @since 2.0 |
| */ |
| public static final int NATIVE = 0x0100; |
| |
| /** |
| * Modifier constant (bit mask, value 0) indicating no modifiers. |
| * @since 2.0 |
| */ |
| public static final int NONE = 0x0000; |
| |
| /** |
| * "private" modifier constant (bit mask). |
| * Applicable to types, methods, constructors, and fields. |
| * @since 2.0 |
| */ |
| public static final int PRIVATE = 0x0002; |
| |
| /** |
| * A list of property descriptors (element type: |
| * {@link StructuralPropertyDescriptor}), |
| * or null if uninitialized. |
| */ |
| private static final List PROPERTY_DESCRIPTORS; |
| |
| /** |
| * "protected" modifier constant (bit mask). |
| * Applicable to types, methods, constructors, and fields. |
| * @since 2.0 |
| */ |
| public static final int PROTECTED = 0x0004; |
| |
| /** |
| * "public" modifier constant (bit mask). |
| * Applicable to types, methods, constructors, and fields. |
| * @since 2.0 |
| */ |
| public static final int PUBLIC = 0x0001; |
| |
| /** |
| * "static" modifier constant (bit mask). |
| * Applicable to types, methods, fields, and initializers. |
| * @since 2.0 |
| */ |
| public static final int STATIC = 0x0008; |
| |
| /** |
| * "strictfp" modifier constant (bit mask). |
| * Applicable to types and methods. |
| * @since 2.0 |
| */ |
| public static final int STRICTFP = 0x0800; |
| |
| /** |
| * "synchronized" modifier constant (bit mask). |
| * Applicable only to methods. |
| * @since 2.0 |
| */ |
| public static final int SYNCHRONIZED = 0x0020; |
| |
| /** |
| * "transient" modifier constant (bit mask). |
| * Applicable only to fields. |
| * @since 2.0 |
| */ |
| public static final int TRANSIENT = 0x0080; |
| |
| /** |
| * "volatile" modifier constant (bit mask). |
| * Applicable only to fields. |
| * @since 2.0 |
| */ |
| public static final int VOLATILE = 0x0040; |
| |
| static { |
| List properyList = new ArrayList(2); |
| createPropertyList(Modifier.class, properyList); |
| addProperty(KEYWORD_PROPERTY, properyList); |
| PROPERTY_DESCRIPTORS = reapPropertyList(properyList); |
| } |
| |
| /** |
| * Returns whether the given flags includes the "abstract" modifier. |
| * Applicable to types and methods. |
| * |
| * @param flags the modifier flags |
| * @return <code>true</code> if the <code>ABSTRACT</code> bit is |
| * set, and <code>false</code> otherwise |
| * @since 2.0 |
| */ |
| public static boolean isAbstract(int flags) { |
| return (flags & ABSTRACT) != 0; |
| } |
| |
| /** |
| * Returns whether the given flags includes the "final" modifier. |
| * Applicable to types, methods, fields, and variables. |
| * |
| * @param flags the modifier flags |
| * @return <code>true</code> if the <code>FINAL</code> bit is |
| * set, and <code>false</code> otherwise |
| * @since 2.0 |
| */ |
| public static boolean isFinal(int flags) { |
| return (flags & FINAL) != 0; |
| } |
| |
| /** |
| * Returns whether the given flags includes the "native" modifier. |
| * Applicable only to methods. |
| * |
| * @param flags the modifier flags |
| * @return <code>true</code> if the <code>NATIVE</code> bit is |
| * set, and <code>false</code> otherwise |
| * @since 2.0 |
| */ |
| public static boolean isNative(int flags) { |
| return (flags & NATIVE) != 0; |
| } |
| |
| /** |
| * Returns whether the given flags includes the "private" modifier. |
| * Applicable to types, methods, constructors, and fields. |
| * |
| * @param flags the modifier flags |
| * @return <code>true</code> if the <code>PRIVATE</code> bit is |
| * set, and <code>false</code> otherwise |
| * @since 2.0 |
| */ |
| public static boolean isPrivate(int flags) { |
| return (flags & PRIVATE) != 0; |
| } |
| |
| /** |
| * Returns whether the given flags includes the "protected" modifier. |
| * Applicable to types, methods, constructors, and fields. |
| * |
| * @param flags the modifier flags |
| * @return <code>true</code> if the <code>PROTECTED</code> bit is |
| * set, and <code>false</code> otherwise |
| * @since 2.0 |
| */ |
| public static boolean isProtected(int flags) { |
| return (flags & PROTECTED) != 0; |
| } |
| |
| /** |
| * Returns whether the given flags includes the "public" modifier. |
| * Applicable to types, methods, constructors, and fields. |
| * |
| * @param flags the modifier flags |
| * @return <code>true</code> if the <code>PUBLIC</code> bit is |
| * set, and <code>false</code> otherwise |
| * @since 2.0 |
| */ |
| public static boolean isPublic(int flags) { |
| return (flags & PUBLIC) != 0; |
| } |
| |
| /** |
| * Returns whether the given flags includes the "static" modifier. |
| * Applicable to types, methods, fields, and initializers. |
| * |
| * @param flags the modifier flags |
| * @return <code>true</code> if the <code>STATIC</code> bit is |
| * set, and <code>false</code> otherwise |
| * @since 2.0 |
| */ |
| public static boolean isStatic(int flags) { |
| return (flags & STATIC) != 0; |
| } |
| |
| /** |
| * Returns whether the given flags includes the "strictfp" modifier. |
| * Applicable to types and methods. |
| * |
| * @param flags the modifier flags |
| * @return <code>true</code> if the <code>STRICTFP</code> bit is |
| * set, and <code>false</code> otherwise |
| * @since 2.0 |
| */ |
| public static boolean isStrictfp(int flags) { |
| return (flags & STRICTFP) != 0; |
| } |
| |
| /** |
| * Returns whether the given flags includes the "synchronized" modifier. |
| * Applicable only to methods. |
| * |
| * @param flags the modifier flags |
| * @return <code>true</code> if the <code>SYNCHRONIZED</code> bit is |
| * set, and <code>false</code> otherwise |
| * @since 2.0 |
| */ |
| public static boolean isSynchronized(int flags) { |
| return (flags & SYNCHRONIZED) != 0; |
| } |
| |
| /** |
| * Returns whether the given flags includes the "transient" modifier. |
| * Applicable only to fields. |
| * |
| * @param flags the modifier flags |
| * @return <code>true</code> if the <code>TRANSIENT</code> bit is |
| * set, and <code>false</code> otherwise |
| * @since 2.0 |
| */ |
| public static boolean isTransient(int flags) { |
| return (flags & TRANSIENT) != 0; |
| } |
| |
| /** |
| * Returns whether the given flags includes the "volatile" modifier. |
| * Applicable only to fields. |
| * |
| * @param flags the modifier flags |
| * @return <code>true</code> if the <code>VOLATILE</code> bit is |
| * set, and <code>false</code> otherwise |
| * @since 2.0 |
| */ |
| public static boolean isVolatile(int flags) { |
| return (flags & VOLATILE) != 0; |
| } |
| |
| /** |
| * Returns a list of structural property descriptors for this node type. |
| * Clients must not modify the result. |
| * |
| * @param apiLevel the API level; one of the |
| * <code>AST.JLS*</code> constants |
| |
| * @return a list of property descriptors (element type: |
| * {@link StructuralPropertyDescriptor}) |
| * @since 3.0 |
| */ |
| public static List propertyDescriptors(int apiLevel) { |
| return PROPERTY_DESCRIPTORS; |
| } |
| |
| /** |
| * The modifier keyword; defaults to an unspecified modifier. |
| * @since 3.0 |
| */ |
| private ModifierKeyword modifierKeyword = ModifierKeyword.PUBLIC_KEYWORD; |
| |
| /** |
| * Creates a new unparented modifier node owned by the given AST. |
| * By default, the node has unspecified (but legal) modifier. |
| * <p> |
| * N.B. This constructor is package-private. |
| * </p> |
| * |
| * @param ast the AST that is to own this node |
| * @since 3.0 |
| */ |
| Modifier(AST ast) { |
| super(ast); |
| unsupportedIn2(); |
| } |
| |
| /* (omit javadoc for this method) |
| * Method declared on ASTNode. |
| * @since 3.0 |
| */ |
| void accept0(ASTVisitor visitor) { |
| visitor.visit(this); |
| visitor.endVisit(this); |
| } |
| |
| /* (omit javadoc for this method) |
| * Method declared on ASTNode. |
| * @since 3.0 |
| */ |
| ASTNode clone0(AST target) { |
| Modifier result = new Modifier(target); |
| result.setSourceRange(getStartPosition(), getLength()); |
| result.setKeyword(getKeyword()); |
| return result; |
| } |
| |
| /** |
| * Returns the modifier keyword of this modifier node. |
| * |
| * @return the modifier keyword |
| * @since 3.0 |
| */ |
| public ModifierKeyword getKeyword() { |
| return this.modifierKeyword; |
| } |
| |
| /* (omit javadoc for this method) |
| * Method declared on ASTNode. |
| * @since 3.0 |
| */ |
| final int getNodeType0() { |
| return MODIFIER; |
| } |
| |
| /* (omit javadoc for this method) |
| * Method declared on ASTNode. |
| */ |
| final Object internalGetSetObjectProperty(SimplePropertyDescriptor property, boolean get, Object value) { |
| if (property == KEYWORD_PROPERTY) { |
| if (get) { |
| return getKeyword(); |
| } else { |
| setKeyword((ModifierKeyword) value); |
| return null; |
| } |
| } |
| // allow default implementation to flag the error |
| return super.internalGetSetObjectProperty(property, get, value); |
| } |
| |
| /* (omit javadoc for this method) |
| * Method declared on ASTNode. |
| */ |
| final List internalStructuralPropertiesForType(int apiLevel) { |
| return propertyDescriptors(apiLevel); |
| } |
| |
| /** |
| * Answer true if the receiver is the abstract modifier, false otherwise. |
| * |
| * @return true if the receiver is the abstract modifier, false otherwise |
| * @since 3.2 |
| */ |
| public boolean isAbstract() { |
| return this.modifierKeyword == ModifierKeyword.ABSTRACT_KEYWORD; |
| } |
| |
| /** |
| * @see IExtendedModifier#isAnnotation() |
| */ |
| public boolean isAnnotation() { |
| return false; |
| } |
| |
| /** |
| * Answer true if the receiver is the final modifier, false otherwise. |
| * |
| * @return true if the receiver is the final modifier, false otherwise |
| * @since 3.2 |
| */ |
| public boolean isFinal() { |
| return this.modifierKeyword == ModifierKeyword.FINAL_KEYWORD; |
| } |
| |
| /** |
| * @see IExtendedModifier#isModifier() |
| */ |
| public boolean isModifier() { |
| return true; |
| } |
| |
| /** |
| * Answer true if the receiver is the native modifier, false otherwise. |
| * |
| * @return true if the receiver is the native modifier, false otherwise |
| * @since 3.2 |
| */ |
| public boolean isNative() { |
| return this.modifierKeyword == ModifierKeyword.NATIVE_KEYWORD; |
| } |
| |
| /** |
| * Answer true if the receiver is the private modifier, false otherwise. |
| * |
| * @return true if the receiver is the private modifier, false otherwise |
| * @since 3.2 |
| */ |
| public boolean isPrivate() { |
| return this.modifierKeyword == ModifierKeyword.PRIVATE_KEYWORD; |
| } |
| |
| /** |
| * Answer true if the receiver is the protected modifier, false otherwise. |
| * |
| * @return true if the receiver is the protected modifier, false otherwise |
| * @since 3.2 |
| */ |
| public boolean isProtected() { |
| return this.modifierKeyword == ModifierKeyword.PROTECTED_KEYWORD; |
| } |
| |
| /** |
| * Answer true if the receiver is the public modifier, false otherwise. |
| * |
| * @return true if the receiver is the public modifier, false otherwise |
| * @since 3.2 |
| */ |
| public boolean isPublic() { |
| return this.modifierKeyword == ModifierKeyword.PUBLIC_KEYWORD; |
| } |
| |
| /** |
| * Answer true if the receiver is the static modifier, false otherwise. |
| * |
| * @return true if the receiver is the static modifier, false otherwise |
| * @since 3.2 |
| */ |
| public boolean isStatic() { |
| return this.modifierKeyword == ModifierKeyword.STATIC_KEYWORD; |
| } |
| |
| /** |
| * Answer true if the receiver is the strictfp modifier, false otherwise. |
| * |
| * @return true if the receiver is the strictfp modifier, false otherwise |
| * @since 3.2 |
| */ |
| public boolean isStrictfp() { |
| return this.modifierKeyword == ModifierKeyword.STRICTFP_KEYWORD; |
| } |
| |
| /** |
| * Answer true if the receiver is the synchronized modifier, false otherwise. |
| * |
| * @return true if the receiver is the synchronized modifier, false otherwise |
| * @since 3.2 |
| */ |
| public boolean isSynchronized() { |
| return this.modifierKeyword == ModifierKeyword.SYNCHRONIZED_KEYWORD; |
| } |
| |
| /** |
| * Answer true if the receiver is the transient modifier, false otherwise. |
| * |
| * @return true if the receiver is the transient modifier, false otherwise |
| * @since 3.2 |
| */ |
| public boolean isTransient() { |
| return this.modifierKeyword == ModifierKeyword.TRANSIENT_KEYWORD; |
| } |
| |
| /** |
| * Answer true if the receiver is the volatile modifier, false otherwise. |
| * |
| * @return true if the receiver is the volatile modifier, false otherwise |
| * @since 3.2 |
| */ |
| public boolean isVolatile() { |
| return this.modifierKeyword == ModifierKeyword.VOLATILE_KEYWORD; |
| } |
| |
| /* (omit javadoc for this method) |
| * Method declared on ASTNode. |
| * @since 3.0 |
| */ |
| int memSize() { |
| // treat ModifierKeyword as free |
| return BASE_NODE_SIZE + 1 * 4; |
| } |
| |
| /** |
| * Sets the modifier keyword of this modifier node. |
| * |
| * @param modifierKeyord the modifier keyword |
| * @exception IllegalArgumentException if the argument is <code>null</code> |
| * @since 3.0 |
| */ |
| public void setKeyword(ModifierKeyword modifierKeyord) { |
| if (modifierKeyord == null) { |
| throw new IllegalArgumentException(); |
| } |
| preValueChange(KEYWORD_PROPERTY); |
| this.modifierKeyword = modifierKeyord; |
| postValueChange(KEYWORD_PROPERTY); |
| } |
| |
| /* (omit javadoc for this method) |
| * Method declared on ASTNode. |
| * @since 3.0 |
| */ |
| final boolean subtreeMatch0(ASTMatcher matcher, Object other) { |
| // dispatch to correct overloaded match method |
| return matcher.match(this, other); |
| } |
| |
| /* (omit javadoc for this method) |
| * Method declared on ASTNode. |
| * @since 3.0 |
| */ |
| int treeSize() { |
| return memSize(); |
| } |
| } |