/*******************************************************************************
* 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.List;
import java.util.Map;
/**
* Primitive type nodes.
* <pre>
* PrimitiveType:
* <b>byte</b>
* <b>short</b>
* <b>char</b>
* <b>int</b>
* <b>long</b>
* <b>float</b>
* <b>double</b>
* <b>boolean</b>
* <b>void</b>
* </pre>
* <p>
* Note that due to the fact that AST nodes belong to a specific AST and
* have a specific parent, there needs to multiple instances of these
* nodes.
* </p>
*
* @since 2.0
* @noinstantiate This class is not intended to be instantiated by clients.
*/
public class PrimitiveType extends Type {
/**
* Primitive type codes (typesafe enumeration).
* <pre>
* <b>byte</b> BYTE
* <b>short</b> SHORT
* <b>char</b> CHAR
* <b>int</b> INT
* <b>long</b> LONG
* <b>float</b> FLOAT
* <b>double</b> DOUBLE
* <b>boolean</b> BOOLEAN
* <b>void</b> VOID
* </pre>
*/
public static class Code {
/**
* The name of the type.
*/
private String name;
/**
* Creates a new primitive type code with the given name.
* <p>
* Note: this constructor is package-private. The only instances
* ever created are the ones for the standard primitive types.
* </p>
*
* @param name the standard name of the primitive type
*/
Code(String name) {
this.name = name;
}
/**
* Returns the standard name of the primitive type.
*
* @return the standard name of the primitive type
*/
public String toString() {
return this.name;
}
}
/** Type code for the primitive type "int". */
public static final Code INT = new Code("int");//$NON-NLS-1$
/** Type code for the primitive type "char". */
public static final Code CHAR = new Code("char");//$NON-NLS-1$
/** Type code for the primitive type "boolean". */
public static final Code BOOLEAN = new Code("boolean");//$NON-NLS-1$
/** Type code for the primitive type "short". */
public static final Code SHORT = new Code("short");//$NON-NLS-1$
/** Type code for the primitive type "long". */
public static final Code LONG = new Code("long");//$NON-NLS-1$
/** Type code for the primitive type "float". */
public static final Code FLOAT = new Code("float");//$NON-NLS-1$
/** Type code for the primitive type "double". */
public static final Code DOUBLE = new Code("double");//$NON-NLS-1$
/** Type code for the primitive type "byte". */
public static final Code BYTE = new Code("byte");//$NON-NLS-1$
/** Type code for the primitive type "void". Note that "void" is
* special in that its only legitimate uses are as a method return
* type and as a type literal.
*/
public static final Code VOID = new Code("void");//$NON-NLS-1$
/**
* The primitive type code; one of the PrimitiveType constants; default
* is int.
*/
private PrimitiveType.Code typeCode = INT;
/**
* Map from token to primitive type code (key type: <code>String</code>;
* value type: <code>PrimitiveType.Code</code>).
*/
private static final Map CODES;
static {
CODES = new HashMap(20);
Code[] ops = {
INT,
BYTE,
CHAR,
BOOLEAN,
SHORT,
LONG,
FLOAT,
DOUBLE,
VOID,
};
for (int i = 0; i < ops.length; i++) {
CODES.put(ops[i].toString(), ops[i]);
}
}
/**
* Returns the primitive type code corresponding to the given string,
* or <code>null</code> if none.
* <p>
* <code>toCode</code> is the converse of <code>toString</code>:
* that is,
* <code>PrimitiveType.Code.toCode(code.toString()) == code</code>
* for all type code <code>code</code>.
* </p>
*
* @param token the standard name of the primitive type
* @return the primitive type code, or <code>null</code> if none
*/
public static PrimitiveType.Code toCode(String token) {
return (PrimitiveType.Code) CODES.get(token);
}
/**
* The "primitiveTypeCode" structural property of this node type (type: {@link PrimitiveType.Code}).
* @since 3.0
*/
public static final SimplePropertyDescriptor PRIMITIVE_TYPE_CODE_PROPERTY =
new SimplePropertyDescriptor(PrimitiveType.class, "primitiveTypeCode", PrimitiveType.Code.class, MANDATORY); //$NON-NLS-1$
/**
* A list of property descriptors (element type:
* {@link StructuralPropertyDescriptor}),
* or null if uninitialized.
*/
private static final List PROPERTY_DESCRIPTORS;
static {
List propertyList = new ArrayList(2);
createPropertyList(PrimitiveType.class, propertyList);
addProperty(PRIMITIVE_TYPE_CODE_PROPERTY, propertyList);
PROPERTY_DESCRIPTORS = reapPropertyList(propertyList);
}
/**
* 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;
}
/**
* Creates a new unparented node for a primitive type owned by the given
* AST. By default, the node has type "int".
* <p>
* N.B. This constructor is package-private.
* </p>
*
* @param ast the AST that is to own this node
*/
PrimitiveType(AST ast) {
super(ast);
}
/* (omit javadoc for this method)
* Method declared on ASTNode.
*/
final List internalStructuralPropertiesForType(int apiLevel) {
return propertyDescriptors(apiLevel);
}
/* (omit javadoc for this method)
* Method declared on ASTNode.
*/
final Object internalGetSetObjectProperty(SimplePropertyDescriptor property, boolean get, Object value) {
if (property == PRIMITIVE_TYPE_CODE_PROPERTY) {
if (get) {
return getPrimitiveTypeCode();
} else {
setPrimitiveTypeCode((Code) 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 int getNodeType0() {
return PRIMITIVE_TYPE;
}
/* (omit javadoc for this method)
* Method declared on ASTNode.
*/
ASTNode clone0(AST target) {
PrimitiveType result = new PrimitiveType(target);
result.setSourceRange(getStartPosition(), getLength());
result.setPrimitiveTypeCode(getPrimitiveTypeCode());
return result;
}
/* (omit javadoc for this method)
* Method declared on ASTNode.
*/
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.
*/
void accept0(ASTVisitor visitor) {
visitor.visit(this);
visitor.endVisit(this);
}
/**
* Returns the primitive type code.
*
* @return one of the primitive type code constants declared in this
* class
*/
public PrimitiveType.Code getPrimitiveTypeCode() {
return this.typeCode;
}
/**
* Sets the primitive type code.
*
* @param typeCode one of the primitive type code constants declared in
* this class
* @exception IllegalArgumentException if the argument is incorrect
*/
public void setPrimitiveTypeCode(PrimitiveType.Code typeCode) {
if (typeCode == null) {
throw new IllegalArgumentException();
}
preValueChange(PRIMITIVE_TYPE_CODE_PROPERTY);
this.typeCode = typeCode;
postValueChange(PRIMITIVE_TYPE_CODE_PROPERTY);
}
/* (omit javadoc for this method)
* Method declared on ASTNode.
*/
int memSize() {
// treat Code as free
return BASE_NODE_SIZE + 1 * 4;
}
/* (omit javadoc for this method)
* Method declared on ASTNode.
*/
int treeSize() {
return memSize();
}
}