Copyright (c) 2015, 2016 Google, Inc and others.
This program and the accompanying materials
are made available under the terms of the Eclipse Public License 2.0
which accompanies this distribution, and is available at
https://www.eclipse.org/legal/epl-2.0/
SPDX-License-Identifier: EPL-2.0
Contributors:
  Stefan Xenos (Google) - Initial implementation
/*******************************************************************************
 * Copyright (c) 2015, 2016 Google, Inc and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *   Stefan Xenos (Google) - Initial implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.core.nd.java;

import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.core.nd.Nd;
import org.eclipse.jdt.internal.core.nd.NdNode;
import org.eclipse.jdt.internal.core.nd.field.FieldManyToOne;
import org.eclipse.jdt.internal.core.nd.field.FieldOneToOne;
import org.eclipse.jdt.internal.core.nd.field.StructDef;

public abstract class NdConstant extends NdNode {
	// Parent pointers. Only one will be non-null.
	// TODO(sxenos): Create something like a union to hold these, to eliminate this
	// sparse data
	public static final FieldManyToOne<NdConstantArray> PARENT_ARRAY;
	public static final FieldOneToOne<NdAnnotationValuePair> PARENT_ANNOTATION_VALUE;
	public static final FieldOneToOne<NdVariable> PARENT_VARIABLE;
	public static final FieldOneToOne<NdMethod> PARENT_METHOD;

	@SuppressWarnings("hiding")
	public static StructDef<NdConstant> type;

	static {
		type = StructDef.createAbstract(NdConstant.class, NdNode.type);
		PARENT_ARRAY = FieldManyToOne.createOwner(type, NdConstantArray.ELEMENTS);
		PARENT_ANNOTATION_VALUE = FieldOneToOne.createOwner(type, NdAnnotationValuePair.type,
				NdAnnotationValuePair.VALUE);
		PARENT_VARIABLE = FieldOneToOne.createOwner(type, NdVariable.type, NdVariable.CONSTANT);
		PARENT_METHOD = FieldOneToOne.createOwner(type, NdMethod.type, NdMethod.DEFAULT_VALUE);
		type.done();
	}

	public NdConstant(Nd nd, long address) {
		super(nd, address);
	}

	protected NdConstant(Nd nd) {
		super(nd);
	}

	public static NdConstant create(Nd nd, Constant constant) {
		if (constant == Constant.NotAConstant) {
			return null;
		}

		switch (constant.typeID()) {
			case TypeIds.T_boolean:
				return NdConstantBoolean.create(nd, constant.booleanValue());
			case TypeIds.T_byte:
				return NdConstantByte.create(nd, constant.byteValue());
			case TypeIds.T_char:
				return NdConstantChar.create(nd, constant.charValue());
			case TypeIds.T_double:
				return NdConstantDouble.create(nd, constant.doubleValue());
			case TypeIds.T_float:
				return NdConstantFloat.create(nd, constant.floatValue());
			case TypeIds.T_int:
				return NdConstantInt.create(nd, constant.intValue());
			case TypeIds.T_long:
				return NdConstantLong.create(nd, constant.longValue());
			case TypeIds.T_short:
				return NdConstantShort.create(nd, constant.shortValue());
			case TypeIds.T_JavaLangString:
				return NdConstantString.create(nd, constant.stringValue());
			default:
				throw new IllegalArgumentException("Unknown typeID() " + constant.typeID()); //$NON-NLS-1$
		}
	}

	public void setParent(NdConstantArray result) {
		PARENT_ARRAY.put(getNd(), this.address, result);
	}

	
Returns the Constant corresponding to the value of this NdConstant or null if the receiver corresponds to a Constant. /**
	 * Returns the {@link Constant} corresponding to the value of this {@link NdConstant} or null if the receiver
	 * corresponds to a {@link Constant}.
	 */
	public abstract Constant getConstant();

	@Override
	public String toString() {
		try {
			return getConstant().toString();
		} catch (RuntimeException e) {
			// This is called most often from the debugger, so we want to return something meaningful even
			// if the code is buggy, the database is corrupt, or we don't have a read lock.
			return super.toString();
		}
	}
}