001//////////////////////////////////////////////////////////////////////////////// 002// checkstyle: Checks Java source code for adherence to a set of rules. 003// Copyright (C) 2001-2020 the original author or authors. 004// 005// This library is free software; you can redistribute it and/or 006// modify it under the terms of the GNU Lesser General Public 007// License as published by the Free Software Foundation; either 008// version 2.1 of the License, or (at your option) any later version. 009// 010// This library is distributed in the hope that it will be useful, 011// but WITHOUT ANY WARRANTY; without even the implied warranty of 012// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 013// Lesser General Public License for more details. 014// 015// You should have received a copy of the GNU Lesser General Public 016// License along with this library; if not, write to the Free Software 017// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 018//////////////////////////////////////////////////////////////////////////////// 019 020package com.puppycrawl.tools.checkstyle; 021 022import java.io.IOException; 023import java.util.Collections; 024import java.util.HashMap; 025import java.util.LinkedHashSet; 026import java.util.List; 027import java.util.Map; 028import java.util.Map.Entry; 029import java.util.Set; 030import java.util.stream.Collectors; 031import java.util.stream.Stream; 032 033import com.puppycrawl.tools.checkstyle.api.CheckstyleException; 034import com.puppycrawl.tools.checkstyle.api.LocalizedMessage; 035import com.puppycrawl.tools.checkstyle.utils.ModuleReflectionUtil; 036 037/** 038 * A factory for creating objects from package names and names. 039 * Consider the below example for better understanding. 040 * <ul> 041 * <li>module name - name of java class that represents module;</li> 042 * <li>module full name - fully qualifies name of java class that represents module;</li> 043 * <li>check module short name - name of Check without 'Check' suffix;</li> 044 * <li>check module name - name of java class that represents Check (with 'Check' suffix);</li> 045 * <li> 046 * check module full name - fully qualifies name of java class 047 * that represents Check (with 'Check' suffix). 048 * </li> 049 * </ul> 050 */ 051public class PackageObjectFactory implements ModuleFactory { 052 053 /** 054 * Enum class to define loading options. 055 */ 056 public enum ModuleLoadOption { 057 058 /** 059 * Searching from registered checkstyle modules and from packages given in constructor. 060 **/ 061 SEARCH_REGISTERED_PACKAGES, 062 /** 063 * As SEARCH_REGISTERED_PACKAGES and also try to load class from all of packages given in 064 * constructor. 065 * Required for eclipse-cs plugin. 066 **/ 067 TRY_IN_ALL_REGISTERED_PACKAGES, 068 069 } 070 071 /** Base package of checkstyle modules checks. */ 072 public static final String BASE_PACKAGE = "com.puppycrawl.tools.checkstyle"; 073 074 /** Exception message when it is unable to create a class instance. */ 075 public static final String UNABLE_TO_INSTANTIATE_EXCEPTION_MESSAGE = 076 "PackageObjectFactory.unableToInstantiateExceptionMessage"; 077 078 /** Exception message when there is ambiguous module name in config file. */ 079 public static final String AMBIGUOUS_MODULE_NAME_EXCEPTION_MESSAGE = 080 "PackageObjectFactory.ambiguousModuleNameExceptionMessage"; 081 082 /** Suffix of checks. */ 083 public static final String CHECK_SUFFIX = "Check"; 084 085 /** Character separate package names in qualified name of java class. */ 086 public static final String PACKAGE_SEPARATOR = "."; 087 088 /** Exception message when null class loader is given. */ 089 public static final String NULL_LOADER_MESSAGE = "moduleClassLoader must not be null"; 090 091 /** Exception message when null package name is given. */ 092 public static final String NULL_PACKAGE_MESSAGE = "package name must not be null"; 093 094 /** Separator to use in strings. */ 095 public static final String STRING_SEPARATOR = ", "; 096 097 /** Map of Checkstyle module names to their fully qualified names. */ 098 private static final Map<String, String> NAME_TO_FULL_MODULE_NAME = new HashMap<>(); 099 100 /** A list of package names to prepend to class names. */ 101 private final Set<String> packages; 102 103 /** The class loader used to load Checkstyle core and custom modules. */ 104 private final ClassLoader moduleClassLoader; 105 106 /** Map of third party Checkstyle module names to the set of their fully qualified names. */ 107 private Map<String, Set<String>> thirdPartyNameToFullModuleNames; 108 109 /** Module load option which defines class search type. */ 110 private ModuleLoadOption moduleLoadOption; 111 112 static { 113 fillShortToFullModuleNamesMap(); 114 } 115 116 /** 117 * Creates a new {@code PackageObjectFactory} instance. 118 * @param packageNames the list of package names to use 119 * @param moduleClassLoader class loader used to load Checkstyle 120 * core and custom modules 121 */ 122 public PackageObjectFactory(Set<String> packageNames, ClassLoader moduleClassLoader) { 123 this(packageNames, moduleClassLoader, ModuleLoadOption.SEARCH_REGISTERED_PACKAGES); 124 } 125 126 /** 127 * Creates a new {@code PackageObjectFactory} instance. 128 * @param packageNames the list of package names to use 129 * @param moduleClassLoader class loader used to load Checkstyle 130 * core and custom modules 131 * @param moduleLoadOption loading option 132 * @throws IllegalArgumentException if moduleClassLoader is null or packageNames contains null 133 */ 134 public PackageObjectFactory(Set<String> packageNames, ClassLoader moduleClassLoader, 135 ModuleLoadOption moduleLoadOption) { 136 if (moduleClassLoader == null) { 137 throw new IllegalArgumentException(NULL_LOADER_MESSAGE); 138 } 139 if (packageNames.contains(null)) { 140 throw new IllegalArgumentException(NULL_PACKAGE_MESSAGE); 141 } 142 143 //create a copy of the given set, but retain ordering 144 packages = new LinkedHashSet<>(packageNames); 145 this.moduleClassLoader = moduleClassLoader; 146 this.moduleLoadOption = moduleLoadOption; 147 } 148 149 /** 150 * Creates a new {@code PackageObjectFactory} instance. 151 * @param packageName The package name to use 152 * @param moduleClassLoader class loader used to load Checkstyle 153 * core and custom modules 154 * @throws IllegalArgumentException if moduleClassLoader is null or packageNames is null 155 */ 156 public PackageObjectFactory(String packageName, ClassLoader moduleClassLoader) { 157 if (moduleClassLoader == null) { 158 throw new IllegalArgumentException(NULL_LOADER_MESSAGE); 159 } 160 if (packageName == null) { 161 throw new IllegalArgumentException(NULL_PACKAGE_MESSAGE); 162 } 163 164 packages = Collections.singleton(packageName); 165 this.moduleClassLoader = moduleClassLoader; 166 } 167 168 /** 169 * Creates a new instance of a class from a given name, or that name 170 * concatenated with "Check". If the name is 171 * a class name, creates an instance of the named class. Otherwise, creates 172 * an instance of a class name obtained by concatenating the given name 173 * to a package name from a given list of package names. 174 * @param name the name of a class. 175 * @return the {@code Object} created by loader. 176 * @throws CheckstyleException if an error occurs. 177 */ 178 @Override 179 public Object createModule(String name) throws CheckstyleException { 180 Object instance = null; 181 // if the name is a simple class name, try to find it in maps at first 182 if (!name.contains(PACKAGE_SEPARATOR)) { 183 instance = createFromStandardCheckSet(name); 184 // find the name in third party map 185 if (instance == null) { 186 if (thirdPartyNameToFullModuleNames == null) { 187 thirdPartyNameToFullModuleNames = 188 generateThirdPartyNameToFullModuleName(moduleClassLoader); 189 } 190 instance = createObjectFromMap(name, thirdPartyNameToFullModuleNames); 191 } 192 } 193 if (instance == null) { 194 instance = createObject(name); 195 } 196 if (instance == null 197 && moduleLoadOption == ModuleLoadOption.TRY_IN_ALL_REGISTERED_PACKAGES) { 198 instance = createModuleByTryInEachPackage(name); 199 } 200 if (instance == null) { 201 String attemptedNames = null; 202 if (!name.contains(PACKAGE_SEPARATOR)) { 203 final String nameCheck = name + CHECK_SUFFIX; 204 attemptedNames = joinPackageNamesWithClassName(name, packages) 205 + STRING_SEPARATOR + nameCheck + STRING_SEPARATOR 206 + joinPackageNamesWithClassName(nameCheck, packages); 207 } 208 final LocalizedMessage exceptionMessage = new LocalizedMessage(1, 209 Definitions.CHECKSTYLE_BUNDLE, UNABLE_TO_INSTANTIATE_EXCEPTION_MESSAGE, 210 new String[] {name, attemptedNames}, null, getClass(), null); 211 throw new CheckstyleException(exceptionMessage.getMessage()); 212 } 213 return instance; 214 } 215 216 /** 217 * Create object from one of Checkstyle module names. 218 * @param name name of module. 219 * @return instance of module. 220 * @throws CheckstyleException if the class fails to instantiate or there are ambiguous classes. 221 */ 222 private Object createFromStandardCheckSet(String name) throws CheckstyleException { 223 final String fullModuleName = NAME_TO_FULL_MODULE_NAME.get(name); 224 Object instance = null; 225 if (fullModuleName == null) { 226 final String fullCheckModuleName = 227 NAME_TO_FULL_MODULE_NAME.get(name + CHECK_SUFFIX); 228 if (fullCheckModuleName != null) { 229 instance = createObject(fullCheckModuleName); 230 } 231 } 232 else { 233 instance = createObject(fullModuleName); 234 } 235 return instance; 236 } 237 238 /** 239 * Create object with the help of the supplied map. 240 * @param name name of module. 241 * @param map the supplied map. 242 * @return instance of module if it is found in modules map and no ambiguous classes exist. 243 * @throws CheckstyleException if the class fails to instantiate or there are ambiguous classes. 244 */ 245 private Object createObjectFromMap(String name, Map<String, Set<String>> map) 246 throws CheckstyleException { 247 final Set<String> fullModuleNames = map.get(name); 248 Object instance = null; 249 if (fullModuleNames == null) { 250 final Set<String> fullCheckModuleNames = map.get(name + CHECK_SUFFIX); 251 if (fullCheckModuleNames != null) { 252 instance = createObjectFromFullModuleNames(name, fullCheckModuleNames); 253 } 254 } 255 else { 256 instance = createObjectFromFullModuleNames(name, fullModuleNames); 257 } 258 return instance; 259 } 260 261 /** 262 * Create Object from optional full module names. 263 * In most case, there should be only one element in {@code fullModuleName}, otherwise 264 * an exception would be thrown. 265 * @param name name of module 266 * @param fullModuleNames the supplied full module names set 267 * @return instance of module if there is only one element in {@code fullModuleName} 268 * @throws CheckstyleException if the class fails to instantiate or there are more than one 269 * element in {@code fullModuleName} 270 */ 271 private Object createObjectFromFullModuleNames(String name, Set<String> fullModuleNames) 272 throws CheckstyleException { 273 final Object returnValue; 274 if (fullModuleNames.size() == 1) { 275 returnValue = createObject(fullModuleNames.iterator().next()); 276 } 277 else { 278 final String optionalNames = fullModuleNames.stream() 279 .sorted() 280 .collect(Collectors.joining(STRING_SEPARATOR)); 281 final LocalizedMessage exceptionMessage = new LocalizedMessage(1, 282 Definitions.CHECKSTYLE_BUNDLE, AMBIGUOUS_MODULE_NAME_EXCEPTION_MESSAGE, 283 new String[] {name, optionalNames}, null, getClass(), null); 284 throw new CheckstyleException(exceptionMessage.getMessage()); 285 } 286 return returnValue; 287 } 288 289 /** 290 * Generate the map of third party Checkstyle module names to the set of their fully qualified 291 * names. 292 * @param loader the class loader used to load Checkstyle package names 293 * @return the map of third party Checkstyle module names to the set of their fully qualified 294 * names 295 */ 296 private Map<String, Set<String>> generateThirdPartyNameToFullModuleName(ClassLoader loader) { 297 Map<String, Set<String>> returnValue; 298 try { 299 returnValue = ModuleReflectionUtil.getCheckstyleModules(packages, loader).stream() 300 .collect(Collectors.groupingBy(Class::getSimpleName, 301 Collectors.mapping(Class::getCanonicalName, Collectors.toSet()))); 302 } 303 catch (IOException ignore) { 304 returnValue = Collections.emptyMap(); 305 } 306 return returnValue; 307 } 308 309 /** 310 * Returns simple check name from full modules names map. 311 * @param fullName name of the class for joining. 312 * @return simple check name. 313 */ 314 public static String getShortFromFullModuleNames(String fullName) { 315 return NAME_TO_FULL_MODULE_NAME 316 .entrySet() 317 .stream() 318 .filter(entry -> entry.getValue().equals(fullName)) 319 .map(Entry::getKey) 320 .findFirst() 321 .orElse(fullName); 322 } 323 324 /** 325 * Creates a string by joining package names with a class name. 326 * @param className name of the class for joining. 327 * @param packages packages names. 328 * @return a string which is obtained by joining package names with a class name. 329 */ 330 private static String joinPackageNamesWithClassName(String className, Set<String> packages) { 331 return packages.stream().collect( 332 Collectors.joining(PACKAGE_SEPARATOR + className + STRING_SEPARATOR, "", 333 PACKAGE_SEPARATOR + className)); 334 } 335 336 /** 337 * Creates a new instance of a named class. 338 * @param className the name of the class to instantiate. 339 * @return the {@code Object} created by loader or null. 340 * @throws CheckstyleException if the class fails to instantiate. 341 */ 342 private Object createObject(String className) throws CheckstyleException { 343 Class<?> clazz = null; 344 345 try { 346 clazz = Class.forName(className, true, moduleClassLoader); 347 } 348 catch (final ReflectiveOperationException | NoClassDefFoundError ignored) { 349 // ignore the exception 350 } 351 352 Object instance = null; 353 354 if (clazz != null) { 355 try { 356 instance = clazz.getDeclaredConstructor().newInstance(); 357 } 358 catch (final ReflectiveOperationException ex) { 359 throw new CheckstyleException("Unable to instantiate " + className, ex); 360 } 361 } 362 363 return instance; 364 } 365 366 /** 367 * Searching to class with given name (or name concatenated with "Check") in existing 368 * packages. Returns instance if class found or, otherwise, null. 369 * @param name the name of a class. 370 * @return the {@code Object} created by loader. 371 * @throws CheckstyleException if an error occurs. 372 */ 373 private Object createModuleByTryInEachPackage(String name) throws CheckstyleException { 374 final List<String> possibleNames = packages.stream() 375 .map(packageName -> packageName + PACKAGE_SEPARATOR + name) 376 .flatMap(className -> Stream.of(className, className + CHECK_SUFFIX)) 377 .collect(Collectors.toList()); 378 Object instance = null; 379 for (String possibleName : possibleNames) { 380 instance = createObject(possibleName); 381 if (instance != null) { 382 break; 383 } 384 } 385 return instance; 386 } 387 388 /** 389 * Fill short-to-full module names map. 390 */ 391 private static void fillShortToFullModuleNamesMap() { 392 fillChecksFromAnnotationPackage(); 393 fillChecksFromBlocksPackage(); 394 fillChecksFromCodingPackage(); 395 fillChecksFromDesignPackage(); 396 fillChecksFromHeaderPackage(); 397 fillChecksFromImportsPackage(); 398 fillChecksFromIndentationPackage(); 399 fillChecksFromJavadocPackage(); 400 fillChecksFromMetricsPackage(); 401 fillChecksFromModifierPackage(); 402 fillChecksFromNamingPackage(); 403 fillChecksFromRegexpPackage(); 404 fillChecksFromSizesPackage(); 405 fillChecksFromWhitespacePackage(); 406 fillModulesFromChecksPackage(); 407 fillModulesFromFilefiltersPackage(); 408 fillModulesFromFiltersPackage(); 409 fillModulesFromCheckstylePackage(); 410 } 411 412 /** 413 * Fill short-to-full module names map with Checks from annotation package. 414 */ 415 private static void fillChecksFromAnnotationPackage() { 416 NAME_TO_FULL_MODULE_NAME.put("AnnotationLocationCheck", 417 BASE_PACKAGE + ".checks.annotation.AnnotationLocationCheck"); 418 NAME_TO_FULL_MODULE_NAME.put("AnnotationOnSameLineCheck", 419 BASE_PACKAGE + ".checks.annotation.AnnotationOnSameLineCheck"); 420 NAME_TO_FULL_MODULE_NAME.put("AnnotationUseStyleCheck", 421 BASE_PACKAGE + ".checks.annotation.AnnotationUseStyleCheck"); 422 NAME_TO_FULL_MODULE_NAME.put("MissingDeprecatedCheck", 423 BASE_PACKAGE + ".checks.annotation.MissingDeprecatedCheck"); 424 NAME_TO_FULL_MODULE_NAME.put("MissingOverrideCheck", 425 BASE_PACKAGE + ".checks.annotation.MissingOverrideCheck"); 426 NAME_TO_FULL_MODULE_NAME.put("PackageAnnotationCheck", 427 BASE_PACKAGE + ".checks.annotation.PackageAnnotationCheck"); 428 NAME_TO_FULL_MODULE_NAME.put("SuppressWarningsCheck", 429 BASE_PACKAGE + ".checks.annotation.SuppressWarningsCheck"); 430 } 431 432 /** 433 * Fill short-to-full module names map with Checks from blocks package. 434 */ 435 private static void fillChecksFromBlocksPackage() { 436 NAME_TO_FULL_MODULE_NAME.put("AvoidNestedBlocksCheck", 437 BASE_PACKAGE + ".checks.blocks.AvoidNestedBlocksCheck"); 438 NAME_TO_FULL_MODULE_NAME.put("EmptyBlockCheck", 439 BASE_PACKAGE + ".checks.blocks.EmptyBlockCheck"); 440 NAME_TO_FULL_MODULE_NAME.put("EmptyCatchBlockCheck", 441 BASE_PACKAGE + ".checks.blocks.EmptyCatchBlockCheck"); 442 NAME_TO_FULL_MODULE_NAME.put("LeftCurlyCheck", 443 BASE_PACKAGE + ".checks.blocks.LeftCurlyCheck"); 444 NAME_TO_FULL_MODULE_NAME.put("NeedBracesCheck", 445 BASE_PACKAGE + ".checks.blocks.NeedBracesCheck"); 446 NAME_TO_FULL_MODULE_NAME.put("RightCurlyCheck", 447 BASE_PACKAGE + ".checks.blocks.RightCurlyCheck"); 448 } 449 450 /** 451 * Fill short-to-full module names map with Checks from coding package. 452 */ 453 // -@cs[ExecutableStatementCount] splitting this method is not reasonable. 454 private static void fillChecksFromCodingPackage() { 455 NAME_TO_FULL_MODULE_NAME.put("ArrayTrailingCommaCheck", 456 BASE_PACKAGE + ".checks.coding.ArrayTrailingCommaCheck"); 457 NAME_TO_FULL_MODULE_NAME.put("AvoidInlineConditionalsCheck", 458 BASE_PACKAGE + ".checks.coding.AvoidInlineConditionalsCheck"); 459 NAME_TO_FULL_MODULE_NAME.put("AvoidNoArgumentSuperConstructorCallCheck", 460 BASE_PACKAGE + ".checks.coding.AvoidNoArgumentSuperConstructorCallCheck"); 461 NAME_TO_FULL_MODULE_NAME.put("CovariantEqualsCheck", 462 BASE_PACKAGE + ".checks.coding.CovariantEqualsCheck"); 463 NAME_TO_FULL_MODULE_NAME.put("DeclarationOrderCheck", 464 BASE_PACKAGE + ".checks.coding.DeclarationOrderCheck"); 465 NAME_TO_FULL_MODULE_NAME.put("DefaultComesLastCheck", 466 BASE_PACKAGE + ".checks.coding.DefaultComesLastCheck"); 467 NAME_TO_FULL_MODULE_NAME.put("EmptyStatementCheck", 468 BASE_PACKAGE + ".checks.coding.EmptyStatementCheck"); 469 NAME_TO_FULL_MODULE_NAME.put("EqualsAvoidNullCheck", 470 BASE_PACKAGE + ".checks.coding.EqualsAvoidNullCheck"); 471 NAME_TO_FULL_MODULE_NAME.put("EqualsHashCodeCheck", 472 BASE_PACKAGE + ".checks.coding.EqualsHashCodeCheck"); 473 NAME_TO_FULL_MODULE_NAME.put("ExplicitInitializationCheck", 474 BASE_PACKAGE + ".checks.coding.ExplicitInitializationCheck"); 475 NAME_TO_FULL_MODULE_NAME.put("FallThroughCheck", 476 BASE_PACKAGE + ".checks.coding.FallThroughCheck"); 477 NAME_TO_FULL_MODULE_NAME.put("FinalLocalVariableCheck", 478 BASE_PACKAGE + ".checks.coding.FinalLocalVariableCheck"); 479 NAME_TO_FULL_MODULE_NAME.put("HiddenFieldCheck", 480 BASE_PACKAGE + ".checks.coding.HiddenFieldCheck"); 481 NAME_TO_FULL_MODULE_NAME.put("IllegalCatchCheck", 482 BASE_PACKAGE + ".checks.coding.IllegalCatchCheck"); 483 NAME_TO_FULL_MODULE_NAME.put("IllegalInstantiationCheck", 484 BASE_PACKAGE + ".checks.coding.IllegalInstantiationCheck"); 485 NAME_TO_FULL_MODULE_NAME.put("IllegalThrowsCheck", 486 BASE_PACKAGE + ".checks.coding.IllegalThrowsCheck"); 487 NAME_TO_FULL_MODULE_NAME.put("IllegalTokenCheck", 488 BASE_PACKAGE + ".checks.coding.IllegalTokenCheck"); 489 NAME_TO_FULL_MODULE_NAME.put("IllegalTokenTextCheck", 490 BASE_PACKAGE + ".checks.coding.IllegalTokenTextCheck"); 491 NAME_TO_FULL_MODULE_NAME.put("IllegalTypeCheck", 492 BASE_PACKAGE + ".checks.coding.IllegalTypeCheck"); 493 NAME_TO_FULL_MODULE_NAME.put("InnerAssignmentCheck", 494 BASE_PACKAGE + ".checks.coding.InnerAssignmentCheck"); 495 NAME_TO_FULL_MODULE_NAME.put("MagicNumberCheck", 496 BASE_PACKAGE + ".checks.coding.MagicNumberCheck"); 497 NAME_TO_FULL_MODULE_NAME.put("MissingCtorCheck", 498 BASE_PACKAGE + ".checks.coding.MissingCtorCheck"); 499 NAME_TO_FULL_MODULE_NAME.put("MissingSwitchDefaultCheck", 500 BASE_PACKAGE + ".checks.coding.MissingSwitchDefaultCheck"); 501 NAME_TO_FULL_MODULE_NAME.put("ModifiedControlVariableCheck", 502 BASE_PACKAGE + ".checks.coding.ModifiedControlVariableCheck"); 503 NAME_TO_FULL_MODULE_NAME.put("MultipleStringLiteralsCheck", 504 BASE_PACKAGE + ".checks.coding.MultipleStringLiteralsCheck"); 505 NAME_TO_FULL_MODULE_NAME.put("MultipleVariableDeclarationsCheck", 506 BASE_PACKAGE + ".checks.coding.MultipleVariableDeclarationsCheck"); 507 NAME_TO_FULL_MODULE_NAME.put("NestedForDepthCheck", 508 BASE_PACKAGE + ".checks.coding.NestedForDepthCheck"); 509 NAME_TO_FULL_MODULE_NAME.put("NestedIfDepthCheck", 510 BASE_PACKAGE + ".checks.coding.NestedIfDepthCheck"); 511 NAME_TO_FULL_MODULE_NAME.put("NestedTryDepthCheck", 512 BASE_PACKAGE + ".checks.coding.NestedTryDepthCheck"); 513 NAME_TO_FULL_MODULE_NAME.put("NoCloneCheck", 514 BASE_PACKAGE + ".checks.coding.NoCloneCheck"); 515 NAME_TO_FULL_MODULE_NAME.put("NoEnumTrailingCommaCheck", 516 BASE_PACKAGE + ".checks.coding.NoEnumTrailingCommaCheck"); 517 NAME_TO_FULL_MODULE_NAME.put("NoFinalizerCheck", 518 BASE_PACKAGE + ".checks.coding.NoFinalizerCheck"); 519 NAME_TO_FULL_MODULE_NAME.put("OneStatementPerLineCheck", 520 BASE_PACKAGE + ".checks.coding.OneStatementPerLineCheck"); 521 NAME_TO_FULL_MODULE_NAME.put("OverloadMethodsDeclarationOrderCheck", 522 BASE_PACKAGE + ".checks.coding.OverloadMethodsDeclarationOrderCheck"); 523 NAME_TO_FULL_MODULE_NAME.put("PackageDeclarationCheck", 524 BASE_PACKAGE + ".checks.coding.PackageDeclarationCheck"); 525 NAME_TO_FULL_MODULE_NAME.put("ParameterAssignmentCheck", 526 BASE_PACKAGE + ".checks.coding.ParameterAssignmentCheck"); 527 NAME_TO_FULL_MODULE_NAME.put("RequireThisCheck", 528 BASE_PACKAGE + ".checks.coding.RequireThisCheck"); 529 NAME_TO_FULL_MODULE_NAME.put("ReturnCountCheck", 530 BASE_PACKAGE + ".checks.coding.ReturnCountCheck"); 531 NAME_TO_FULL_MODULE_NAME.put("SimplifyBooleanExpressionCheck", 532 BASE_PACKAGE + ".checks.coding.SimplifyBooleanExpressionCheck"); 533 NAME_TO_FULL_MODULE_NAME.put("SimplifyBooleanReturnCheck", 534 BASE_PACKAGE + ".checks.coding.SimplifyBooleanReturnCheck"); 535 NAME_TO_FULL_MODULE_NAME.put("StringLiteralEqualityCheck", 536 BASE_PACKAGE + ".checks.coding.StringLiteralEqualityCheck"); 537 NAME_TO_FULL_MODULE_NAME.put("SuperCloneCheck", 538 BASE_PACKAGE + ".checks.coding.SuperCloneCheck"); 539 NAME_TO_FULL_MODULE_NAME.put("SuperFinalizeCheck", 540 BASE_PACKAGE + ".checks.coding.SuperFinalizeCheck"); 541 NAME_TO_FULL_MODULE_NAME.put("UnnecessaryParenthesesCheck", 542 BASE_PACKAGE + ".checks.coding.UnnecessaryParenthesesCheck"); 543 NAME_TO_FULL_MODULE_NAME.put("UnnecessarySemicolonAfterTypeMemberDeclarationCheck", 544 BASE_PACKAGE 545 + ".checks.coding.UnnecessarySemicolonAfterTypeMemberDeclarationCheck"); 546 NAME_TO_FULL_MODULE_NAME.put("UnnecessarySemicolonInEnumerationCheck", 547 BASE_PACKAGE + ".checks.coding.UnnecessarySemicolonInEnumerationCheck"); 548 NAME_TO_FULL_MODULE_NAME.put("UnnecessarySemicolonInTryWithResourcesCheck", 549 BASE_PACKAGE + ".checks.coding.UnnecessarySemicolonInTryWithResourcesCheck"); 550 NAME_TO_FULL_MODULE_NAME.put("VariableDeclarationUsageDistanceCheck", 551 BASE_PACKAGE + ".checks.coding.VariableDeclarationUsageDistanceCheck"); 552 NAME_TO_FULL_MODULE_NAME.put("NoArrayTrailingCommaCheck", 553 BASE_PACKAGE + ".checks.coding.NoArrayTrailingCommaCheck"); 554 } 555 556 /** 557 * Fill short-to-full module names map with Checks from design package. 558 */ 559 private static void fillChecksFromDesignPackage() { 560 NAME_TO_FULL_MODULE_NAME.put("DesignForExtensionCheck", 561 BASE_PACKAGE + ".checks.design.DesignForExtensionCheck"); 562 NAME_TO_FULL_MODULE_NAME.put("FinalClassCheck", 563 BASE_PACKAGE + ".checks.design.FinalClassCheck"); 564 NAME_TO_FULL_MODULE_NAME.put("HideUtilityClassConstructorCheck", 565 BASE_PACKAGE + ".checks.design.HideUtilityClassConstructorCheck"); 566 NAME_TO_FULL_MODULE_NAME.put("InnerTypeLastCheck", 567 BASE_PACKAGE + ".checks.design.InnerTypeLastCheck"); 568 NAME_TO_FULL_MODULE_NAME.put("InterfaceIsTypeCheck", 569 BASE_PACKAGE + ".checks.design.InterfaceIsTypeCheck"); 570 NAME_TO_FULL_MODULE_NAME.put("MutableExceptionCheck", 571 BASE_PACKAGE + ".checks.design.MutableExceptionCheck"); 572 NAME_TO_FULL_MODULE_NAME.put("OneTopLevelClassCheck", 573 BASE_PACKAGE + ".checks.design.OneTopLevelClassCheck"); 574 NAME_TO_FULL_MODULE_NAME.put("ThrowsCountCheck", 575 BASE_PACKAGE + ".checks.design.ThrowsCountCheck"); 576 NAME_TO_FULL_MODULE_NAME.put("VisibilityModifierCheck", 577 BASE_PACKAGE + ".checks.design.VisibilityModifierCheck"); 578 } 579 580 /** 581 * Fill short-to-full module names map with Checks from header package. 582 */ 583 private static void fillChecksFromHeaderPackage() { 584 NAME_TO_FULL_MODULE_NAME.put("HeaderCheck", 585 BASE_PACKAGE + ".checks.header.HeaderCheck"); 586 NAME_TO_FULL_MODULE_NAME.put("RegexpHeaderCheck", 587 BASE_PACKAGE + ".checks.header.RegexpHeaderCheck"); 588 } 589 590 /** 591 * Fill short-to-full module names map with Checks from imports package. 592 */ 593 private static void fillChecksFromImportsPackage() { 594 NAME_TO_FULL_MODULE_NAME.put("AvoidStarImportCheck", 595 BASE_PACKAGE + ".checks.imports.AvoidStarImportCheck"); 596 NAME_TO_FULL_MODULE_NAME.put("AvoidStaticImportCheck", 597 BASE_PACKAGE + ".checks.imports.AvoidStaticImportCheck"); 598 NAME_TO_FULL_MODULE_NAME.put("CustomImportOrderCheck", 599 BASE_PACKAGE + ".checks.imports.CustomImportOrderCheck"); 600 NAME_TO_FULL_MODULE_NAME.put("IllegalImportCheck", 601 BASE_PACKAGE + ".checks.imports.IllegalImportCheck"); 602 NAME_TO_FULL_MODULE_NAME.put("ImportControlCheck", 603 BASE_PACKAGE + ".checks.imports.ImportControlCheck"); 604 NAME_TO_FULL_MODULE_NAME.put("ImportOrderCheck", 605 BASE_PACKAGE + ".checks.imports.ImportOrderCheck"); 606 NAME_TO_FULL_MODULE_NAME.put("RedundantImportCheck", 607 BASE_PACKAGE + ".checks.imports.RedundantImportCheck"); 608 NAME_TO_FULL_MODULE_NAME.put("UnusedImportsCheck", 609 BASE_PACKAGE + ".checks.imports.UnusedImportsCheck"); 610 } 611 612 /** 613 * Fill short-to-full module names map with Checks from indentation package. 614 */ 615 private static void fillChecksFromIndentationPackage() { 616 NAME_TO_FULL_MODULE_NAME.put("CommentsIndentationCheck", 617 BASE_PACKAGE + ".checks.indentation.CommentsIndentationCheck"); 618 NAME_TO_FULL_MODULE_NAME.put("IndentationCheck", 619 BASE_PACKAGE + ".checks.indentation.IndentationCheck"); 620 } 621 622 /** 623 * Fill short-to-full module names map with Checks from javadoc package. 624 */ 625 private static void fillChecksFromJavadocPackage() { 626 NAME_TO_FULL_MODULE_NAME.put("AtclauseOrderCheck", 627 BASE_PACKAGE + ".checks.javadoc.AtclauseOrderCheck"); 628 NAME_TO_FULL_MODULE_NAME.put("InvalidJavadocPositionCheck", 629 BASE_PACKAGE + ".checks.javadoc.InvalidJavadocPositionCheck"); 630 NAME_TO_FULL_MODULE_NAME.put("JavadocBlockTagLocationCheck", 631 BASE_PACKAGE + ".checks.javadoc.JavadocBlockTagLocationCheck"); 632 NAME_TO_FULL_MODULE_NAME.put("JavadocContentLocationCheck", 633 BASE_PACKAGE + ".checks.javadoc.JavadocContentLocationCheck"); 634 NAME_TO_FULL_MODULE_NAME.put("JavadocMethodCheck", 635 BASE_PACKAGE + ".checks.javadoc.JavadocMethodCheck"); 636 NAME_TO_FULL_MODULE_NAME.put("JavadocPackageCheck", 637 BASE_PACKAGE + ".checks.javadoc.JavadocPackageCheck"); 638 NAME_TO_FULL_MODULE_NAME.put("JavadocParagraphCheck", 639 BASE_PACKAGE + ".checks.javadoc.JavadocParagraphCheck"); 640 NAME_TO_FULL_MODULE_NAME.put("JavadocStyleCheck", 641 BASE_PACKAGE + ".checks.javadoc.JavadocStyleCheck"); 642 NAME_TO_FULL_MODULE_NAME.put("JavadocTagContinuationIndentationCheck", 643 BASE_PACKAGE + ".checks.javadoc.JavadocTagContinuationIndentationCheck"); 644 NAME_TO_FULL_MODULE_NAME.put("JavadocTypeCheck", 645 BASE_PACKAGE + ".checks.javadoc.JavadocTypeCheck"); 646 NAME_TO_FULL_MODULE_NAME.put("JavadocVariableCheck", 647 BASE_PACKAGE + ".checks.javadoc.JavadocVariableCheck"); 648 NAME_TO_FULL_MODULE_NAME.put("MissingJavadocMethodCheck", 649 BASE_PACKAGE + ".checks.javadoc.MissingJavadocMethodCheck"); 650 NAME_TO_FULL_MODULE_NAME.put("MissingJavadocPackageCheck", 651 BASE_PACKAGE + ".checks.javadoc.MissingJavadocPackageCheck"); 652 NAME_TO_FULL_MODULE_NAME.put("MissingJavadocTypeCheck", 653 BASE_PACKAGE + ".checks.javadoc.MissingJavadocTypeCheck"); 654 NAME_TO_FULL_MODULE_NAME.put("NonEmptyAtclauseDescriptionCheck", 655 BASE_PACKAGE + ".checks.javadoc.NonEmptyAtclauseDescriptionCheck"); 656 NAME_TO_FULL_MODULE_NAME.put("SingleLineJavadocCheck", 657 BASE_PACKAGE + ".checks.javadoc.SingleLineJavadocCheck"); 658 NAME_TO_FULL_MODULE_NAME.put("SummaryJavadocCheck", 659 BASE_PACKAGE + ".checks.javadoc.SummaryJavadocCheck"); 660 NAME_TO_FULL_MODULE_NAME.put("WriteTagCheck", 661 BASE_PACKAGE + ".checks.javadoc.WriteTagCheck"); 662 } 663 664 /** 665 * Fill short-to-full module names map with Checks from metrics package. 666 */ 667 private static void fillChecksFromMetricsPackage() { 668 NAME_TO_FULL_MODULE_NAME.put("BooleanExpressionComplexityCheck", 669 BASE_PACKAGE + ".checks.metrics.BooleanExpressionComplexityCheck"); 670 NAME_TO_FULL_MODULE_NAME.put("ClassDataAbstractionCouplingCheck", 671 BASE_PACKAGE + ".checks.metrics.ClassDataAbstractionCouplingCheck"); 672 NAME_TO_FULL_MODULE_NAME.put("ClassFanOutComplexityCheck", 673 BASE_PACKAGE + ".checks.metrics.ClassFanOutComplexityCheck"); 674 NAME_TO_FULL_MODULE_NAME.put("CyclomaticComplexityCheck", 675 BASE_PACKAGE + ".checks.metrics.CyclomaticComplexityCheck"); 676 NAME_TO_FULL_MODULE_NAME.put("JavaNCSSCheck", 677 BASE_PACKAGE + ".checks.metrics.JavaNCSSCheck"); 678 NAME_TO_FULL_MODULE_NAME.put("NPathComplexityCheck", 679 BASE_PACKAGE + ".checks.metrics.NPathComplexityCheck"); 680 } 681 682 /** 683 * Fill short-to-full module names map with Checks from modifier package. 684 */ 685 private static void fillChecksFromModifierPackage() { 686 NAME_TO_FULL_MODULE_NAME.put("ClassMemberImpliedModifierCheck", 687 BASE_PACKAGE + ".checks.modifier.ClassMemberImpliedModifierCheck"); 688 NAME_TO_FULL_MODULE_NAME.put("InterfaceMemberImpliedModifierCheck", 689 BASE_PACKAGE + ".checks.modifier.InterfaceMemberImpliedModifierCheck"); 690 NAME_TO_FULL_MODULE_NAME.put("ModifierOrderCheck", 691 BASE_PACKAGE + ".checks.modifier.ModifierOrderCheck"); 692 NAME_TO_FULL_MODULE_NAME.put("RedundantModifierCheck", 693 BASE_PACKAGE + ".checks.modifier.RedundantModifierCheck"); 694 } 695 696 /** 697 * Fill short-to-full module names map with Checks from naming package. 698 */ 699 private static void fillChecksFromNamingPackage() { 700 NAME_TO_FULL_MODULE_NAME.put("AbbreviationAsWordInNameCheck", 701 BASE_PACKAGE + ".checks.naming.AbbreviationAsWordInNameCheck"); 702 NAME_TO_FULL_MODULE_NAME.put("AbstractClassNameCheck", 703 BASE_PACKAGE + ".checks.naming.AbstractClassNameCheck"); 704 NAME_TO_FULL_MODULE_NAME.put("CatchParameterNameCheck", 705 BASE_PACKAGE + ".checks.naming.CatchParameterNameCheck"); 706 NAME_TO_FULL_MODULE_NAME.put("ClassTypeParameterNameCheck", 707 BASE_PACKAGE + ".checks.naming.ClassTypeParameterNameCheck"); 708 NAME_TO_FULL_MODULE_NAME.put("ConstantNameCheck", 709 BASE_PACKAGE + ".checks.naming.ConstantNameCheck"); 710 NAME_TO_FULL_MODULE_NAME.put("InterfaceTypeParameterNameCheck", 711 BASE_PACKAGE + ".checks.naming.InterfaceTypeParameterNameCheck"); 712 NAME_TO_FULL_MODULE_NAME.put("LambdaParameterNameCheck", 713 BASE_PACKAGE + ".checks.naming.LambdaParameterNameCheck"); 714 NAME_TO_FULL_MODULE_NAME.put("LocalFinalVariableNameCheck", 715 BASE_PACKAGE + ".checks.naming.LocalFinalVariableNameCheck"); 716 NAME_TO_FULL_MODULE_NAME.put("LocalVariableNameCheck", 717 BASE_PACKAGE + ".checks.naming.LocalVariableNameCheck"); 718 NAME_TO_FULL_MODULE_NAME.put("MemberNameCheck", 719 BASE_PACKAGE + ".checks.naming.MemberNameCheck"); 720 NAME_TO_FULL_MODULE_NAME.put("MethodNameCheck", 721 BASE_PACKAGE + ".checks.naming.MethodNameCheck"); 722 NAME_TO_FULL_MODULE_NAME.put("MethodTypeParameterNameCheck", 723 BASE_PACKAGE + ".checks.naming.MethodTypeParameterNameCheck"); 724 NAME_TO_FULL_MODULE_NAME.put("PackageNameCheck", 725 BASE_PACKAGE + ".checks.naming.PackageNameCheck"); 726 NAME_TO_FULL_MODULE_NAME.put("ParameterNameCheck", 727 BASE_PACKAGE + ".checks.naming.ParameterNameCheck"); 728 NAME_TO_FULL_MODULE_NAME.put("StaticVariableNameCheck", 729 BASE_PACKAGE + ".checks.naming.StaticVariableNameCheck"); 730 NAME_TO_FULL_MODULE_NAME.put("TypeNameCheck", 731 BASE_PACKAGE + ".checks.naming.TypeNameCheck"); 732 } 733 734 /** 735 * Fill short-to-full module names map with Checks from regexp package. 736 */ 737 private static void fillChecksFromRegexpPackage() { 738 NAME_TO_FULL_MODULE_NAME.put("RegexpCheck", 739 BASE_PACKAGE + ".checks.regexp.RegexpCheck"); 740 NAME_TO_FULL_MODULE_NAME.put("RegexpMultilineCheck", 741 BASE_PACKAGE + ".checks.regexp.RegexpMultilineCheck"); 742 NAME_TO_FULL_MODULE_NAME.put("RegexpOnFilenameCheck", 743 BASE_PACKAGE + ".checks.regexp.RegexpOnFilenameCheck"); 744 NAME_TO_FULL_MODULE_NAME.put("RegexpSinglelineCheck", 745 BASE_PACKAGE + ".checks.regexp.RegexpSinglelineCheck"); 746 NAME_TO_FULL_MODULE_NAME.put("RegexpSinglelineJavaCheck", 747 BASE_PACKAGE + ".checks.regexp.RegexpSinglelineJavaCheck"); 748 } 749 750 /** 751 * Fill short-to-full module names map with Checks from sizes package. 752 */ 753 private static void fillChecksFromSizesPackage() { 754 NAME_TO_FULL_MODULE_NAME.put("AnonInnerLengthCheck", 755 BASE_PACKAGE + ".checks.sizes.AnonInnerLengthCheck"); 756 NAME_TO_FULL_MODULE_NAME.put("ExecutableStatementCountCheck", 757 BASE_PACKAGE + ".checks.sizes.ExecutableStatementCountCheck"); 758 NAME_TO_FULL_MODULE_NAME.put("FileLengthCheck", 759 BASE_PACKAGE + ".checks.sizes.FileLengthCheck"); 760 NAME_TO_FULL_MODULE_NAME.put("LineLengthCheck", 761 BASE_PACKAGE + ".checks.sizes.LineLengthCheck"); 762 NAME_TO_FULL_MODULE_NAME.put("MethodCountCheck", 763 BASE_PACKAGE + ".checks.sizes.MethodCountCheck"); 764 NAME_TO_FULL_MODULE_NAME.put("MethodLengthCheck", 765 BASE_PACKAGE + ".checks.sizes.MethodLengthCheck"); 766 NAME_TO_FULL_MODULE_NAME.put("OuterTypeNumberCheck", 767 BASE_PACKAGE + ".checks.sizes.OuterTypeNumberCheck"); 768 NAME_TO_FULL_MODULE_NAME.put("ParameterNumberCheck", 769 BASE_PACKAGE + ".checks.sizes.ParameterNumberCheck"); 770 } 771 772 /** 773 * Fill short-to-full module names map with Checks from whitespace package. 774 */ 775 private static void fillChecksFromWhitespacePackage() { 776 NAME_TO_FULL_MODULE_NAME.put("EmptyForInitializerPadCheck", 777 BASE_PACKAGE + ".checks.whitespace.EmptyForInitializerPadCheck"); 778 NAME_TO_FULL_MODULE_NAME.put("EmptyForIteratorPadCheck", 779 BASE_PACKAGE + ".checks.whitespace.EmptyForIteratorPadCheck"); 780 NAME_TO_FULL_MODULE_NAME.put("EmptyLineSeparatorCheck", 781 BASE_PACKAGE + ".checks.whitespace.EmptyLineSeparatorCheck"); 782 NAME_TO_FULL_MODULE_NAME.put("FileTabCharacterCheck", 783 BASE_PACKAGE + ".checks.whitespace.FileTabCharacterCheck"); 784 NAME_TO_FULL_MODULE_NAME.put("GenericWhitespaceCheck", 785 BASE_PACKAGE + ".checks.whitespace.GenericWhitespaceCheck"); 786 NAME_TO_FULL_MODULE_NAME.put("MethodParamPadCheck", 787 BASE_PACKAGE + ".checks.whitespace.MethodParamPadCheck"); 788 NAME_TO_FULL_MODULE_NAME.put("NoLineWrapCheck", 789 BASE_PACKAGE + ".checks.whitespace.NoLineWrapCheck"); 790 NAME_TO_FULL_MODULE_NAME.put("NoWhitespaceAfterCheck", 791 BASE_PACKAGE + ".checks.whitespace.NoWhitespaceAfterCheck"); 792 NAME_TO_FULL_MODULE_NAME.put("NoWhitespaceBeforeCheck", 793 BASE_PACKAGE + ".checks.whitespace.NoWhitespaceBeforeCheck"); 794 NAME_TO_FULL_MODULE_NAME.put("OperatorWrapCheck", 795 BASE_PACKAGE + ".checks.whitespace.OperatorWrapCheck"); 796 NAME_TO_FULL_MODULE_NAME.put("ParenPadCheck", 797 BASE_PACKAGE + ".checks.whitespace.ParenPadCheck"); 798 NAME_TO_FULL_MODULE_NAME.put("SeparatorWrapCheck", 799 BASE_PACKAGE + ".checks.whitespace.SeparatorWrapCheck"); 800 NAME_TO_FULL_MODULE_NAME.put("SingleSpaceSeparatorCheck", 801 BASE_PACKAGE + ".checks.whitespace.SingleSpaceSeparatorCheck"); 802 NAME_TO_FULL_MODULE_NAME.put("TypecastParenPadCheck", 803 BASE_PACKAGE + ".checks.whitespace.TypecastParenPadCheck"); 804 NAME_TO_FULL_MODULE_NAME.put("WhitespaceAfterCheck", 805 BASE_PACKAGE + ".checks.whitespace.WhitespaceAfterCheck"); 806 NAME_TO_FULL_MODULE_NAME.put("WhitespaceAroundCheck", 807 BASE_PACKAGE + ".checks.whitespace.WhitespaceAroundCheck"); 808 } 809 810 /** 811 * Fill short-to-full module names map with modules from checks package. 812 */ 813 private static void fillModulesFromChecksPackage() { 814 NAME_TO_FULL_MODULE_NAME.put("ArrayTypeStyleCheck", 815 BASE_PACKAGE + ".checks.ArrayTypeStyleCheck"); 816 NAME_TO_FULL_MODULE_NAME.put("AvoidEscapedUnicodeCharactersCheck", 817 BASE_PACKAGE + ".checks.AvoidEscapedUnicodeCharactersCheck"); 818 NAME_TO_FULL_MODULE_NAME.put("DescendantTokenCheck", 819 BASE_PACKAGE + ".checks.DescendantTokenCheck"); 820 NAME_TO_FULL_MODULE_NAME.put("FinalParametersCheck", 821 BASE_PACKAGE + ".checks.FinalParametersCheck"); 822 NAME_TO_FULL_MODULE_NAME.put("NewlineAtEndOfFileCheck", 823 BASE_PACKAGE + ".checks.NewlineAtEndOfFileCheck"); 824 NAME_TO_FULL_MODULE_NAME.put("OuterTypeFilenameCheck", 825 BASE_PACKAGE + ".checks.OuterTypeFilenameCheck"); 826 NAME_TO_FULL_MODULE_NAME.put("OrderedPropertiesCheck", 827 BASE_PACKAGE + ".checks.OrderedPropertiesCheck"); 828 NAME_TO_FULL_MODULE_NAME.put("SuppressWarningsHolder", 829 BASE_PACKAGE + ".checks.SuppressWarningsHolder"); 830 NAME_TO_FULL_MODULE_NAME.put("TodoCommentCheck", 831 BASE_PACKAGE + ".checks.TodoCommentCheck"); 832 NAME_TO_FULL_MODULE_NAME.put("TrailingCommentCheck", 833 BASE_PACKAGE + ".checks.TrailingCommentCheck"); 834 NAME_TO_FULL_MODULE_NAME.put("TranslationCheck", 835 BASE_PACKAGE + ".checks.TranslationCheck"); 836 NAME_TO_FULL_MODULE_NAME.put("UncommentedMainCheck", 837 BASE_PACKAGE + ".checks.UncommentedMainCheck"); 838 NAME_TO_FULL_MODULE_NAME.put("UniquePropertiesCheck", 839 BASE_PACKAGE + ".checks.UniquePropertiesCheck"); 840 NAME_TO_FULL_MODULE_NAME.put("UpperEllCheck", 841 BASE_PACKAGE + ".checks.UpperEllCheck"); 842 } 843 844 /** 845 * Fill short-to-full module names map with modules from filefilters package. 846 */ 847 private static void fillModulesFromFilefiltersPackage() { 848 NAME_TO_FULL_MODULE_NAME.put("BeforeExecutionExclusionFileFilter", 849 BASE_PACKAGE + ".filefilters.BeforeExecutionExclusionFileFilter"); 850 } 851 852 /** 853 * Fill short-to-full module names map with modules from filters package. 854 */ 855 private static void fillModulesFromFiltersPackage() { 856 NAME_TO_FULL_MODULE_NAME.put("SeverityMatchFilter", 857 BASE_PACKAGE + ".filters.SeverityMatchFilter"); 858 NAME_TO_FULL_MODULE_NAME.put("SuppressWithPlainTextCommentFilter", 859 BASE_PACKAGE + ".filters.SuppressWithPlainTextCommentFilter"); 860 NAME_TO_FULL_MODULE_NAME.put("SuppressionCommentFilter", 861 BASE_PACKAGE + ".filters.SuppressionCommentFilter"); 862 NAME_TO_FULL_MODULE_NAME.put("SuppressionFilter", 863 BASE_PACKAGE + ".filters.SuppressionFilter"); 864 NAME_TO_FULL_MODULE_NAME.put("SuppressionSingleFilter", 865 BASE_PACKAGE + ".filters.SuppressionSingleFilter"); 866 NAME_TO_FULL_MODULE_NAME.put("SuppressionXpathFilter", 867 BASE_PACKAGE + ".filters.SuppressionXpathFilter"); 868 NAME_TO_FULL_MODULE_NAME.put("SuppressionXpathSingleFilter", 869 BASE_PACKAGE + ".filters.SuppressionXpathSingleFilter"); 870 NAME_TO_FULL_MODULE_NAME.put("SuppressWarningsFilter", 871 BASE_PACKAGE + ".filters.SuppressWarningsFilter"); 872 NAME_TO_FULL_MODULE_NAME.put("SuppressWithNearbyCommentFilter", 873 BASE_PACKAGE + ".filters.SuppressWithNearbyCommentFilter"); 874 } 875 876 /** 877 * Fill short-to-full module names map with modules from checkstyle package. 878 */ 879 private static void fillModulesFromCheckstylePackage() { 880 NAME_TO_FULL_MODULE_NAME.put("Checker", BASE_PACKAGE + ".Checker"); 881 NAME_TO_FULL_MODULE_NAME.put("TreeWalker", BASE_PACKAGE + ".TreeWalker"); 882 } 883 884}