/*******************************************************************************
* 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.che.ide.ext.java.jdt.core.dom;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Primitive type nodes.
* <p/>
* <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>
*
* @noinstantiate This class is not intended to be instantiated by clients.
* @since 2.0
*/
public class PrimitiveType extends Type {
/**
* Primitive type codes (typesafe enumeration).
* <p/>
* <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
* @throws 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();
}
}