1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
/*
* Javassist, a Java-bytecode translator toolkit.
* Copyright (C) 2004 Bill Burke. All Rights Reserved.
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. Alternatively, the contents of this file may be used under
* the terms of the GNU Lesser General Public License Version 2.1 or later,
* or the Apache License Version 2.0.
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*/
package javassist.bytecode.annotation;
import java.io.IOException;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.Map;
import javassist.ClassPool;
import javassist.bytecode.ConstPool;
/**
* Array member.
*
* @author <a href="mailto:bill@jboss.org">Bill Burke</a>
* @author Shigeru Chiba
*/
public class ArrayMemberValue extends MemberValue {
MemberValue type;
MemberValue[] values;
/**
* Constructs an array. The initial value or type are not specified.
*/
public ArrayMemberValue(ConstPool cp) {
super('[', cp);
type = null;
values = null;
}
/**
* Constructs an array. The initial value is not specified.
*
* @param t the type of the array elements.
*/
public ArrayMemberValue(MemberValue t, ConstPool cp) {
super('[', cp);
type = t;
values = null;
}
@Override
Object getValue(ClassLoader cl, ClassPool cp, Method method)
throws ClassNotFoundException
{
if (values == null)
throw new ClassNotFoundException(
"no array elements found: " + method.getName());
int size = values.length;
Class<?> clazz;
if (type == null) {
clazz = method.getReturnType().getComponentType();
if (clazz == null || size > 0)
throw new ClassNotFoundException("broken array type: "
+ method.getName());
}
else
clazz = type.getType(cl);
Object a = Array.newInstance(clazz, size);
for (int i = 0; i < size; i++)
Array.set(a, i, values[i].getValue(cl, cp, method));
return a;
}
@Override
Class<?> getType(ClassLoader cl) throws ClassNotFoundException {
if (type == null)
throw new ClassNotFoundException("no array type specified");
Object a = Array.newInstance(type.getType(cl), 0);
return a.getClass();
}
@Override
public void renameClass(String oldname, String newname) {
if (type != null) {
type.renameClass(oldname, newname);
}
if (values != null) {
for (MemberValue value : values) {
value.renameClass(oldname, newname);
}
}
}
@Override
public void renameClass(Map<String, String> classnames) {
if (type != null) {
type.renameClass(classnames);
}
if (values != null) {
for (MemberValue value : values) {
value.renameClass(classnames);
}
}
}
/**
* Obtains the type of the elements.
*
* @return null if the type is not specified.
*/
public MemberValue getType() {
return type;
}
/**
* Obtains the elements of the array.
*/
public MemberValue[] getValue() {
return values;
}
/**
* Sets the elements of the array.
*/
public void setValue(MemberValue[] elements) {
values = elements;
if (elements != null && elements.length > 0)
type = elements[0];
}
/**
* Obtains the string representation of this object.
*/
@Override
public String toString() {
StringBuffer buf = new StringBuffer("{");
if (values != null) {
for (int i = 0; i < values.length; i++) {
buf.append(values[i].toString());
if (i + 1 < values.length)
buf.append(", ");
}
}
buf.append("}");
return buf.toString();
}
/**
* Writes the value.
*/
@Override
public void write(AnnotationsWriter writer) throws IOException {
int num = values == null ? 0 : values.length;
writer.arrayValue(num);
for (int i = 0; i < num; ++i)
values[i].write(writer);
}
/**
* Accepts a visitor.
*/
@Override
public void accept(MemberValueVisitor visitor) {
visitor.visitArrayMemberValue(this);
}
}
|
