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