/* *******************************************************************
 * Copyright (c) 2004 IBM
 * 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: 
 *     Andy Clement -     initial implementation {date}
 * ******************************************************************/

package org.aspectj.apache.bcel.classfile.annotation;

import java.io.DataOutputStream;
import java.io.IOException;

import org.aspectj.apache.bcel.Constants;
import org.aspectj.apache.bcel.classfile.ConstantDouble;
import org.aspectj.apache.bcel.classfile.ConstantFloat;
import org.aspectj.apache.bcel.classfile.ConstantInteger;
import org.aspectj.apache.bcel.classfile.ConstantLong;
import org.aspectj.apache.bcel.classfile.ConstantPool;
import org.aspectj.apache.bcel.classfile.ConstantUtf8;

public class SimpleElementValue extends ElementValue {

	// For primitive types and string type, this points to the value entry in the cpGen
	// For 'class' this points to the class entry in the cpGen
	private int idx;

	// ctors for each supported type... type could be inferred but for now lets
	// force it to be passed

	
Protected ctor used for deserialization, doesn't *put* an entry in the constant pool, assumes the one at the supplied index
is correct.
/**
	 * Protected ctor used for deserialization, doesn't *put* an entry in the constant pool, assumes the one at the supplied index
	 * is correct.
	 */
	protected SimpleElementValue(int type, int idx, ConstantPool cpGen) {
		super(type, cpGen);
		this.idx = idx;
	}

	public SimpleElementValue(int type, ConstantPool cpGen, int value) {
		super(type, cpGen);
		idx = cpGen.addInteger(value);
	}

	public SimpleElementValue(int type, ConstantPool cpGen, long value) {
		super(type, cpGen);
		idx = cpGen.addLong(value);
	}

	public SimpleElementValue(int type, ConstantPool cpGen, double value) {
		super(type, cpGen);
		idx = cpGen.addDouble(value);
	}

	public SimpleElementValue(int type, ConstantPool cpGen, float value) {
		super(type, cpGen);
		idx = cpGen.addFloat(value);
	}

	public SimpleElementValue(int type, ConstantPool cpGen, short value) {
		super(type, cpGen);
		idx = cpGen.addInteger(value);
	}

	public SimpleElementValue(int type, ConstantPool cpGen, byte value) {
		super(type, cpGen);
		idx = cpGen.addInteger(value);
	}

	public SimpleElementValue(int type, ConstantPool cpGen, char value) {
		super(type, cpGen);
		idx = cpGen.addInteger(value);
	}

	public SimpleElementValue(int type, ConstantPool cpGen, boolean value) {
		super(type, cpGen);
		if (value) {
			idx = cpGen.addInteger(1);
		} else {
			idx = cpGen.addInteger(0);
		}
	}

	public SimpleElementValue(int type, ConstantPool cpGen, String value) {
		super(type, cpGen);
		idx = cpGen.addUtf8(value);
	}

	public byte getValueByte() {
		if (type != PRIMITIVE_BYTE) {
			throw new RuntimeException("Dont call getValueByte() on a non BYTE ElementValue");
		}
		ConstantInteger c = (ConstantInteger) cpool.getConstant(idx, Constants.CONSTANT_Integer);
		return (byte) c.getIntValue();
	}

	public char getValueChar() {
		if (type != PRIMITIVE_CHAR) {
			throw new RuntimeException("Dont call getValueChar() on a non CHAR ElementValue");
		}
		ConstantInteger c = (ConstantInteger) cpool.getConstant(idx, Constants.CONSTANT_Integer);
		return (char) c.getIntValue();
	}

	public long getValueLong() {
		if (type != PRIMITIVE_LONG) {
			throw new RuntimeException("Dont call getValueLong() on a non LONG ElementValue");
		}
		ConstantLong j = (ConstantLong) cpool.getConstant(idx);
		return j.getValue();
	}

	public float getValueFloat() {
		if (type != PRIMITIVE_FLOAT) {
			throw new RuntimeException("Dont call getValueFloat() on a non FLOAT ElementValue");
		}
		ConstantFloat f = (ConstantFloat) cpool.getConstant(idx);
		return f.getValue();
	}

	public double getValueDouble() {
		if (type != PRIMITIVE_DOUBLE) {
			throw new RuntimeException("Dont call getValueDouble() on a non DOUBLE ElementValue");
		}
		ConstantDouble d = (ConstantDouble) cpool.getConstant(idx);
		return d.getValue();
	}

	public boolean getValueBoolean() {
		if (type != PRIMITIVE_BOOLEAN) {
			throw new RuntimeException("Dont call getValueBoolean() on a non BOOLEAN ElementValue");
		}
		ConstantInteger bo = (ConstantInteger) cpool.getConstant(idx);
		return (bo.getValue() != 0);
	}

	public short getValueShort() {
		if (type != PRIMITIVE_SHORT) {
			throw new RuntimeException("Dont call getValueShort() on a non SHORT ElementValue");
		}
		ConstantInteger s = (ConstantInteger) cpool.getConstant(idx);
		return (short) s.getIntValue();
	}

	
The boolean controls whether we copy info from the 'old' constant pool to the 'new'. You need to use this ctor if the
annotation is being copied from one file to another.
/**
	 * The boolean controls whether we copy info from the 'old' constant pool to the 'new'. You need to use this ctor if the
	 * annotation is being copied from one file to another.
	 */
	public SimpleElementValue(SimpleElementValue value, ConstantPool cpool, boolean copyPoolEntries) {
		super(value.getElementValueType(), cpool);
		if (!copyPoolEntries) {
			// J5ASSERT: Could assert value.stringifyValue() is the same as
			// cpool.getConstant(SimpleElementValuevalue.getIndex())
			idx = value.getIndex();
		} else {
			switch (value.getElementValueType()) {
			case STRING:
				idx = cpool.addUtf8(value.getValueString());
				break;
			case PRIMITIVE_INT:
				idx = cpool.addInteger(value.getValueInt());
				break;
			case PRIMITIVE_BYTE:
				idx = cpool.addInteger(value.getValueByte());
				break;
			case PRIMITIVE_CHAR:
				idx = cpool.addInteger(value.getValueChar());
				break;
			case PRIMITIVE_LONG:
				idx = cpool.addLong(value.getValueLong());
				break;
			case PRIMITIVE_FLOAT:
				idx = cpool.addFloat(value.getValueFloat());
				break;
			case PRIMITIVE_DOUBLE:
				idx = cpool.addDouble(value.getValueDouble());
				break;
			case PRIMITIVE_BOOLEAN:
				if (value.getValueBoolean()) {
					idx = cpool.addInteger(1);
				} else {
					idx = cpool.addInteger(0);
				}
				break;
			case PRIMITIVE_SHORT:
				idx = cpool.addInteger(value.getValueShort());
				break;
			default:
				throw new RuntimeException("SimpleElementValueGen class does not know how " + "to copy this type " + type);
			}
		}
	}

	public int getIndex() {
		return idx;
	}

	public String getValueString() {
		if (type != STRING) {
			throw new RuntimeException("Dont call getValueString() on a non STRING ElementValue");
		}
		ConstantUtf8 c = (ConstantUtf8) cpool.getConstant(idx);
		return c.getValue();
	}

	public int getValueInt() {
		if (type != PRIMITIVE_INT) {
			throw new RuntimeException("Dont call getValueString() on a non STRING ElementValue");
		}
		ConstantInteger c = (ConstantInteger) cpool.getConstant(idx);
		return c.getValue();
	}

	// Whatever kind of value it is, return it as a string
	@Override
	public String stringifyValue() {
		switch (type) {
		case PRIMITIVE_INT:
			ConstantInteger c = (ConstantInteger) cpool.getConstant(idx);
			return Integer.toString(c.getValue());
		case PRIMITIVE_LONG:
			ConstantLong j = (ConstantLong) cpool.getConstant(idx);
			return Long.toString(j.getValue());
		case PRIMITIVE_DOUBLE:
			ConstantDouble d = (ConstantDouble) cpool.getConstant(idx);
			return d.getValue().toString();
		case PRIMITIVE_FLOAT:
			ConstantFloat f = (ConstantFloat) cpool.getConstant(idx);
			return Float.toString(f.getValue());
		case PRIMITIVE_SHORT:
			ConstantInteger s = (ConstantInteger) cpool.getConstant(idx);
			return Integer.toString(s.getValue());
		case PRIMITIVE_BYTE:
			ConstantInteger b = (ConstantInteger) cpool.getConstant(idx);
			return Integer.toString(b.getValue());
		case PRIMITIVE_CHAR:
			ConstantInteger ch = (ConstantInteger) cpool.getConstant(idx);
			return new Character((char) ch.getIntValue()).toString();
		case PRIMITIVE_BOOLEAN:
			ConstantInteger bo = (ConstantInteger) cpool.getConstant(idx);
			if (bo.getValue() == 0) {
				return "false";
			} else {
				return "true";
			}
		case STRING:
			ConstantUtf8 cu8 = (ConstantUtf8) cpool.getConstant(idx);
			return cu8.getValue();

		default:
			throw new RuntimeException("SimpleElementValueGen class does not know how to stringify type " + type);
		}
	}

	@Override
	public String toString() {
		StringBuilder s = new StringBuilder();
		switch (type) {
		case PRIMITIVE_INT:
			ConstantInteger c = (ConstantInteger) cpool.getConstant(idx);
			s.append("(int)").append(Integer.toString(c.getValue()));
			break;
		case PRIMITIVE_LONG:
			ConstantLong j = (ConstantLong) cpool.getConstant(idx);
			s.append("(long)").append(Long.toString(j.getValue()));
			break;
		case PRIMITIVE_DOUBLE:
			ConstantDouble d = (ConstantDouble) cpool.getConstant(idx);
			s.append("(double)").append(d.getValue().toString());
			break;
		case PRIMITIVE_FLOAT:
			ConstantFloat f = (ConstantFloat) cpool.getConstant(idx);
			s.append("(float)").append(Float.toString(f.getValue()));
			break;
		case PRIMITIVE_SHORT:
			ConstantInteger ci = (ConstantInteger) cpool.getConstant(idx);
			s.append("(short)").append(Integer.toString(ci.getValue()));
			break;
		case PRIMITIVE_BYTE:
			ConstantInteger b = (ConstantInteger) cpool.getConstant(idx);
			s.append("(byte)").append(Integer.toString(b.getValue()));
			break;
		case PRIMITIVE_CHAR:
			ConstantInteger ch = (ConstantInteger) cpool.getConstant(idx);
			s.append("(char)").append(new Character((char) ch.getIntValue()).toString());
			break;
		case PRIMITIVE_BOOLEAN:
			ConstantInteger bo = (ConstantInteger) cpool.getConstant(idx);
			s.append("(boolean)");
			if (bo.getValue() == 0) {
				s.append("false");
			} else {
				s.append("true");
			}
			break;
		case STRING:
			ConstantUtf8 cu8 = (ConstantUtf8) cpool.getConstant(idx);
			s.append("(string)").append(cu8.getValue());
			break;
		default:
			throw new RuntimeException("SimpleElementValueGen class does not know how to stringify type " + type);
		}
		return s.toString();
	}

	@Override
	public void dump(DataOutputStream dos) throws IOException {
		dos.writeByte(type); // u1 kind of value
		switch (type) {
		case PRIMITIVE_INT:
		case PRIMITIVE_BYTE:
		case PRIMITIVE_CHAR:
		case PRIMITIVE_FLOAT:
		case PRIMITIVE_LONG:
		case PRIMITIVE_BOOLEAN:
		case PRIMITIVE_SHORT:
		case PRIMITIVE_DOUBLE:
		case STRING:
			dos.writeShort(idx);
			break;
		default:
			throw new RuntimeException("SimpleElementValueGen doesnt know how to write out type " + type);
		}
	}

}