| /* ******************************************************************* |
| * 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 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. |
| */ |
| 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); |
| } |
| } |
| |
| } |