1 17 18 package org.sape.carbon.core.util.reflection; 19 20 import java.util.ArrayList ; 21 import java.util.Collections ; 22 import java.util.HashMap ; 23 import java.util.List ; 24 import java.util.Map ; 25 26 27 38 public class ClassTree { 39 40 protected ClassTreeNode bottom; 41 42 43 50 public ClassTree(Class specificClass) { 51 this.bottom = ClassTreeNode.buildNode(specificClass); 52 53 } 54 55 public ClassTreeNode getBottom() { 56 return this.bottom; 57 } 58 59 60 66 public List getOrderedList() { 67 List list = new ArrayList (); 68 list.add(getBottom()); 69 70 buildList(getBottom(),list); 71 72 Collections.sort(list); 73 74 for (int i = 0; i < list.size(); i++) { 76 ClassTreeNode node = (ClassTreeNode) list.get(i); 77 list.set(i,node.getObjectClass()); 78 } 79 80 Collections.reverse(list); 82 83 return list; 84 } 85 86 102 private void buildList(ClassTreeNode node, List output) { 103 104 for (int i = 0; i < node.getParents().size(); i++) { 105 ClassTreeNode parent = (ClassTreeNode) node.getParents().get(i); 106 if (!output.contains(parent)) { 107 output.add(parent); 108 } 109 } 110 111 List parents = node.getParents(); 112 for (int i = 0; i < parents.size(); i++) { 113 ClassTreeNode parent = (ClassTreeNode) parents.get(i); 114 buildList(parent, output); 115 } 116 } 117 118 119 120 125 public static class ClassTreeNode implements Comparable { 126 127 protected Class objectClass; 128 129 130 protected List children; 131 132 133 protected List parents; 134 135 140 public ClassTreeNode(Class objectClass) { 141 this.children = new ArrayList (); 142 this.objectClass = objectClass; 143 this.parents = new ArrayList (); 144 145 146 } 147 148 public static ClassTreeNode buildNode(Class objectClass) { 149 Map allNodes = new HashMap (); 150 return buildNode(objectClass, allNodes); 151 } 152 153 protected static ClassTreeNode buildNode(Class objectClass, Map allNodes) { 154 ClassTreeNode node; 155 if (allNodes.containsKey(objectClass)) { 156 node = (ClassTreeNode) allNodes.get(objectClass); 157 } else { 158 node = new ClassTreeNode(objectClass); 159 allNodes.put(objectClass, node); 160 } 161 162 Class [] superInterfaces = objectClass.getInterfaces(); 164 for (int i = 0; i < superInterfaces.length; i++) { 165 Class superInterface = superInterfaces[i]; 166 ClassTreeNode parent = buildNode(superInterface); 167 node.addParent(parent); 168 } 169 170 Class superClass = objectClass.getSuperclass(); 172 if (superClass != null) { 173 ClassTreeNode parent = buildNode(superClass); 174 node.addParent(parent); 175 } 176 return node; 177 } 178 179 180 public List getParents() { 181 return this.parents; 182 } 183 184 public void addParent(ClassTreeNode node) { 185 this.parents.add(node); 186 node.addChild(this); 187 } 188 189 public boolean removeChild(ClassTreeNode node) { 190 return this.children.remove(node); 191 } 192 public void addChild(ClassTreeNode node) { 193 this.children.add(node); 194 } 195 196 public List getChildren() { 197 return this.children; 198 } 199 200 public boolean equals(Object obj) { 201 return ((ClassTreeNode)obj).getObjectClass().equals(this.objectClass); 202 } 203 204 public Class getObjectClass() { 205 return this.objectClass; 206 } 207 208 public String getClassName() { 209 return this.objectClass.getName(); 210 } 211 212 213 public int hashCode() { 214 return this.objectClass.hashCode(); 215 } 216 217 226 public int compareTo(Object obj) { 227 Class objClass = ((ClassTreeNode)obj).getObjectClass(); 228 229 if (objClass.equals(this.objectClass)) { 230 return 0; 231 } else if (this.objectClass.isAssignableFrom(objClass)) { 232 return 2; 233 } else if (objClass.isAssignableFrom(this.objectClass)) { 234 return -2; 235 } else { 236 return 0; 237 } 238 } 239 } 241 242 } 243 244 | Popular Tags |