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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
|
/*
* Javassist, a Java-bytecode translator toolkit.
* Copyright (C) 1999-2007 Shigeru Chiba. 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.
*
* 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;
/**
* An instance of <code>CtMember</code> represents a field, a constructor,
* or a method.
*/
public abstract class CtMember {
protected CtMember next; // for internal use
protected CtClass declaringClass;
protected CtMember(CtClass clazz) { declaringClass = clazz; }
static CtMember append(CtMember list, CtMember previousTail, CtMember tail) {
tail.next = null;
if (list == null)
return tail;
else {
previousTail.next = tail;
return list;
}
}
static CtMember append(CtMember list, CtMember tail) {
tail.next = null;
if (list == null)
return tail;
else {
CtMember lst = list;
while (lst.next != null)
lst = lst.next;
lst.next = tail;
return list;
}
}
static int count(CtMember f) {
int n = 0;
while (f != null) {
++n;
f = f.next;
}
return n;
}
static CtMember remove(CtMember list, CtMember m) {
CtMember top = list;
if (list == null)
return null;
else if (list == m)
return list.next;
else
while (list.next != null) {
if (list.next == m) {
list.next = list.next.next;
break;
}
list = list.next;
}
return top;
}
public String toString() {
StringBuffer buffer = new StringBuffer(getClass().getName());
buffer.append("@");
buffer.append(Integer.toHexString(hashCode()));
buffer.append("[");
buffer.append(Modifier.toString(getModifiers()));
extendToString(buffer);
buffer.append("]");
return buffer.toString();
}
/**
* Invoked by {@link #toString()} to add to the buffer and provide the
* complete value. Subclasses should invoke this method, adding a
* space before each token. The modifiers for the member are
* provided first; subclasses should provide additional data such
* as return type, field or method name, etc.
*/
protected abstract void extendToString(StringBuffer buffer);
/**
* Returns the class that declares this member.
*/
public CtClass getDeclaringClass() { return declaringClass; }
/**
* Returns true if this member is accessible from the given class.
*/
public boolean visibleFrom(CtClass clazz) {
int mod = getModifiers();
if (Modifier.isPublic(mod))
return true;
else if (Modifier.isPrivate(mod))
return clazz == declaringClass;
else { // package or protected
String declName = declaringClass.getPackageName();
String fromName = clazz.getPackageName();
boolean visible;
if (declName == null)
visible = fromName == null;
else
visible = declName.equals(fromName);
if (!visible && Modifier.isProtected(mod))
return clazz.subclassOf(declaringClass);
return visible;
}
}
/**
* Obtains the modifiers of the member.
*
* @return modifiers encoded with
* <code>javassist.Modifier</code>.
* @see Modifier
*/
public abstract int getModifiers();
/**
* Sets the encoded modifiers of the member.
*
* @see Modifier
*/
public abstract void setModifiers(int mod);
/**
* Returns the annotations associated with this member.
* For example, if an annotation <code>@Author</code> is associated
* with this member, the returned array contains an <code>Author</code>
* object. The member values can be obtained by calling methods on
* the <code>Author</code> object.
*
* @return an array of annotation-type objects.
* @see CtClass#getAnnotations()
*/
public abstract Object[] getAnnotations() throws ClassNotFoundException;
/**
* Returns the annotations associated with this member.
* This method is equivalent to <code>getAnnotations()</code>
* except that, if any annotations are not on the classpath,
* they are not included in the returned array.
*
* @return an array of annotation-type objects.
* @see #getAnnotations()
* @see CtClass#getAvailableAnnotations()
* @since 3.3
*/
public abstract Object[] getAvailableAnnotations()
throws ClassNotFoundException;
/**
* Obtains the name of the member.
*
* <p>As for constructor names, see <code>getName()</code>
* in <code>CtConstructor</code>.
*
* @see CtConstructor#getName()
*/
public abstract String getName();
/**
* Returns the character string representing the signature of the member.
* If two members have the same signature (parameter types etc.),
* <code>getSignature()</code> returns the same string.
*/
public abstract String getSignature();
/**
* Obtains a user-defined attribute with the given name.
* If that attribute is not found in the class file, this
* method returns null.
*
* <p>Note that an attribute is a data block specified by
* the class file format.
* See {@link javassist.bytecode.AttributeInfo}.
*
* @param name attribute name
*/
public abstract byte[] getAttribute(String name);
/**
* Adds a user-defined attribute. The attribute is saved in the class file.
*
* <p>Note that an attribute is a data block specified by
* the class file format.
* See {@link javassist.bytecode.AttributeInfo}.
*
* @param name attribute name
* @param data attribute value
*/
public abstract void setAttribute(String name, byte[] data);
}
|
