Mercurial > hg > truffle

comparison agent/src/share/classes/sun/jvm/hotspot/jdi/ClassTypeImpl.java @ 0:a61af66fc99e jdk7-b24

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial load
author duke
date Sat, 01 Dec 2007 00:00:00 +0000
parents
children c18cbe5936b8
comparison
equal deleted inserted replaced
-1:000000000000 0:a61af66fc99e
1 /*
2 * Copyright 2002-2007 Sun Microsystems, Inc. All Rights Reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
24
25 package sun.jvm.hotspot.jdi;
26
27 import com.sun.jdi.*;
28 import sun.jvm.hotspot.oops.Klass;
29 import sun.jvm.hotspot.oops.InstanceKlass;
30
31 import java.util.*;
32 import java.lang.ref.SoftReference;
33
34 public class ClassTypeImpl extends ReferenceTypeImpl
35 implements ClassType
36 {
37 private SoftReference interfacesCache = null;
38 private SoftReference allInterfacesCache = null;
39 private SoftReference subclassesCache = null;
40
41 protected ClassTypeImpl(VirtualMachine aVm, InstanceKlass aRef) {
42 super(aVm, aRef);
43 }
44
45 public ClassType superclass() {
46 InstanceKlass kk = (InstanceKlass)ref().getSuper();
47 if (kk == null) {
48 return null;
49 }
50 return (ClassType) vm.referenceType(kk);
51 }
52
53 public List interfaces() {
54 List interfaces = (interfacesCache != null)? (List) interfacesCache.get() : null;
55 if (interfaces == null) {
56 checkPrepared();
57 interfaces = Collections.unmodifiableList(getInterfaces());
58 interfacesCache = new SoftReference(interfaces);
59 }
60 return interfaces;
61 }
62
63 void addInterfaces(List list) {
64 List immediate = interfaces();
65
66 HashSet hashList = new HashSet(list);
67 hashList.addAll(immediate);
68 list.clear();
69 list.addAll(hashList);
70
71 Iterator iter = immediate.iterator();
72 while (iter.hasNext()) {
73 InterfaceTypeImpl interfaze = (InterfaceTypeImpl)iter.next();
74 interfaze.addSuperinterfaces(list);
75 }
76
77 ClassTypeImpl superclass = (ClassTypeImpl)superclass();
78 if (superclass != null) {
79 superclass.addInterfaces(list);
80 }
81 }
82
83 public List allInterfaces() {
84 List allinterfaces = (allInterfacesCache != null)? (List) allInterfacesCache.get() : null;
85 if (allinterfaces == null) {
86 checkPrepared();
87 allinterfaces = new ArrayList();
88 addInterfaces(allinterfaces);
89 allinterfaces = Collections.unmodifiableList(allinterfaces);
90 allInterfacesCache = new SoftReference(allinterfaces);
91 }
92 return allinterfaces;
93 }
94
95 public List subclasses() {
96 List subclasses = (subclassesCache != null)? (List) subclassesCache.get() : null;
97 if (subclasses == null) {
98 List all = vm.allClasses();
99 subclasses = new ArrayList(0);
100 Iterator iter = all.iterator();
101 while (iter.hasNext()) {
102 ReferenceType refType = (ReferenceType)iter.next();
103 if (refType instanceof ClassType) {
104 ClassType clazz = (ClassType)refType;
105 ClassType superclass = clazz.superclass();
106 if ((superclass != null) && superclass.equals(this)) {
107 subclasses.add(refType);
108 }
109 }
110 }
111 subclasses = Collections.unmodifiableList(subclasses);
112 subclassesCache = new SoftReference(subclasses);
113 }
114 return subclasses;
115 }
116
117 public Method concreteMethodByName(String name, String signature) {
118 checkPrepared();
119 List methods = visibleMethods();
120 Method method = null;
121 Iterator iter = methods.iterator();
122 while (iter.hasNext()) {
123 Method candidate = (Method)iter.next();
124 if (candidate.name().equals(name) &&
125 candidate.signature().equals(signature) &&
126 !candidate.isAbstract()) {
127
128 method = candidate;
129 break;
130 }
131 }
132 return method;
133 }
134
135 List getAllMethods() {
136 ArrayList list = new ArrayList(methods());
137 ClassType clazz = superclass();
138 while (clazz != null) {
139 list.addAll(clazz.methods());
140 clazz = clazz.superclass();
141 }
142 /*
143 * Avoid duplicate checking on each method by iterating through
144 * duplicate-free allInterfaces() rather than recursing
145 */
146 Iterator iter = allInterfaces().iterator();
147 while (iter.hasNext()) {
148 InterfaceType interfaze = (InterfaceType)iter.next();
149 list.addAll(interfaze.methods());
150 }
151 return list;
152 }
153
154 List inheritedTypes() {
155 List inherited = new ArrayList(interfaces());
156 if (superclass() != null) {
157 inherited.add(0, superclass()); /* insert at front */
158 }
159 return inherited;
160 }
161
162 public boolean isEnum() {
163 ClassTypeImpl superclass = (ClassTypeImpl) superclass();
164 if (superclass != null) {
165 return superclass.typeNameAsSymbol().equals(vm.javaLangEnum());
166 } else {
167 return false;
168 }
169 }
170
171 public void setValue(Field field, Value value)
172 throws InvalidTypeException, ClassNotLoadedException {
173 vm.throwNotReadOnlyException("ClassType.setValue(...)");
174 }
175
176
177 public Value invokeMethod(ThreadReference threadIntf, Method methodIntf,
178 List arguments, int options)
179 throws InvalidTypeException,
180 ClassNotLoadedException,
181 IncompatibleThreadStateException,
182 InvocationException {
183 vm.throwNotReadOnlyException("ClassType.invokeMethod(...)");
184 return null;
185 }
186
187 public ObjectReference newInstance(ThreadReference threadIntf,
188 Method methodIntf,
189 List arguments, int options)
190 throws InvalidTypeException,
191 ClassNotLoadedException,
192 IncompatibleThreadStateException,
193 InvocationException {
194 vm.throwNotReadOnlyException("ClassType.newInstance(...)");
195 return null;
196 }
197
198 void addVisibleMethods(Map methodMap) {
199 /*
200 * Add methods from
201 * parent types first, so that the methods in this class will
202 * overwrite them in the hash table
203 */
204
205 Iterator iter = interfaces().iterator();
206 while (iter.hasNext()) {
207 InterfaceTypeImpl interfaze = (InterfaceTypeImpl)iter.next();
208 interfaze.addVisibleMethods(methodMap);
209 }
210
211 ClassTypeImpl clazz = (ClassTypeImpl)superclass();
212 if (clazz != null) {
213 clazz.addVisibleMethods(methodMap);
214 }
215
216 addToMethodMap(methodMap, methods());
217 }
218
219 boolean isAssignableTo(ReferenceType type) {
220 ClassTypeImpl superclazz = (ClassTypeImpl)superclass();
221 if (this.equals(type)) {
222 return true;
223 } else if ((superclazz != null) && superclazz.isAssignableTo(type)) {
224 return true;
225 } else {
226 List interfaces = interfaces();
227 Iterator iter = interfaces.iterator();
228 while (iter.hasNext()) {
229 InterfaceTypeImpl interfaze = (InterfaceTypeImpl)iter.next();
230 if (interfaze.isAssignableTo(type)) {
231 return true;
232 }
233 }
234 return false;
235 }
236 }
237
238 public String toString() {
239 return "class " + name() + "(" + loaderString() + ")";
240 }
241 }