Mercurial > hg > graal-compiler

comparison agent/src/share/classes/sun/jvm/hotspot/jdi/InterfaceTypeImpl.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-2004 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.InstanceKlass;
29
30 import java.util.List;
31 import java.util.ArrayList;
32 import java.util.Map;
33 import java.util.Iterator;
34 import java.util.Collections;
35 import java.lang.ref.SoftReference;
36
37 public class InterfaceTypeImpl extends ReferenceTypeImpl
38 implements InterfaceType {
39 private SoftReference superInterfacesCache = null;
40 private SoftReference subInterfacesCache = null;
41 private SoftReference implementorsCache = null;
42
43 protected InterfaceTypeImpl(VirtualMachine aVm, InstanceKlass aRef) {
44 super(aVm, aRef);
45 }
46
47 public List superinterfaces() throws ClassNotPreparedException {
48 List superinterfaces = (superInterfacesCache != null)? (List) superInterfacesCache.get() : null;
49 if (superinterfaces == null) {
50 checkPrepared();
51 superinterfaces = Collections.unmodifiableList(getInterfaces());
52 superInterfacesCache = new SoftReference(superinterfaces);
53 }
54 return superinterfaces;
55 }
56
57 public List subinterfaces() {
58 List subinterfaces = (subInterfacesCache != null)? (List) subInterfacesCache.get() : null;
59 if (subinterfaces == null) {
60 List all = vm.allClasses();
61 subinterfaces = new ArrayList();
62 Iterator iter = all.iterator();
63 while (iter.hasNext()) {
64 ReferenceType refType = (ReferenceType)iter.next();
65 if (refType instanceof InterfaceType) {
66 InterfaceType interfaze = (InterfaceType)refType;
67 if (interfaze.isPrepared() && interfaze.superinterfaces().contains(this)) {
68 subinterfaces.add(interfaze);
69 }
70 }
71 }
72 subinterfaces = Collections.unmodifiableList(subinterfaces);
73 subInterfacesCache = new SoftReference(subinterfaces);
74 }
75 return subinterfaces;
76 }
77
78 public List implementors() {
79 List implementors = (implementorsCache != null)? (List) implementorsCache.get() : null;
80 if (implementors == null) {
81 List all = vm.allClasses();
82 implementors = new ArrayList();
83 Iterator iter = all.iterator();
84 while (iter.hasNext()) {
85 ReferenceType refType = (ReferenceType)iter.next();
86 if (refType instanceof ClassType) {
87 ClassType clazz = (ClassType)refType;
88 if (clazz.isPrepared() && clazz.interfaces().contains(this)) {
89 implementors.add(clazz);
90 }
91 }
92 }
93 implementors = Collections.unmodifiableList(implementors);
94 implementorsCache = new SoftReference(implementors);
95 }
96 return implementors;
97 }
98
99 void addVisibleMethods(Map methodMap) {
100 /*
101 * Add methods from
102 * parent types first, so that the methods in this class will
103 * overwrite them in the hash table
104 */
105 Iterator iter = superinterfaces().iterator();
106 while (iter.hasNext()) {
107 InterfaceTypeImpl interfaze = (InterfaceTypeImpl)iter.next();
108 interfaze.addVisibleMethods(methodMap);
109 }
110
111 addToMethodMap(methodMap, methods());
112 }
113
114 List getAllMethods() {
115 ArrayList list = new ArrayList(methods());
116 /*
117 * It's more efficient if don't do this
118 * recursively.
119 */
120 List interfaces = allSuperinterfaces();
121 Iterator iter = interfaces.iterator();
122 while (iter.hasNext()) {
123 InterfaceType interfaze = (InterfaceType)iter.next();
124 list.addAll(interfaze.methods());
125 }
126
127 return list;
128 }
129
130 List allSuperinterfaces() {
131 ArrayList list = new ArrayList();
132 addSuperinterfaces(list);
133 return list;
134 }
135
136 void addSuperinterfaces(List list) {
137 /*
138 * This code is a little strange because it
139 * builds the list with a more suitable order than the
140 * depth-first approach a normal recursive solution would
141 * take. Instead, all direct superinterfaces precede all
142 * indirect ones.
143 */
144
145 /*
146 * Get a list of direct superinterfaces that's not already in the
147 * list being built.
148 */
149 List immediate = new ArrayList(superinterfaces());
150 Iterator iter = immediate.iterator();
151 while (iter.hasNext()) {
152 InterfaceType interfaze = (InterfaceType)iter.next();
153 if (list.contains(interfaze)) {
154 iter.remove();
155 }
156 }
157
158 /*
159 * Add all new direct superinterfaces
160 */
161 list.addAll(immediate);
162
163 /*
164 * Recurse for all new direct superinterfaces.
165 */
166 iter = immediate.iterator();
167 while (iter.hasNext()) {
168 InterfaceTypeImpl interfaze = (InterfaceTypeImpl)iter.next();
169 interfaze.addSuperinterfaces(list);
170 }
171 }
172
173 boolean isAssignableTo(ReferenceType type) {
174
175 // Exact match?
176 if (this.equals(type)) {
177 return true;
178 } else {
179 // Try superinterfaces.
180 List supers = superinterfaces();
181 Iterator iter = supers.iterator();
182 while (iter.hasNext()) {
183 InterfaceTypeImpl interfaze = (InterfaceTypeImpl)iter.next();
184 if (interfaze.isAssignableTo(type)) {
185 return true;
186 }
187 }
188
189 return false;
190 }
191 }
192
193 List inheritedTypes() {
194 return superinterfaces();
195 }
196
197 public boolean isInitialized() {
198 return isPrepared();
199 }
200
201 public String toString() {
202 return "interface " + name() + " (" + loaderString() + ")";
203 }
204 }