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