View Javadoc
1 package net.sourceforge.pmd.swingui; 2 3 import net.sourceforge.pmd.PMDException; 4 import net.sourceforge.pmd.Rule; 5 import net.sourceforge.pmd.RuleProperties; 6 import net.sourceforge.pmd.RuleSet; 7 import net.sourceforge.pmd.swingui.event.ListenerList; 8 import net.sourceforge.pmd.swingui.event.PMDDirectoryRequestEvent; 9 import net.sourceforge.pmd.swingui.event.PMDDirectoryReturnedEvent; 10 import net.sourceforge.pmd.swingui.event.PMDDirectoryReturnedEventListener; 11 import net.sourceforge.pmd.swingui.event.RulesTreeModelEvent; 12 import net.sourceforge.pmd.swingui.event.RulesTreeModelEventListener; 13 14 import javax.swing.tree.DefaultTreeModel; 15 import java.util.ArrayList; 16 import java.util.Arrays; 17 import java.util.Comparator; 18 import java.util.Enumeration; 19 import java.util.List; 20 import java.util.Set; 21 22 /*** 23 * 24 * @author Donald A. Leckie 25 * @since December 13, 2002 26 * @version $Revision: 1.7 $, $Date: 2003/03/14 19:04:11 $ 27 */ 28 class RulesTreeModel extends DefaultTreeModel { 29 30 private PMDDirectoryReturnedEventHandler m_pmdDirectoryReturnedEventHandler; 31 private RulesTreeModelEventHandler m_rulesTreeModelEventHandler; 32 private static RulesTreeModel m_rulesTreeModel; 33 34 /*** 35 **************************************************************************** 36 * 37 * @param rootNode 38 */ 39 private RulesTreeModel(RulesTreeNode rootNode) { 40 super(rootNode); 41 42 m_pmdDirectoryReturnedEventHandler = new PMDDirectoryReturnedEventHandler(); 43 m_rulesTreeModelEventHandler = new RulesTreeModelEventHandler(); 44 ListenerList.addListener((PMDDirectoryReturnedEventListener) m_pmdDirectoryReturnedEventHandler); 45 } 46 47 /*** 48 *************************************************************************** 49 * 50 * @param ruleSetName 51 * 52 * @return 53 */ 54 protected RulesTreeNode getRuleSetNode(String ruleSetName) { 55 if (ruleSetName != null) { 56 RulesTreeNode rootNode = (RulesTreeNode) getRoot(); 57 Enumeration ruleSetNodes = rootNode.children(); 58 59 while (ruleSetNodes.hasMoreElements()) { 60 RulesTreeNode ruleSetNode = (RulesTreeNode) ruleSetNodes.nextElement(); 61 62 if (ruleSetNode.getName().equalsIgnoreCase(ruleSetName)) { 63 return ruleSetNode; 64 } 65 } 66 } 67 68 return null; 69 } 70 71 /*** 72 *************************************************************************** 73 * 74 * @param ruleSetName 75 * @param ruleName 76 * 77 * @return 78 */ 79 protected RulesTreeNode getRuleNode(String ruleSetName, String ruleName) { 80 if ((ruleSetName != null) && (ruleName != null)) { 81 RulesTreeNode rootNode = (RulesTreeNode) getRoot(); 82 Enumeration ruleSetNodes = rootNode.children(); 83 84 while (ruleSetNodes.hasMoreElements()) { 85 RulesTreeNode ruleSetNode = (RulesTreeNode) ruleSetNodes.nextElement(); 86 87 if (ruleSetNode.getName().equalsIgnoreCase(ruleSetName)) { 88 Enumeration ruleNodes = ruleSetNode.children(); 89 90 while (ruleNodes.hasMoreElements()) { 91 RulesTreeNode ruleNode = (RulesTreeNode) ruleNodes.nextElement(); 92 93 if (ruleNode.getName().equalsIgnoreCase(ruleName)) { 94 return ruleNode; 95 } 96 } 97 } 98 } 99 } 100 101 return null; 102 } 103 104 /*** 105 *************************************************************************** 106 * @return 107 */ 108 protected static final RulesTreeModel get() throws PMDException { 109 if (m_rulesTreeModel == null) { 110 RulesTreeNode rootNode; 111 112 rootNode = new RulesTreeNode("Rules"); 113 m_rulesTreeModel = new RulesTreeModel(rootNode); 114 m_rulesTreeModel.buildTree(); 115 } 116 117 return m_rulesTreeModel; 118 } 119 120 /*** 121 ******************************************************************************* 122 * 123 */ 124 private void buildTree() throws PMDException { 125 RuleSet[] ruleSets; 126 RulesTreeNode rootNode; 127 128 ruleSets = loadRuleSets(); 129 rootNode = (RulesTreeNode) getRoot(); 130 131 for (int n1 = 0; n1 < ruleSets.length; n1++) { 132 RulesTreeNode ruleSetNode = new RulesTreeNode(ruleSets[n1]); 133 134 rootNode.add(ruleSetNode); 135 loadRuleTreeNodes(ruleSetNode); 136 } 137 138 } 139 140 /*** 141 ******************************************************************************* 142 * 143 * @return 144 */ 145 private RuleSet[] loadRuleSets() throws PMDException { 146 PMDDirectoryRequestEvent.notifyRequestAllRuleSets(this); 147 148 // The event is processed. The requested rule set is assembled by another class 149 // that calls notifyReturnedAllRuleSets. The list of rule sets is stored in the 150 // inner class PMDDirectoryReturnedEventHandler. Then processing will then continue here. 151 // 152 153 List ruleSetList = m_pmdDirectoryReturnedEventHandler.getRuleSetList(); 154 155 if (ruleSetList == null) { 156 ruleSetList = new ArrayList(); 157 } 158 159 // 160 // Sort the rule sets by name in ascending order. 161 // 162 RuleSet[] ruleSets = new RuleSet[ruleSetList.size()]; 163 164 ruleSetList.toArray(ruleSets); 165 Arrays.sort(ruleSets, new RuleSetNameComparator()); 166 167 return ruleSets; 168 } 169 170 /*** 171 ******************************************************************************* 172 * 173 * @param ruleSetNode 174 */ 175 private void loadRuleTreeNodes(RulesTreeNode ruleSetNode) { 176 RuleSet ruleSet; 177 Set setOfRules; 178 Rule[] rules; 179 180 ruleSet = ruleSetNode.getRuleSet(); 181 setOfRules = ruleSet.getRules(); 182 rules = new Rule[setOfRules.size()]; 183 184 setOfRules.toArray(rules); 185 Arrays.sort(rules, new RuleNameComparator()); 186 187 for (int n = 0; n < rules.length; n++) { 188 RulesTreeNode ruleNode = new RulesTreeNode(ruleSetNode, rules[n]); 189 190 ruleSetNode.add(ruleNode); 191 loadProperties(ruleNode); 192 193 rules[n] = null; 194 } 195 } 196 197 /*** 198 ******************************************************************************* 199 * 200 * @param ruleNode 201 */ 202 private void loadProperties(RulesTreeNode ruleNode) { 203 Rule rule; 204 RuleProperties properties; 205 String[] propertyNames; 206 Enumeration keys; 207 int index; 208 209 rule = ruleNode.getRule(); 210 properties = rule.getProperties(); 211 propertyNames = new String[properties.size()]; 212 keys = properties.keys(); 213 index = 0; 214 215 while (keys.hasMoreElements()) { 216 propertyNames[index] = (String) keys.nextElement(); 217 index++; 218 } 219 220 Arrays.sort(propertyNames, new PropertyNameComparator()); 221 222 for (int n = 0; n < propertyNames.length; n++) { 223 String propertyName; 224 String propertyValue; 225 String propertyValueType; 226 RulesTreeNode propertyNode; 227 228 propertyName = propertyNames[n]; 229 propertyValue = properties.getValue(propertyName); 230 propertyValueType = properties.getValueType(propertyName); 231 propertyNode = new RulesTreeNode(ruleNode, propertyName, propertyValue, propertyValueType); 232 233 ruleNode.add(propertyNode); 234 235 propertyNames[n] = null; 236 } 237 } 238 239 /*** 240 **************************************************************************** 241 **************************************************************************** 242 **************************************************************************** 243 */ 244 private class RulesTreeModelEventHandler implements RulesTreeModelEventListener { 245 246 /*** 247 *********************************************************************** 248 * 249 */ 250 private RulesTreeModelEventHandler() { 251 ListenerList.addListener((RulesTreeModelEventListener) this); 252 } 253 254 /*** 255 ************************************************************************ 256 * 257 * @param parentNode 258 */ 259 public void reload(RulesTreeModelEvent event) { 260 RulesTreeNode parentNode = event.getParentNode(); 261 RulesTreeModel.this.reload(parentNode); 262 } 263 264 /*** 265 **************************************************************************** 266 * 267 * @param event 268 */ 269 public void requestSelectedRule(RulesTreeModelEvent event) { 270 } 271 272 /*** 273 **************************************************************************** 274 * 275 * @param event 276 */ 277 public void returnedSelectedRule(RulesTreeModelEvent event) { 278 } 279 } 280 281 /*** 282 ******************************************************************************* 283 ******************************************************************************* 284 ******************************************************************************* 285 */ 286 private class PropertyNameComparator implements Comparator { 287 288 /*** 289 ************************************************************************ 290 * 291 * @param objectA 292 * @param objectB 293 * 294 * @return 295 */ 296 public int compare(Object objectA, Object objectB) { 297 String propertyNameA = (String) objectA; 298 String propertyNameB = (String) objectB; 299 300 return propertyNameA.compareToIgnoreCase(propertyNameB); 301 } 302 } 303 304 /*** 305 ******************************************************************************* 306 ******************************************************************************* 307 ******************************************************************************* 308 */ 309 private class RuleSetNameComparator implements Comparator { 310 311 /*** 312 ************************************************************************ 313 * 314 * @param objectA 315 * @param objectB 316 * 317 * @return 318 */ 319 public int compare(Object objectA, Object objectB) { 320 String ruleSetNameA = ((RuleSet) objectA).getName(); 321 String ruleSetNameB = ((RuleSet) objectB).getName(); 322 323 return ruleSetNameA.compareToIgnoreCase(ruleSetNameB); 324 } 325 } 326 327 /*** 328 ******************************************************************************* 329 ******************************************************************************* 330 ******************************************************************************* 331 */ 332 private class RuleNameComparator implements Comparator { 333 334 /*** 335 ************************************************************************ 336 * 337 * @param objectA 338 * @param objectB 339 * 340 * @return 341 */ 342 public int compare(Object objectA, Object objectB) { 343 String ruleNameA = ((Rule) objectA).getName(); 344 String ruleNameB = ((Rule) objectB).getName(); 345 346 return ruleNameA.compareToIgnoreCase(ruleNameB); 347 } 348 } 349 350 /*** 351 ******************************************************************************* 352 ******************************************************************************* 353 ******************************************************************************* 354 */ 355 private class PMDDirectoryReturnedEventHandler implements PMDDirectoryReturnedEventListener { 356 357 private List m_ruleSetList; 358 private String m_ruleSetPath; 359 360 /*** 361 *************************************************************************** 362 */ 363 private String getRuleSetPath() { 364 return m_ruleSetPath; 365 } 366 367 /*** 368 *************************************************************************** 369 */ 370 private List getRuleSetList() { 371 return m_ruleSetList; 372 } 373 374 /*** 375 *************************************************************************** 376 * 377 * @param event 378 */ 379 public void returnedRuleSetPath(PMDDirectoryReturnedEvent event) { 380 m_ruleSetPath = event.getRuleSetPath(); 381 } 382 383 /*** 384 *************************************************************************** 385 * 386 * @param event 387 */ 388 public void returnedAllRuleSets(PMDDirectoryReturnedEvent event) { 389 m_ruleSetList = event.getRuleSetList(); 390 } 391 392 /*** 393 *************************************************************************** 394 * 395 * @param event 396 */ 397 public void returnedDefaultRuleSets(PMDDirectoryReturnedEvent event) { 398 m_ruleSetList = event.getRuleSetList(); 399 } 400 401 /*** 402 *************************************************************************** 403 * 404 * @param event 405 */ 406 public void returnedIncludedRules(PMDDirectoryReturnedEvent event) { 407 m_ruleSetList = event.getRuleSetList(); 408 } 409 } 410 }

This page was automatically generated by Maven