KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > bcel > classfile > ConstantValue


1 /*
2  * Copyright 2000-2004 The Apache Software Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17 package org.apache.bcel.classfile;
18
19 import java.io.DataInputStream JavaDoc;
20 import java.io.DataOutputStream JavaDoc;
21 import java.io.IOException JavaDoc;
22 import org.apache.bcel.Constants;
23
24 /**
25  * This class is derived from <em>Attribute</em> and represents a constant
26  * value, i.e., a default value for initializing a class field.
27  * This class is instantiated by the <em>Attribute.readAttribute()</em> method.
28  *
29  * @version $Id: ConstantValue.java 386056 2006-03-15 11:31:56Z tcurdt $
30  * @author <A HREF="mailto:m.dahm@gmx.de">M. Dahm</A>
31  * @see Attribute
32  */
33 public final class ConstantValue extends Attribute {
34
35     private int constantvalue_index;
36
37
38     /**
39      * Initialize from another object. Note that both objects use the same
40      * references (shallow copy). Use clone() for a physical copy.
41      */
42     public ConstantValue(ConstantValue c) {
43         this(c.getNameIndex(), c.getLength(), c.getConstantValueIndex(), c.getConstantPool());
44     }
45
46
47     /**
48      * Construct object from file stream.
49      * @param name_index Name index in constant pool
50      * @param length Content length in bytes
51      * @param file Input stream
52      * @param constant_pool Array of constants
53      * @throws IOException
54      */
55     ConstantValue(int name_index, int length, DataInputStream JavaDoc file, ConstantPool constant_pool)
56             throws IOException JavaDoc {
57         this(name_index, length, file.readUnsignedShort(), constant_pool);
58     }
59
60
61     /**
62      * @param name_index Name index in constant pool
63      * @param length Content length in bytes
64      * @param constantvalue_index Index in constant pool
65      * @param constant_pool Array of constants
66      */
67     public ConstantValue(int name_index, int length, int constantvalue_index,
68             ConstantPool constant_pool) {
69         super(Constants.ATTR_CONSTANT_VALUE, name_index, length, constant_pool);
70         this.constantvalue_index = constantvalue_index;
71     }
72
73
74     /**
75      * Called by objects that are traversing the nodes of the tree implicitely
76      * defined by the contents of a Java class. I.e., the hierarchy of methods,
77      * fields, attributes, etc. spawns a tree of objects.
78      *
79      * @param v Visitor object
80      */
81     public void accept( Visitor v ) {
82         v.visitConstantValue(this);
83     }
84
85
86     /**
87      * Dump constant value attribute to file stream on binary format.
88      *
89      * @param file Output file stream
90      * @throws IOException
91      */
92     public final void dump( DataOutputStream JavaDoc file ) throws IOException JavaDoc {
93         super.dump(file);
94         file.writeShort(constantvalue_index);
95     }
96
97
98     /**
99      * @return Index in constant pool of constant value.
100      */
101     public final int getConstantValueIndex() {
102         return constantvalue_index;
103     }
104
105
106     /**
107      * @param constantvalue_index the index info the constant pool of this constant value
108      */
109     public final void setConstantValueIndex( int constantvalue_index ) {
110         this.constantvalue_index = constantvalue_index;
111     }
112
113
114     /**
115      * @return String representation of constant value.
116      */
117     public final String JavaDoc toString() {
118         Constant c = constant_pool.getConstant(constantvalue_index);
119         String JavaDoc buf;
120         int i;
121         // Print constant to string depending on its type
122 switch (c.getTag()) {
123             case Constants.CONSTANT_Long:
124                 buf = "" + ((ConstantLong) c).getBytes();
125                 break;
126             case Constants.CONSTANT_Float:
127                 buf = "" + ((ConstantFloat) c).getBytes();
128                 break;
129             case Constants.CONSTANT_Double:
130                 buf = "" + ((ConstantDouble) c).getBytes();
131                 break;
132             case Constants.CONSTANT_Integer:
133                 buf = "" + ((ConstantInteger) c).getBytes();
134                 break;
135             case Constants.CONSTANT_String:
136                 i = ((ConstantString) c).getStringIndex();
137                 c = constant_pool.getConstant(i, Constants.CONSTANT_Utf8);
138                 buf = "\"" + Utility.convertString(((ConstantUtf8) c).getBytes()) + "\"";
139                 break;
140             default:
141                 throw new IllegalStateException JavaDoc("Type of ConstValue invalid: " + c);
142         }
143         return buf;
144     }
145
146
147     /**
148      * @return deep copy of this attribute
149      */
150     public Attribute copy( ConstantPool _constant_pool ) {
151         ConstantValue c = (ConstantValue) clone();
152         c.constant_pool = _constant_pool;
153         return c;
154     }
155 }
156
Popular Tags