001/////////////////////////////////////////////////////////////////////////////////////////////// 002// checkstyle: Checks Java source code and other text files for adherence to a set of rules. 003// Copyright (C) 2001-2026 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.HashMap; 024import java.util.HashSet; 025import java.util.LinkedHashSet; 026import java.util.List; 027import java.util.Map; 028import java.util.Map.Entry; 029import java.util.Set; 030import java.util.function.Supplier; 031import java.util.stream.Collectors; 032import java.util.stream.Stream; 033 034import com.puppycrawl.tools.checkstyle.api.CheckstyleException; 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 /** 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 * 119 * @param packageNames package names to use 120 * @param moduleClassLoader class loader used to load Checkstyle 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 packageName The package name to use 130 * @param moduleClassLoader class loader used to load Checkstyle core and custom modules 131 * @throws IllegalArgumentException if moduleClassLoader is null or packageNames is null 132 */ 133 public PackageObjectFactory(String packageName, ClassLoader moduleClassLoader) { 134 if (moduleClassLoader == null) { 135 throw new IllegalArgumentException(NULL_LOADER_MESSAGE); 136 } 137 if (packageName == null) { 138 throw new IllegalArgumentException(NULL_PACKAGE_MESSAGE); 139 } 140 141 packages = Set.of(packageName); 142 this.moduleClassLoader = moduleClassLoader; 143 } 144 145 /** 146 * Creates a new {@code PackageObjectFactory} instance. 147 * 148 * @param packageNames package names to use 149 * @param moduleClassLoader class loader used to load Checkstyle core and custom modules 150 * @param moduleLoadOption loading option 151 * @throws IllegalArgumentException if moduleClassLoader is null or packageNames contains null 152 */ 153 public PackageObjectFactory(Set<String> packageNames, ClassLoader moduleClassLoader, 154 ModuleLoadOption moduleLoadOption) { 155 if (moduleClassLoader == null) { 156 throw new IllegalArgumentException(NULL_LOADER_MESSAGE); 157 } 158 if (packageNames.contains(null)) { 159 throw new IllegalArgumentException(NULL_PACKAGE_MESSAGE); 160 } 161 162 // create a copy of the given set, but retain ordering 163 packages = new LinkedHashSet<>(packageNames); 164 this.moduleClassLoader = moduleClassLoader; 165 this.moduleLoadOption = moduleLoadOption; 166 } 167 168 /** 169 * Creates a new instance of a class from a given name, or that name 170 * concatenated with {@code "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 * 175 * @param name the name of a class. 176 * @return the {@code Object} created by loader. 177 * @throws CheckstyleException if an error occurs. 178 */ 179 @Override 180 public Object createModule(String name) throws CheckstyleException { 181 Object instance = null; 182 // if the name is a simple class name, try to find it in maps at first 183 if (!name.contains(PACKAGE_SEPARATOR)) { 184 instance = createFromStandardCheckSet(name); 185 // find the name in third party map 186 if (instance == null) { 187 instance = createObjectFromClassPath(name); 188 } 189 } 190 if (instance == null) { 191 instance = createObject(name); 192 } 193 if (instance == null 194 && moduleLoadOption == ModuleLoadOption.TRY_IN_ALL_REGISTERED_PACKAGES) { 195 instance = createModuleByTryInEachPackage(name); 196 } 197 if (instance == null) { 198 String attemptedNames = null; 199 if (!name.contains(PACKAGE_SEPARATOR)) { 200 final String nameCheck = name + CHECK_SUFFIX; 201 attemptedNames = joinPackageNamesWithClassName(name, packages) 202 + STRING_SEPARATOR + nameCheck + STRING_SEPARATOR 203 + joinPackageNamesWithClassName(nameCheck, packages); 204 } 205 final LocalizedMessage exceptionMessage = new LocalizedMessage( 206 Definitions.CHECKSTYLE_BUNDLE, getClass(), 207 UNABLE_TO_INSTANTIATE_EXCEPTION_MESSAGE, name, attemptedNames); 208 throw new CheckstyleException(exceptionMessage.getMessage()); 209 } 210 return instance; 211 } 212 213 /** 214 * Create object from one of Checkstyle module names. 215 * 216 * @param name name of module. 217 * @return instance of module. 218 * @throws CheckstyleException if the class fails to instantiate or there are ambiguous classes. 219 */ 220 private Object createFromStandardCheckSet(String name) throws CheckstyleException { 221 final String fullModuleName = NAME_TO_FULL_MODULE_NAME.get(name); 222 Object instance = null; 223 if (fullModuleName == null) { 224 final String fullCheckModuleName = 225 NAME_TO_FULL_MODULE_NAME.get(name + CHECK_SUFFIX); 226 if (fullCheckModuleName != null) { 227 instance = createObject(fullCheckModuleName); 228 } 229 } 230 else { 231 instance = createObject(fullModuleName); 232 } 233 return instance; 234 } 235 236 /** 237 * Create object with the help of the classpath. 238 * 239 * @param name name of module. 240 * @return instance of module if it is found in modules map and no ambiguous classes exist. 241 * @throws CheckstyleException if the class fails to instantiate or there are ambiguous classes. 242 */ 243 private Object createObjectFromClassPath(String name) 244 throws CheckstyleException { 245 thirdPartyNameToFullModuleNames = lazyLoad( 246 thirdPartyNameToFullModuleNames, 247 () -> generateThirdPartyNameToFullModuleName(moduleClassLoader) 248 ); 249 final Set<String> fullModuleNames = thirdPartyNameToFullModuleNames.get(name); 250 Object instance = null; 251 if (fullModuleNames == null) { 252 final Set<String> fullCheckModuleNames = 253 thirdPartyNameToFullModuleNames.get(name + CHECK_SUFFIX); 254 if (fullCheckModuleNames != null) { 255 instance = createObjectFromFullModuleNames(name, fullCheckModuleNames); 256 } 257 } 258 else { 259 instance = createObjectFromFullModuleNames(name, fullModuleNames); 260 } 261 return instance; 262 } 263 264 /** 265 * Create Object from optional full module names. 266 * In most case, there should be only one element in {@code fullModuleNames}, otherwise 267 * an exception would be thrown. 268 * 269 * @param name name of module 270 * @param fullModuleNames the supplied full module names set 271 * @return instance of module if there is only one element in {@code fullModuleNames} 272 * @throws CheckstyleException if the class fails to instantiate or there are more than one 273 * element in {@code fullModuleNames} 274 */ 275 private Object createObjectFromFullModuleNames(String name, Set<String> fullModuleNames) 276 throws CheckstyleException { 277 final Object returnValue; 278 if (fullModuleNames.size() == 1) { 279 returnValue = createObject(fullModuleNames.iterator().next()); 280 } 281 else { 282 final String optionalNames = fullModuleNames.stream() 283 .sorted() 284 .collect(Collectors.joining(STRING_SEPARATOR)); 285 final LocalizedMessage exceptionMessage = new LocalizedMessage( 286 Definitions.CHECKSTYLE_BUNDLE, getClass(), 287 AMBIGUOUS_MODULE_NAME_EXCEPTION_MESSAGE, name, optionalNames); 288 throw new CheckstyleException(exceptionMessage.getMessage()); 289 } 290 return returnValue; 291 } 292 293 /** 294 * Generate the map of third party Checkstyle module names to the set of their fully qualified 295 * names. 296 * 297 * @param loader the class loader used to load Checkstyle package names 298 * @return the map of third party Checkstyle module names to the set of their fully qualified 299 * names 300 */ 301 private Map<String, Set<String>> generateThirdPartyNameToFullModuleName(ClassLoader loader) { 302 Map<String, Set<String>> returnValue; 303 try { 304 returnValue = ModuleReflectionUtil.getCheckstyleModules(packages, loader).stream() 305 .collect(Collectors.groupingBy(Class::getSimpleName, 306 Collectors.mapping( 307 Class::getCanonicalName, 308 Collectors.toCollection(HashSet::new)))); 309 } 310 catch (IOException ignore) { 311 returnValue = Map.of(); 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 .findFirst() 328 .map(Entry::getKey) 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 exc) { 369 throw new CheckstyleException("Unable to instantiate " + className, exc); 370 } 371 } 372 373 return instance; 374 } 375 376 /** 377 * Searching to class with given name (or name concatenated with {@code "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 .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 * Initialize object by supplier if object is null. 401 * 402 * @param <T> type of object 403 * @param object object to initialize 404 * @param supplier function to initialize if object is null 405 * @return object as it was provided in method or initialized 406 */ 407 private static <T> T lazyLoad(T object, Supplier<T> supplier) { 408 final T result; 409 if (object == null) { 410 result = supplier.get(); 411 } 412 else { 413 result = object; 414 } 415 return result; 416 } 417 418 /** 419 * Fill short-to-full module names map. 420 */ 421 private static void fillShortToFullModuleNamesMap() { 422 fillChecksFromAnnotationPackage(); 423 fillChecksFromBlocksPackage(); 424 fillChecksFromCodingPackage(); 425 fillChecksFromDesignPackage(); 426 fillChecksFromHeaderPackage(); 427 fillChecksFromImportsPackage(); 428 fillChecksFromIndentationPackage(); 429 fillChecksFromJavadocPackage(); 430 fillChecksFromMetricsPackage(); 431 fillChecksFromModifierPackage(); 432 fillChecksFromModulesPackage(); 433 fillChecksFromNamingPackage(); 434 fillChecksFromRegexpPackage(); 435 fillChecksFromSizesPackage(); 436 fillChecksFromWhitespacePackage(); 437 fillModulesFromChecksPackage(); 438 fillModulesFromFilefiltersPackage(); 439 fillModulesFromFiltersPackage(); 440 fillModulesFromCheckstylePackage(); 441 } 442 443 /** 444 * Fill short-to-full module names map with Checks from annotation package. 445 */ 446 private static void fillChecksFromAnnotationPackage() { 447 NAME_TO_FULL_MODULE_NAME.put("AnnotationLocationCheck", 448 BASE_PACKAGE + ".checks.annotation.AnnotationLocationCheck"); 449 NAME_TO_FULL_MODULE_NAME.put("OpenjdkAnnotationLocationCheck", 450 BASE_PACKAGE + ".checks.annotation.OpenjdkAnnotationLocationCheck"); 451 NAME_TO_FULL_MODULE_NAME.put("AnnotationOnSameLineCheck", 452 BASE_PACKAGE + ".checks.annotation.AnnotationOnSameLineCheck"); 453 NAME_TO_FULL_MODULE_NAME.put("AnnotationUseStyleCheck", 454 BASE_PACKAGE + ".checks.annotation.AnnotationUseStyleCheck"); 455 NAME_TO_FULL_MODULE_NAME.put("MissingDeprecatedCheck", 456 BASE_PACKAGE + ".checks.annotation.MissingDeprecatedCheck"); 457 NAME_TO_FULL_MODULE_NAME.put("MissingOverrideCheck", 458 BASE_PACKAGE + ".checks.annotation.MissingOverrideCheck"); 459 NAME_TO_FULL_MODULE_NAME.put("MissingOverrideOnRecordAccessorCheck", 460 BASE_PACKAGE + ".checks.annotation.MissingOverrideOnRecordAccessorCheck"); 461 NAME_TO_FULL_MODULE_NAME.put("PackageAnnotationCheck", 462 BASE_PACKAGE + ".checks.annotation.PackageAnnotationCheck"); 463 NAME_TO_FULL_MODULE_NAME.put("SuppressWarningsCheck", 464 BASE_PACKAGE + ".checks.annotation.SuppressWarningsCheck"); 465 } 466 467 /** 468 * Fill short-to-full module names map with Checks from blocks package. 469 */ 470 private static void fillChecksFromBlocksPackage() { 471 NAME_TO_FULL_MODULE_NAME.put("AvoidNestedBlocksCheck", 472 BASE_PACKAGE + ".checks.blocks.AvoidNestedBlocksCheck"); 473 NAME_TO_FULL_MODULE_NAME.put("EmptyBlockCheck", 474 BASE_PACKAGE + ".checks.blocks.EmptyBlockCheck"); 475 NAME_TO_FULL_MODULE_NAME.put("EmptyCatchBlockCheck", 476 BASE_PACKAGE + ".checks.blocks.EmptyCatchBlockCheck"); 477 NAME_TO_FULL_MODULE_NAME.put("LeftCurlyCheck", 478 BASE_PACKAGE + ".checks.blocks.LeftCurlyCheck"); 479 NAME_TO_FULL_MODULE_NAME.put("NeedBracesCheck", 480 BASE_PACKAGE + ".checks.blocks.NeedBracesCheck"); 481 NAME_TO_FULL_MODULE_NAME.put("GoogleRightCurlyCheck", 482 BASE_PACKAGE + ".checks.blocks.GoogleRightCurlyCheck"); 483 NAME_TO_FULL_MODULE_NAME.put("RightCurlyCheck", 484 BASE_PACKAGE + ".checks.blocks.RightCurlyCheck"); 485 } 486 487 /** 488 * Fill short-to-full module names map with Checks from coding package. 489 */ 490 // -@cs[ExecutableStatementCount] splitting this method is not reasonable. 491 // -@cs[JavaNCSS] splitting this method is not reasonable. 492 private static void fillChecksFromCodingPackage() { 493 NAME_TO_FULL_MODULE_NAME.put("ArrayTrailingCommaCheck", 494 BASE_PACKAGE + ".checks.coding.ArrayTrailingCommaCheck"); 495 NAME_TO_FULL_MODULE_NAME.put("AvoidDoubleBraceInitializationCheck", 496 BASE_PACKAGE + ".checks.coding.AvoidDoubleBraceInitializationCheck"); 497 NAME_TO_FULL_MODULE_NAME.put("AvoidInlineConditionalsCheck", 498 BASE_PACKAGE + ".checks.coding.AvoidInlineConditionalsCheck"); 499 NAME_TO_FULL_MODULE_NAME.put("AvoidNoArgumentSuperConstructorCallCheck", 500 BASE_PACKAGE + ".checks.coding.AvoidNoArgumentSuperConstructorCallCheck"); 501 NAME_TO_FULL_MODULE_NAME.put("ConstructorsDeclarationGroupingCheck", 502 BASE_PACKAGE + ".checks.coding.ConstructorsDeclarationGroupingCheck"); 503 NAME_TO_FULL_MODULE_NAME.put("CovariantEqualsCheck", 504 BASE_PACKAGE + ".checks.coding.CovariantEqualsCheck"); 505 NAME_TO_FULL_MODULE_NAME.put("DeclarationOrderCheck", 506 BASE_PACKAGE + ".checks.coding.DeclarationOrderCheck"); 507 NAME_TO_FULL_MODULE_NAME.put("DefaultComesLastCheck", 508 BASE_PACKAGE + ".checks.coding.DefaultComesLastCheck"); 509 NAME_TO_FULL_MODULE_NAME.put("EmptyStatementCheck", 510 BASE_PACKAGE + ".checks.coding.EmptyStatementCheck"); 511 NAME_TO_FULL_MODULE_NAME.put("EqualsAvoidNullCheck", 512 BASE_PACKAGE + ".checks.coding.EqualsAvoidNullCheck"); 513 NAME_TO_FULL_MODULE_NAME.put("EqualsHashCodeCheck", 514 BASE_PACKAGE + ".checks.coding.EqualsHashCodeCheck"); 515 NAME_TO_FULL_MODULE_NAME.put("ExplicitInitializationCheck", 516 BASE_PACKAGE + ".checks.coding.ExplicitInitializationCheck"); 517 NAME_TO_FULL_MODULE_NAME.put("ExpressionOverBlockLambdaCheck", 518 BASE_PACKAGE + ".checks.coding.ExpressionOverBlockLambdaCheck"); 519 NAME_TO_FULL_MODULE_NAME.put("FallThroughCheck", 520 BASE_PACKAGE + ".checks.coding.FallThroughCheck"); 521 NAME_TO_FULL_MODULE_NAME.put("FinalLocalVariableCheck", 522 BASE_PACKAGE + ".checks.coding.FinalLocalVariableCheck"); 523 NAME_TO_FULL_MODULE_NAME.put("FinalPatternVariableCheck", 524 BASE_PACKAGE + ".checks.coding.FinalPatternVariableCheck"); 525 NAME_TO_FULL_MODULE_NAME.put("HiddenFieldCheck", 526 BASE_PACKAGE + ".checks.coding.HiddenFieldCheck"); 527 NAME_TO_FULL_MODULE_NAME.put("IllegalCatchCheck", 528 BASE_PACKAGE + ".checks.coding.IllegalCatchCheck"); 529 NAME_TO_FULL_MODULE_NAME.put("IllegalInstantiationCheck", 530 BASE_PACKAGE + ".checks.coding.IllegalInstantiationCheck"); 531 NAME_TO_FULL_MODULE_NAME.put("IllegalSymbolCheck", 532 BASE_PACKAGE + ".checks.coding.IllegalSymbolCheck"); 533 NAME_TO_FULL_MODULE_NAME.put("IllegalThrowsCheck", 534 BASE_PACKAGE + ".checks.coding.IllegalThrowsCheck"); 535 NAME_TO_FULL_MODULE_NAME.put("IllegalTokenCheck", 536 BASE_PACKAGE + ".checks.coding.IllegalTokenCheck"); 537 NAME_TO_FULL_MODULE_NAME.put("IllegalTokenTextCheck", 538 BASE_PACKAGE + ".checks.coding.IllegalTokenTextCheck"); 539 NAME_TO_FULL_MODULE_NAME.put("IllegalTypeCheck", 540 BASE_PACKAGE + ".checks.coding.IllegalTypeCheck"); 541 NAME_TO_FULL_MODULE_NAME.put("InnerAssignmentCheck", 542 BASE_PACKAGE + ".checks.coding.InnerAssignmentCheck"); 543 NAME_TO_FULL_MODULE_NAME.put("MagicNumberCheck", 544 BASE_PACKAGE + ".checks.coding.MagicNumberCheck"); 545 NAME_TO_FULL_MODULE_NAME.put("MissingCtorCheck", 546 BASE_PACKAGE + ".checks.coding.MissingCtorCheck"); 547 NAME_TO_FULL_MODULE_NAME.put("MissingNullCaseInSwitchCheck", 548 BASE_PACKAGE + ".checks.coding.MissingNullCaseInSwitchCheck"); 549 NAME_TO_FULL_MODULE_NAME.put("MissingSwitchDefaultCheck", 550 BASE_PACKAGE + ".checks.coding.MissingSwitchDefaultCheck"); 551 NAME_TO_FULL_MODULE_NAME.put("ModifiedControlVariableCheck", 552 BASE_PACKAGE + ".checks.coding.ModifiedControlVariableCheck"); 553 NAME_TO_FULL_MODULE_NAME.put("MultipleStringLiteralsCheck", 554 BASE_PACKAGE + ".checks.coding.MultipleStringLiteralsCheck"); 555 NAME_TO_FULL_MODULE_NAME.put("MultipleVariableDeclarationsCheck", 556 BASE_PACKAGE + ".checks.coding.MultipleVariableDeclarationsCheck"); 557 NAME_TO_FULL_MODULE_NAME.put("NestedForDepthCheck", 558 BASE_PACKAGE + ".checks.coding.NestedForDepthCheck"); 559 NAME_TO_FULL_MODULE_NAME.put("NestedIfDepthCheck", 560 BASE_PACKAGE + ".checks.coding.NestedIfDepthCheck"); 561 NAME_TO_FULL_MODULE_NAME.put("NestedTryDepthCheck", 562 BASE_PACKAGE + ".checks.coding.NestedTryDepthCheck"); 563 NAME_TO_FULL_MODULE_NAME.put("NoCloneCheck", 564 BASE_PACKAGE + ".checks.coding.NoCloneCheck"); 565 NAME_TO_FULL_MODULE_NAME.put("NoEnumTrailingCommaCheck", 566 BASE_PACKAGE + ".checks.coding.NoEnumTrailingCommaCheck"); 567 NAME_TO_FULL_MODULE_NAME.put("NoFinalizerCheck", 568 BASE_PACKAGE + ".checks.coding.NoFinalizerCheck"); 569 NAME_TO_FULL_MODULE_NAME.put("OneStatementPerLineCheck", 570 BASE_PACKAGE + ".checks.coding.OneStatementPerLineCheck"); 571 NAME_TO_FULL_MODULE_NAME.put("OverloadMethodsDeclarationOrderCheck", 572 BASE_PACKAGE + ".checks.coding.OverloadMethodsDeclarationOrderCheck"); 573 NAME_TO_FULL_MODULE_NAME.put("PackageDeclarationCheck", 574 BASE_PACKAGE + ".checks.coding.PackageDeclarationCheck"); 575 NAME_TO_FULL_MODULE_NAME.put("PatternVariableAssignmentCheck", 576 BASE_PACKAGE + ".checks.coding.PatternVariableAssignmentCheck"); 577 NAME_TO_FULL_MODULE_NAME.put("ParameterAssignmentCheck", 578 BASE_PACKAGE + ".checks.coding.ParameterAssignmentCheck"); 579 NAME_TO_FULL_MODULE_NAME.put("RedundantThisCheck", 580 BASE_PACKAGE + ".checks.coding.RedundantThisCheck"); 581 NAME_TO_FULL_MODULE_NAME.put("RequireThisCheck", 582 BASE_PACKAGE + ".checks.coding.RequireThisCheck"); 583 NAME_TO_FULL_MODULE_NAME.put("ReturnCountCheck", 584 BASE_PACKAGE + ".checks.coding.ReturnCountCheck"); 585 NAME_TO_FULL_MODULE_NAME.put("SimplifyBooleanExpressionCheck", 586 BASE_PACKAGE + ".checks.coding.SimplifyBooleanExpressionCheck"); 587 NAME_TO_FULL_MODULE_NAME.put("SimplifyBooleanReturnCheck", 588 BASE_PACKAGE + ".checks.coding.SimplifyBooleanReturnCheck"); 589 NAME_TO_FULL_MODULE_NAME.put("StringLiteralEqualityCheck", 590 BASE_PACKAGE + ".checks.coding.StringLiteralEqualityCheck"); 591 NAME_TO_FULL_MODULE_NAME.put("SuperCloneCheck", 592 BASE_PACKAGE + ".checks.coding.SuperCloneCheck"); 593 NAME_TO_FULL_MODULE_NAME.put("SuperFinalizeCheck", 594 BASE_PACKAGE + ".checks.coding.SuperFinalizeCheck"); 595 NAME_TO_FULL_MODULE_NAME.put("UnnecessaryParenthesesCheck", 596 BASE_PACKAGE + ".checks.coding.UnnecessaryParenthesesCheck"); 597 NAME_TO_FULL_MODULE_NAME.put("UnnecessaryPermitsClauseCheck", 598 BASE_PACKAGE + ".checks.coding.UnnecessaryPermitsClauseCheck"); 599 NAME_TO_FULL_MODULE_NAME.put("UnnecessarySemicolonAfterOuterTypeDeclarationCheck", 600 BASE_PACKAGE 601 + ".checks.coding.UnnecessarySemicolonAfterOuterTypeDeclarationCheck"); 602 NAME_TO_FULL_MODULE_NAME.put("UnnecessarySemicolonAfterTypeMemberDeclarationCheck", 603 BASE_PACKAGE 604 + ".checks.coding.UnnecessarySemicolonAfterTypeMemberDeclarationCheck"); 605 NAME_TO_FULL_MODULE_NAME.put("UnnecessarySemicolonInEnumerationCheck", 606 BASE_PACKAGE + ".checks.coding.UnnecessarySemicolonInEnumerationCheck"); 607 NAME_TO_FULL_MODULE_NAME.put("UnnecessarySemicolonInTryWithResourcesCheck", 608 BASE_PACKAGE + ".checks.coding.UnnecessarySemicolonInTryWithResourcesCheck"); 609 NAME_TO_FULL_MODULE_NAME.put("UseEnhancedSwitchCheck", 610 BASE_PACKAGE + ".checks.coding.UseEnhancedSwitchCheck"); 611 NAME_TO_FULL_MODULE_NAME.put("VariableDeclarationUsageDistanceCheck", 612 BASE_PACKAGE + ".checks.coding.VariableDeclarationUsageDistanceCheck"); 613 NAME_TO_FULL_MODULE_NAME.put("WhenShouldBeUsedCheck", 614 BASE_PACKAGE + ".checks.coding.WhenShouldBeUsedCheck"); 615 NAME_TO_FULL_MODULE_NAME.put("NoArrayTrailingCommaCheck", 616 BASE_PACKAGE + ".checks.coding.NoArrayTrailingCommaCheck"); 617 NAME_TO_FULL_MODULE_NAME.put("MatchXpathCheck", 618 BASE_PACKAGE + ".checks.coding.MatchXpathCheck"); 619 NAME_TO_FULL_MODULE_NAME.put("TextBlockGoogleStyleFormattingCheck", 620 BASE_PACKAGE + ".checks.coding.TextBlockGoogleStyleFormattingCheck"); 621 NAME_TO_FULL_MODULE_NAME.put("UnusedLocalVariableCheck", 622 BASE_PACKAGE + ".checks.coding.UnusedLocalVariableCheck"); 623 NAME_TO_FULL_MODULE_NAME.put("UnusedPrivateFieldCheck", 624 BASE_PACKAGE + ".checks.coding.UnusedPrivateFieldCheck"); 625 NAME_TO_FULL_MODULE_NAME.put("UnusedCatchParameterShouldBeUnnamedCheck", 626 BASE_PACKAGE + ".checks.coding.UnusedCatchParameterShouldBeUnnamedCheck"); 627 NAME_TO_FULL_MODULE_NAME.put("UnusedLambdaParameterShouldBeUnnamedCheck", 628 BASE_PACKAGE + ".checks.coding.UnusedLambdaParameterShouldBeUnnamedCheck"); 629 NAME_TO_FULL_MODULE_NAME.put("UnnecessaryNullCheckWithInstanceOfCheck", 630 BASE_PACKAGE + ".checks.coding.UnnecessaryNullCheckWithInstanceOfCheck"); 631 NAME_TO_FULL_MODULE_NAME.put("UnusedTryResourceShouldBeUnnamedCheck", 632 BASE_PACKAGE + ".checks.coding.UnusedTryResourceShouldBeUnnamedCheck"); 633 NAME_TO_FULL_MODULE_NAME.put("UnnecessaryTypeArgumentsWithRecordPatternCheck", 634 BASE_PACKAGE + ".checks.coding.UnnecessaryTypeArgumentsWithRecordPatternCheck"); 635 NAME_TO_FULL_MODULE_NAME.put("NoCauseGetMessageInExceptionConstructorCheck", 636 BASE_PACKAGE + ".checks.coding.NoCauseGetMessageInExceptionConstructorCheck"); 637 NAME_TO_FULL_MODULE_NAME.put("ExceptionThrowShouldUseContextCheck", 638 BASE_PACKAGE + ".checks.coding.ExceptionThrowShouldUseContextCheck"); 639 } 640 641 /** 642 * Fill short-to-full module names map with Checks from design package. 643 */ 644 private static void fillChecksFromDesignPackage() { 645 NAME_TO_FULL_MODULE_NAME.put("DesignForExtensionCheck", 646 BASE_PACKAGE + ".checks.design.DesignForExtensionCheck"); 647 NAME_TO_FULL_MODULE_NAME.put("FinalClassCheck", 648 BASE_PACKAGE + ".checks.design.FinalClassCheck"); 649 NAME_TO_FULL_MODULE_NAME.put("HideUtilityClassConstructorCheck", 650 BASE_PACKAGE + ".checks.design.HideUtilityClassConstructorCheck"); 651 NAME_TO_FULL_MODULE_NAME.put("InnerTypeLastCheck", 652 BASE_PACKAGE + ".checks.design.InnerTypeLastCheck"); 653 NAME_TO_FULL_MODULE_NAME.put("InterfaceIsTypeCheck", 654 BASE_PACKAGE + ".checks.design.InterfaceIsTypeCheck"); 655 NAME_TO_FULL_MODULE_NAME.put("MutableExceptionCheck", 656 BASE_PACKAGE + ".checks.design.MutableExceptionCheck"); 657 NAME_TO_FULL_MODULE_NAME.put("OneTopLevelClassCheck", 658 BASE_PACKAGE + ".checks.design.OneTopLevelClassCheck"); 659 NAME_TO_FULL_MODULE_NAME.put("SealedShouldHavePermitsListCheck", 660 BASE_PACKAGE + ".checks.design.SealedShouldHavePermitsListCheck"); 661 NAME_TO_FULL_MODULE_NAME.put("ThrowsCountCheck", 662 BASE_PACKAGE + ".checks.design.ThrowsCountCheck"); 663 NAME_TO_FULL_MODULE_NAME.put("VisibilityModifierCheck", 664 BASE_PACKAGE + ".checks.design.VisibilityModifierCheck"); 665 } 666 667 /** 668 * Fill short-to-full module names map with Checks from header package. 669 */ 670 private static void fillChecksFromHeaderPackage() { 671 NAME_TO_FULL_MODULE_NAME.put("HeaderCheck", 672 BASE_PACKAGE + ".checks.header.HeaderCheck"); 673 NAME_TO_FULL_MODULE_NAME.put("RegexpHeaderCheck", 674 BASE_PACKAGE + ".checks.header.RegexpHeaderCheck"); 675 NAME_TO_FULL_MODULE_NAME.put("MultiFileRegexpHeaderCheck", 676 BASE_PACKAGE + ".checks.header.MultiFileRegexpHeaderCheck"); 677 } 678 679 /** 680 * Fill short-to-full module names map with Checks from imports package. 681 */ 682 private static void fillChecksFromImportsPackage() { 683 NAME_TO_FULL_MODULE_NAME.put("AvoidModuleImportCheck", 684 BASE_PACKAGE + ".checks.imports.AvoidModuleImportCheck"); 685 NAME_TO_FULL_MODULE_NAME.put("AvoidStarImportCheck", 686 BASE_PACKAGE + ".checks.imports.AvoidStarImportCheck"); 687 NAME_TO_FULL_MODULE_NAME.put("AvoidStaticImportCheck", 688 BASE_PACKAGE + ".checks.imports.AvoidStaticImportCheck"); 689 NAME_TO_FULL_MODULE_NAME.put("CustomImportOrderCheck", 690 BASE_PACKAGE + ".checks.imports.CustomImportOrderCheck"); 691 NAME_TO_FULL_MODULE_NAME.put("IllegalImportCheck", 692 BASE_PACKAGE + ".checks.imports.IllegalImportCheck"); 693 NAME_TO_FULL_MODULE_NAME.put("ImportControlCheck", 694 BASE_PACKAGE + ".checks.imports.ImportControlCheck"); 695 NAME_TO_FULL_MODULE_NAME.put("ImportOrderCheck", 696 BASE_PACKAGE + ".checks.imports.ImportOrderCheck"); 697 NAME_TO_FULL_MODULE_NAME.put("ModuleImportOrderCheck", 698 BASE_PACKAGE + ".checks.imports.ModuleImportOrderCheck"); 699 NAME_TO_FULL_MODULE_NAME.put("RedundantImportCheck", 700 BASE_PACKAGE + ".checks.imports.RedundantImportCheck"); 701 NAME_TO_FULL_MODULE_NAME.put("UnnecessaryFullyQualifiedTypeCheck", 702 BASE_PACKAGE + ".checks.imports.UnnecessaryFullyQualifiedTypeCheck"); 703 NAME_TO_FULL_MODULE_NAME.put("UnusedImportsCheck", 704 BASE_PACKAGE + ".checks.imports.UnusedImportsCheck"); 705 } 706 707 /** 708 * Fill short-to-full module names map with Checks from indentation package. 709 */ 710 private static void fillChecksFromIndentationPackage() { 711 NAME_TO_FULL_MODULE_NAME.put("ClassHeaderWrapOpenjdkCheck", 712 BASE_PACKAGE + ".checks.indentation.ClassHeaderWrapOpenjdkCheck"); 713 NAME_TO_FULL_MODULE_NAME.put("CommentsIndentationCheck", 714 BASE_PACKAGE + ".checks.indentation.CommentsIndentationCheck"); 715 NAME_TO_FULL_MODULE_NAME.put("IndentationCheck", 716 BASE_PACKAGE + ".checks.indentation.IndentationCheck"); 717 NAME_TO_FULL_MODULE_NAME.put("OpenjdkMethodThrowsAlignmentCheck", 718 BASE_PACKAGE + ".checks.indentation.OpenjdkMethodThrowsAlignmentCheck"); 719 } 720 721 /** 722 * Fill short-to-full module names map with Checks from javadoc package. 723 */ 724 private static void fillChecksFromJavadocPackage() { 725 NAME_TO_FULL_MODULE_NAME.put("AtclauseOrderCheck", 726 BASE_PACKAGE + ".checks.javadoc.AtclauseOrderCheck"); 727 NAME_TO_FULL_MODULE_NAME.put("IllegalBlockTagCheck", 728 BASE_PACKAGE + ".checks.javadoc.IllegalBlockTagCheck"); 729 NAME_TO_FULL_MODULE_NAME.put("InappropriateJavadocBlockTagsOnPackageCheck", 730 BASE_PACKAGE + ".checks.javadoc.InappropriateJavadocBlockTagsOnPackageCheck"); 731 NAME_TO_FULL_MODULE_NAME.put("InappropriateJavadocBlockTagsOnTypeCheck", 732 BASE_PACKAGE + ".checks.javadoc.InappropriateJavadocBlockTagsOnTypeCheck"); 733 NAME_TO_FULL_MODULE_NAME.put("InappropriateJavadocBlockTagsOnFieldCheck", 734 BASE_PACKAGE + ".checks.javadoc.InappropriateJavadocBlockTagsOnFieldCheck"); 735 NAME_TO_FULL_MODULE_NAME.put("BlockCommentEndPositionCheck", 736 BASE_PACKAGE + ".checks.javadoc.BlockCommentEndPositionCheck"); 737 NAME_TO_FULL_MODULE_NAME.put("InvalidJavadocPositionCheck", 738 BASE_PACKAGE + ".checks.javadoc.InvalidJavadocPositionCheck"); 739 NAME_TO_FULL_MODULE_NAME.put("JavadocBlockTagLocationCheck", 740 BASE_PACKAGE + ".checks.javadoc.JavadocBlockTagLocationCheck"); 741 NAME_TO_FULL_MODULE_NAME.put("JavadocContentLocationCheck", 742 BASE_PACKAGE + ".checks.javadoc.JavadocContentLocationCheck"); 743 NAME_TO_FULL_MODULE_NAME.put("JavadocEndCommentDelimiterCheck", 744 BASE_PACKAGE + ".checks.javadoc.JavadocEndCommentDelimiterCheck"); 745 NAME_TO_FULL_MODULE_NAME.put("JavadocLeadingAsteriskAlignCheck", 746 BASE_PACKAGE + ".checks.javadoc.JavadocLeadingAsteriskAlignCheck"); 747 NAME_TO_FULL_MODULE_NAME.put("JavadocLinkFirstOccurrenceCheck", 748 BASE_PACKAGE + ".checks.javadoc.JavadocLinkFirstOccurrenceCheck"); 749 NAME_TO_FULL_MODULE_NAME.put("JavadocLinkWellKnownApiCheck", 750 BASE_PACKAGE + ".checks.javadoc.JavadocLinkWellKnownApiCheck"); 751 NAME_TO_FULL_MODULE_NAME.put("JavadocMethodCheck", 752 BASE_PACKAGE + ".checks.javadoc.JavadocMethodCheck"); 753 NAME_TO_FULL_MODULE_NAME.put("JavadocMissingLeadingAsteriskCheck", 754 BASE_PACKAGE + ".checks.javadoc.JavadocMissingLeadingAsteriskCheck"); 755 NAME_TO_FULL_MODULE_NAME.put("JavadocMissingWhitespaceAfterAsteriskCheck", 756 BASE_PACKAGE + ".checks.javadoc.JavadocMissingWhitespaceAfterAsteriskCheck"); 757 NAME_TO_FULL_MODULE_NAME.put("JavadocNoErrorInThrowsTagCheck", 758 BASE_PACKAGE + ".checks.javadoc.JavadocNoErrorInThrowsTagCheck"); 759 NAME_TO_FULL_MODULE_NAME.put("JavadocPackageCheck", 760 BASE_PACKAGE + ".checks.javadoc.JavadocPackageCheck"); 761 NAME_TO_FULL_MODULE_NAME.put("JavadocParagraphCheck", 762 BASE_PACKAGE + ".checks.javadoc.JavadocParagraphCheck"); 763 NAME_TO_FULL_MODULE_NAME.put("JavadocParamOrderCheck", 764 BASE_PACKAGE + ".checks.javadoc.JavadocParamOrderCheck"); 765 NAME_TO_FULL_MODULE_NAME.put("JavadocRegexpCheck", 766 BASE_PACKAGE + ".checks.javadoc.JavadocRegexpCheck"); 767 NAME_TO_FULL_MODULE_NAME.put("JavadocSeeTagOrderCheck", 768 BASE_PACKAGE + ".checks.javadoc.JavadocSeeTagOrderCheck"); 769 NAME_TO_FULL_MODULE_NAME.put("JavadocTagContinuationIndentationCheck", 770 BASE_PACKAGE + ".checks.javadoc.JavadocTagContinuationIndentationCheck"); 771 NAME_TO_FULL_MODULE_NAME.put("JavadocThrowsOrderCheck", 772 BASE_PACKAGE + ".checks.javadoc.JavadocThrowsOrderCheck"); 773 NAME_TO_FULL_MODULE_NAME.put("JavadocTypeCheck", 774 BASE_PACKAGE + ".checks.javadoc.JavadocTypeCheck"); 775 NAME_TO_FULL_MODULE_NAME.put("JavadocUtilizingTrailingSpaceCheck", 776 BASE_PACKAGE + ".checks.javadoc.JavadocUtilizingTrailingSpaceCheck"); 777 NAME_TO_FULL_MODULE_NAME.put("JavadocVariableCheck", 778 BASE_PACKAGE + ".checks.javadoc.JavadocVariableCheck"); 779 NAME_TO_FULL_MODULE_NAME.put("MissingJavadocMethodCheck", 780 BASE_PACKAGE + ".checks.javadoc.MissingJavadocMethodCheck"); 781 NAME_TO_FULL_MODULE_NAME.put("MissingJavadocPackageCheck", 782 BASE_PACKAGE + ".checks.javadoc.MissingJavadocPackageCheck"); 783 NAME_TO_FULL_MODULE_NAME.put("MissingJavadocTypeCheck", 784 BASE_PACKAGE + ".checks.javadoc.MissingJavadocTypeCheck"); 785 NAME_TO_FULL_MODULE_NAME.put("NonEmptyAtclauseDescriptionCheck", 786 BASE_PACKAGE + ".checks.javadoc.NonEmptyAtclauseDescriptionCheck"); 787 NAME_TO_FULL_MODULE_NAME.put("PreferCodeOrSnippetJavadocInlineTagCheck", 788 BASE_PACKAGE + ".checks.javadoc.PreferCodeOrSnippetJavadocInlineTagCheck"); 789 NAME_TO_FULL_MODULE_NAME.put("PreferLiteralJavadocInlineTagCheck", 790 BASE_PACKAGE + ".checks.javadoc.PreferLiteralJavadocInlineTagCheck"); 791 NAME_TO_FULL_MODULE_NAME.put("RequireEmptyLineBeforeBlockTagGroupCheck", 792 BASE_PACKAGE + ".checks.javadoc.RequireEmptyLineBeforeBlockTagGroupCheck"); 793 NAME_TO_FULL_MODULE_NAME.put("SingleLineJavadocCheck", 794 BASE_PACKAGE + ".checks.javadoc.SingleLineJavadocCheck"); 795 NAME_TO_FULL_MODULE_NAME.put("SummaryJavadocCheck", 796 BASE_PACKAGE + ".checks.javadoc.SummaryJavadocCheck"); 797 NAME_TO_FULL_MODULE_NAME.put("WriteTagCheck", 798 BASE_PACKAGE + ".checks.javadoc.WriteTagCheck"); 799 } 800 801 /** 802 * Fill short-to-full module names map with Checks from metrics package. 803 */ 804 private static void fillChecksFromMetricsPackage() { 805 NAME_TO_FULL_MODULE_NAME.put("BooleanExpressionComplexityCheck", 806 BASE_PACKAGE + ".checks.metrics.BooleanExpressionComplexityCheck"); 807 NAME_TO_FULL_MODULE_NAME.put("ClassDataAbstractionCouplingCheck", 808 BASE_PACKAGE + ".checks.metrics.ClassDataAbstractionCouplingCheck"); 809 NAME_TO_FULL_MODULE_NAME.put("ClassFanOutComplexityCheck", 810 BASE_PACKAGE + ".checks.metrics.ClassFanOutComplexityCheck"); 811 NAME_TO_FULL_MODULE_NAME.put("CyclomaticComplexityCheck", 812 BASE_PACKAGE + ".checks.metrics.CyclomaticComplexityCheck"); 813 NAME_TO_FULL_MODULE_NAME.put("JavaNCSSCheck", 814 BASE_PACKAGE + ".checks.metrics.JavaNCSSCheck"); 815 NAME_TO_FULL_MODULE_NAME.put("NPathComplexityCheck", 816 BASE_PACKAGE + ".checks.metrics.NPathComplexityCheck"); 817 } 818 819 /** 820 * Fill short-to-full module names map with Checks from modifier package. 821 */ 822 private static void fillChecksFromModifierPackage() { 823 NAME_TO_FULL_MODULE_NAME.put("AnnotatedDeclarationVisibilityCheck", 824 BASE_PACKAGE + ".checks.modifier.AnnotatedDeclarationVisibilityCheck"); 825 NAME_TO_FULL_MODULE_NAME.put("ClassMemberImpliedModifierCheck", 826 BASE_PACKAGE + ".checks.modifier.ClassMemberImpliedModifierCheck"); 827 NAME_TO_FULL_MODULE_NAME.put("InterfaceMemberImpliedModifierCheck", 828 BASE_PACKAGE + ".checks.modifier.InterfaceMemberImpliedModifierCheck"); 829 NAME_TO_FULL_MODULE_NAME.put("ModifierOrderCheck", 830 BASE_PACKAGE + ".checks.modifier.ModifierOrderCheck"); 831 NAME_TO_FULL_MODULE_NAME.put("RedundantModifierCheck", 832 BASE_PACKAGE + ".checks.modifier.RedundantModifierCheck"); 833 NAME_TO_FULL_MODULE_NAME.put("RedundantModifierCompactSourceCheck", 834 BASE_PACKAGE + ".checks.modifier.RedundantModifierCompactSourceCheck"); 835 } 836 837 /** 838 * Fill short-to-full module names map with Checks from modules package. 839 */ 840 private static void fillChecksFromModulesPackage() { 841 NAME_TO_FULL_MODULE_NAME.put("ModuleDirectiveOrderCheck", 842 BASE_PACKAGE + ".checks.modules.ModuleDirectiveOrderCheck"); 843 } 844 845 /** 846 * Fill short-to-full module names map with Checks from naming package. 847 */ 848 private static void fillChecksFromNamingPackage() { 849 NAME_TO_FULL_MODULE_NAME.put("AbbreviationAsWordInNameCheck", 850 BASE_PACKAGE + ".checks.naming.AbbreviationAsWordInNameCheck"); 851 NAME_TO_FULL_MODULE_NAME.put("AbstractClassNameCheck", 852 BASE_PACKAGE + ".checks.naming.AbstractClassNameCheck"); 853 NAME_TO_FULL_MODULE_NAME.put("CatchParameterNameCheck", 854 BASE_PACKAGE + ".checks.naming.CatchParameterNameCheck"); 855 NAME_TO_FULL_MODULE_NAME.put("ClassTypeParameterNameCheck", 856 BASE_PACKAGE + ".checks.naming.ClassTypeParameterNameCheck"); 857 NAME_TO_FULL_MODULE_NAME.put("ConstantNameCheck", 858 BASE_PACKAGE + ".checks.naming.ConstantNameCheck"); 859 NAME_TO_FULL_MODULE_NAME.put("InterfaceTypeParameterNameCheck", 860 BASE_PACKAGE + ".checks.naming.InterfaceTypeParameterNameCheck"); 861 NAME_TO_FULL_MODULE_NAME.put("LambdaParameterNameCheck", 862 BASE_PACKAGE + ".checks.naming.LambdaParameterNameCheck"); 863 NAME_TO_FULL_MODULE_NAME.put("LocalFinalVariableNameCheck", 864 BASE_PACKAGE + ".checks.naming.LocalFinalVariableNameCheck"); 865 NAME_TO_FULL_MODULE_NAME.put("LocalVariableNameCheck", 866 BASE_PACKAGE + ".checks.naming.LocalVariableNameCheck"); 867 NAME_TO_FULL_MODULE_NAME.put("MemberNameCheck", 868 BASE_PACKAGE + ".checks.naming.MemberNameCheck"); 869 NAME_TO_FULL_MODULE_NAME.put("GoogleNonConstantFieldNameCheck", 870 BASE_PACKAGE + ".checks.naming.GoogleNonConstantFieldNameCheck"); 871 NAME_TO_FULL_MODULE_NAME.put("MethodNameCheck", 872 BASE_PACKAGE + ".checks.naming.MethodNameCheck"); 873 NAME_TO_FULL_MODULE_NAME.put("GoogleMethodNameCheck", 874 BASE_PACKAGE + ".checks.naming.GoogleMethodNameCheck"); 875 NAME_TO_FULL_MODULE_NAME.put("MethodTypeParameterNameCheck", 876 BASE_PACKAGE + ".checks.naming.MethodTypeParameterNameCheck"); 877 NAME_TO_FULL_MODULE_NAME.put("PackageNameCheck", 878 BASE_PACKAGE + ".checks.naming.PackageNameCheck"); 879 NAME_TO_FULL_MODULE_NAME.put("ParameterNameCheck", 880 BASE_PACKAGE + ".checks.naming.ParameterNameCheck"); 881 NAME_TO_FULL_MODULE_NAME.put("RecordComponentNameCheck", 882 BASE_PACKAGE + ".checks.naming.RecordComponentNameCheck"); 883 NAME_TO_FULL_MODULE_NAME.put("RecordTypeParameterNameCheck", 884 BASE_PACKAGE + ".checks.naming.RecordTypeParameterNameCheck"); 885 NAME_TO_FULL_MODULE_NAME.put("StaticVariableNameCheck", 886 BASE_PACKAGE + ".checks.naming.StaticVariableNameCheck"); 887 NAME_TO_FULL_MODULE_NAME.put("TypeNameCheck", 888 BASE_PACKAGE + ".checks.naming.TypeNameCheck"); 889 NAME_TO_FULL_MODULE_NAME.put("PatternVariableNameCheck", 890 BASE_PACKAGE + ".checks.naming.PatternVariableNameCheck"); 891 NAME_TO_FULL_MODULE_NAME.put("IllegalIdentifierNameCheck", 892 BASE_PACKAGE + ".checks.naming.IllegalIdentifierNameCheck"); 893 } 894 895 /** 896 * Fill short-to-full module names map with Checks from regexp package. 897 */ 898 private static void fillChecksFromRegexpPackage() { 899 NAME_TO_FULL_MODULE_NAME.put("RegexpCheck", 900 BASE_PACKAGE + ".checks.regexp.RegexpCheck"); 901 NAME_TO_FULL_MODULE_NAME.put("RegexpMultilineCheck", 902 BASE_PACKAGE + ".checks.regexp.RegexpMultilineCheck"); 903 NAME_TO_FULL_MODULE_NAME.put("RegexpOnFilenameCheck", 904 BASE_PACKAGE + ".checks.regexp.RegexpOnFilenameCheck"); 905 NAME_TO_FULL_MODULE_NAME.put("RegexpSinglelineCheck", 906 BASE_PACKAGE + ".checks.regexp.RegexpSinglelineCheck"); 907 NAME_TO_FULL_MODULE_NAME.put("RegexpSinglelineJavaCheck", 908 BASE_PACKAGE + ".checks.regexp.RegexpSinglelineJavaCheck"); 909 } 910 911 /** 912 * Fill short-to-full module names map with Checks from sizes package. 913 */ 914 private static void fillChecksFromSizesPackage() { 915 NAME_TO_FULL_MODULE_NAME.put("AnonInnerLengthCheck", 916 BASE_PACKAGE + ".checks.sizes.AnonInnerLengthCheck"); 917 NAME_TO_FULL_MODULE_NAME.put("ExecutableStatementCountCheck", 918 BASE_PACKAGE + ".checks.sizes.ExecutableStatementCountCheck"); 919 NAME_TO_FULL_MODULE_NAME.put("FileLengthCheck", 920 BASE_PACKAGE + ".checks.sizes.FileLengthCheck"); 921 NAME_TO_FULL_MODULE_NAME.put("LambdaBodyLengthCheck", 922 BASE_PACKAGE + ".checks.sizes.LambdaBodyLengthCheck"); 923 NAME_TO_FULL_MODULE_NAME.put("LineLengthCheck", 924 BASE_PACKAGE + ".checks.sizes.LineLengthCheck"); 925 NAME_TO_FULL_MODULE_NAME.put("MethodCountCheck", 926 BASE_PACKAGE + ".checks.sizes.MethodCountCheck"); 927 NAME_TO_FULL_MODULE_NAME.put("MethodLengthCheck", 928 BASE_PACKAGE + ".checks.sizes.MethodLengthCheck"); 929 NAME_TO_FULL_MODULE_NAME.put("OuterTypeNumberCheck", 930 BASE_PACKAGE + ".checks.sizes.OuterTypeNumberCheck"); 931 NAME_TO_FULL_MODULE_NAME.put("ParameterNumberCheck", 932 BASE_PACKAGE + ".checks.sizes.ParameterNumberCheck"); 933 NAME_TO_FULL_MODULE_NAME.put("RecordComponentNumberCheck", 934 BASE_PACKAGE + ".checks.sizes.RecordComponentNumberCheck"); 935 } 936 937 /** 938 * Fill short-to-full module names map with Checks from whitespace package. 939 */ 940 private static void fillChecksFromWhitespacePackage() { 941 NAME_TO_FULL_MODULE_NAME.put("ArrayBracketNoWhitespaceCheck", 942 BASE_PACKAGE + ".checks.whitespace.ArrayBracketNoWhitespaceCheck"); 943 NAME_TO_FULL_MODULE_NAME.put("EmptyForInitializerPadCheck", 944 BASE_PACKAGE + ".checks.whitespace.EmptyForInitializerPadCheck"); 945 NAME_TO_FULL_MODULE_NAME.put("EmptyForIteratorPadCheck", 946 BASE_PACKAGE + ".checks.whitespace.EmptyForIteratorPadCheck"); 947 NAME_TO_FULL_MODULE_NAME.put("EmptyLineSeparatorCheck", 948 BASE_PACKAGE + ".checks.whitespace.EmptyLineSeparatorCheck"); 949 NAME_TO_FULL_MODULE_NAME.put("EmptyLineWrappingInBlockCheck", 950 BASE_PACKAGE + ".checks.whitespace.EmptyLineWrappingInBlockCheck"); 951 NAME_TO_FULL_MODULE_NAME.put("FileTabCharacterCheck", 952 BASE_PACKAGE + ".checks.whitespace.FileTabCharacterCheck"); 953 NAME_TO_FULL_MODULE_NAME.put("GenericWhitespaceCheck", 954 BASE_PACKAGE + ".checks.whitespace.GenericWhitespaceCheck"); 955 NAME_TO_FULL_MODULE_NAME.put("MethodParamPadCheck", 956 BASE_PACKAGE + ".checks.whitespace.MethodParamPadCheck"); 957 NAME_TO_FULL_MODULE_NAME.put("NoLineWrapCheck", 958 BASE_PACKAGE + ".checks.whitespace.NoLineWrapCheck"); 959 NAME_TO_FULL_MODULE_NAME.put("NoWhitespaceAfterCheck", 960 BASE_PACKAGE + ".checks.whitespace.NoWhitespaceAfterCheck"); 961 NAME_TO_FULL_MODULE_NAME.put("NoWhitespaceBeforeCheck", 962 BASE_PACKAGE + ".checks.whitespace.NoWhitespaceBeforeCheck"); 963 NAME_TO_FULL_MODULE_NAME.put("NoWhitespaceBeforeCaseDefaultColonCheck", 964 BASE_PACKAGE + ".checks.whitespace.NoWhitespaceBeforeCaseDefaultColonCheck"); 965 NAME_TO_FULL_MODULE_NAME.put("OpenjdkMethodParameterAlignmentCheck", 966 BASE_PACKAGE + ".checks.whitespace.OpenjdkMethodParameterAlignmentCheck"); 967 NAME_TO_FULL_MODULE_NAME.put("OperatorWrapCheck", 968 BASE_PACKAGE + ".checks.whitespace.OperatorWrapCheck"); 969 NAME_TO_FULL_MODULE_NAME.put("ParenPadCheck", 970 BASE_PACKAGE + ".checks.whitespace.ParenPadCheck"); 971 NAME_TO_FULL_MODULE_NAME.put("SeparatorWrapCheck", 972 BASE_PACKAGE + ".checks.whitespace.SeparatorWrapCheck"); 973 NAME_TO_FULL_MODULE_NAME.put("SingleSpaceSeparatorCheck", 974 BASE_PACKAGE + ".checks.whitespace.SingleSpaceSeparatorCheck"); 975 NAME_TO_FULL_MODULE_NAME.put("TypeBodyPaddingCheck", 976 BASE_PACKAGE + ".checks.whitespace.TypeBodyPaddingCheck"); 977 NAME_TO_FULL_MODULE_NAME.put("TypecastParenPadCheck", 978 BASE_PACKAGE + ".checks.whitespace.TypecastParenPadCheck"); 979 NAME_TO_FULL_MODULE_NAME.put("WhitespaceAfterCheck", 980 BASE_PACKAGE + ".checks.whitespace.WhitespaceAfterCheck"); 981 NAME_TO_FULL_MODULE_NAME.put("WhitespaceAroundCheck", 982 BASE_PACKAGE + ".checks.whitespace.WhitespaceAroundCheck"); 983 NAME_TO_FULL_MODULE_NAME.put("WhitespaceBeforeEmptyBodyCheck", 984 BASE_PACKAGE + ".checks.whitespace.WhitespaceBeforeEmptyBodyCheck"); 985 } 986 987 /** 988 * Fill short-to-full module names map with modules from checks package. 989 */ 990 private static void fillModulesFromChecksPackage() { 991 NAME_TO_FULL_MODULE_NAME.put("ArrayTypeStyleCheck", 992 BASE_PACKAGE + ".checks.ArrayTypeStyleCheck"); 993 NAME_TO_FULL_MODULE_NAME.put("AvoidEscapedUnicodeCharactersCheck", 994 BASE_PACKAGE + ".checks.AvoidEscapedUnicodeCharactersCheck"); 995 NAME_TO_FULL_MODULE_NAME.put("DescendantTokenCheck", 996 BASE_PACKAGE + ".checks.DescendantTokenCheck"); 997 NAME_TO_FULL_MODULE_NAME.put("FinalParametersCheck", 998 BASE_PACKAGE + ".checks.FinalParametersCheck"); 999 NAME_TO_FULL_MODULE_NAME.put("NewlineAtEndOfFileCheck", 1000 BASE_PACKAGE + ".checks.NewlineAtEndOfFileCheck"); 1001 NAME_TO_FULL_MODULE_NAME.put("LineEndingCheck", 1002 BASE_PACKAGE + ".checks.LineEndingCheck"); 1003 NAME_TO_FULL_MODULE_NAME.put("MultilineCommentLeadingAsteriskPresenceCheck", 1004 BASE_PACKAGE + ".checks.MultilineCommentLeadingAsteriskPresenceCheck"); 1005 NAME_TO_FULL_MODULE_NAME.put("NoCodeInFileCheck", 1006 BASE_PACKAGE + ".checks.NoCodeInFileCheck"); 1007 NAME_TO_FULL_MODULE_NAME.put("OuterTypeFilenameCheck", 1008 BASE_PACKAGE + ".checks.OuterTypeFilenameCheck"); 1009 NAME_TO_FULL_MODULE_NAME.put("OrderedPropertiesCheck", 1010 BASE_PACKAGE + ".checks.OrderedPropertiesCheck"); 1011 NAME_TO_FULL_MODULE_NAME.put("SuppressWarningsHolder", 1012 BASE_PACKAGE + ".checks.SuppressWarningsHolder"); 1013 NAME_TO_FULL_MODULE_NAME.put("TodoCommentCheck", 1014 BASE_PACKAGE + ".checks.TodoCommentCheck"); 1015 NAME_TO_FULL_MODULE_NAME.put("TrailingCommentCheck", 1016 BASE_PACKAGE + ".checks.TrailingCommentCheck"); 1017 NAME_TO_FULL_MODULE_NAME.put("TranslationCheck", 1018 BASE_PACKAGE + ".checks.TranslationCheck"); 1019 NAME_TO_FULL_MODULE_NAME.put("UncommentedMainCheck", 1020 BASE_PACKAGE + ".checks.UncommentedMainCheck"); 1021 NAME_TO_FULL_MODULE_NAME.put("UniquePropertiesCheck", 1022 BASE_PACKAGE + ".checks.UniquePropertiesCheck"); 1023 NAME_TO_FULL_MODULE_NAME.put("UpperEllCheck", 1024 BASE_PACKAGE + ".checks.UpperEllCheck"); 1025 NAME_TO_FULL_MODULE_NAME.put("HexLiteralCaseCheck", 1026 BASE_PACKAGE + ".checks.HexLiteralCaseCheck"); 1027 NAME_TO_FULL_MODULE_NAME.put("NumericalPrefixesInfixesSuffixesCharacterCaseCheck", 1028 BASE_PACKAGE + ".checks.NumericalPrefixesInfixesSuffixesCharacterCaseCheck"); 1029 } 1030 1031 /** 1032 * Fill short-to-full module names map with modules from filefilters package. 1033 */ 1034 private static void fillModulesFromFilefiltersPackage() { 1035 NAME_TO_FULL_MODULE_NAME.put("BeforeExecutionExclusionFileFilter", 1036 BASE_PACKAGE + ".filefilters.BeforeExecutionExclusionFileFilter"); 1037 } 1038 1039 /** 1040 * Fill short-to-full module names map with modules from filters package. 1041 */ 1042 private static void fillModulesFromFiltersPackage() { 1043 NAME_TO_FULL_MODULE_NAME.put("SeverityMatchFilter", 1044 BASE_PACKAGE + ".filters.SeverityMatchFilter"); 1045 NAME_TO_FULL_MODULE_NAME.put("SuppressWithPlainTextCommentFilter", 1046 BASE_PACKAGE + ".filters.SuppressWithPlainTextCommentFilter"); 1047 NAME_TO_FULL_MODULE_NAME.put("SuppressionCommentFilter", 1048 BASE_PACKAGE + ".filters.SuppressionCommentFilter"); 1049 NAME_TO_FULL_MODULE_NAME.put("SuppressionFilter", 1050 BASE_PACKAGE + ".filters.SuppressionFilter"); 1051 NAME_TO_FULL_MODULE_NAME.put("SuppressionSingleFilter", 1052 BASE_PACKAGE + ".filters.SuppressionSingleFilter"); 1053 NAME_TO_FULL_MODULE_NAME.put("SuppressionXpathFilter", 1054 BASE_PACKAGE + ".filters.SuppressionXpathFilter"); 1055 NAME_TO_FULL_MODULE_NAME.put("SuppressionXpathSingleFilter", 1056 BASE_PACKAGE + ".filters.SuppressionXpathSingleFilter"); 1057 NAME_TO_FULL_MODULE_NAME.put("SuppressWarningsFilter", 1058 BASE_PACKAGE + ".filters.SuppressWarningsFilter"); 1059 NAME_TO_FULL_MODULE_NAME.put("SuppressWithNearbyCommentFilter", 1060 BASE_PACKAGE + ".filters.SuppressWithNearbyCommentFilter"); 1061 NAME_TO_FULL_MODULE_NAME.put("SuppressWithNearbyTextFilter", 1062 BASE_PACKAGE + ".filters.SuppressWithNearbyTextFilter"); 1063 } 1064 1065 /** 1066 * Fill short-to-full module names map with modules from checkstyle package. 1067 */ 1068 private static void fillModulesFromCheckstylePackage() { 1069 NAME_TO_FULL_MODULE_NAME.put("Checker", BASE_PACKAGE + ".Checker"); 1070 NAME_TO_FULL_MODULE_NAME.put("TreeWalker", BASE_PACKAGE + ".TreeWalker"); 1071 } 1072 1073}