All Classes and Interfaces
Class
Description
Validates abbreviations (consecutive capital letters) length in
identifier name, it also allows to enforce camel case naming.
Abstract class for checking a class member (field/method)'s name conforms to
a specified pattern.
The base class for checks.
Base class for coupling calculation.
Ensures that the names of abstract classes conforming to some regular
expression and check that
abstract modifier exists.Abstract base class for all handlers.
Provides common functionality for many FileSetChecks.
Abstract super class for header checks.
Base class for Checks that process Javadoc comments.
Abstract class for checking that names conform to a specified format.
Represents general class for
ElementNode, RootNode and AttributeNode.Abstract class for checking the padding of parentheses.
Abstract class for checking that an overriding method with no parameters
invokes the super method.
Serves as an abstract base class for all modules that report inspection
findings.
This enum represents access modifiers.
Checks location of annotation on language elements.
Checks that annotations are located on the same line with their targets.
Checks the style of elements in annotations.
Defines the two styles for defining
elements in an annotation.
Defines the styles for defining elements in an annotation.
Defines the two styles for defining
elements in an annotation.
Contains utility methods designed to work with annotations.
Checks for long anonymous inner classes.
Handler for array initialization blocks.
Checks that array initialization contains a trailing comma.
Checks the style of array type definitions.
Class for printing AST to String.
Checks the order of
javadoc block-tags or javadoc tags.
Represents attribute of the element.
Raw event for audit.
Represents the default formatter for log message.
Represents the formatter interface for log message.
Listener in charge of receiving events from the Checker.
A Java Bean that implements the component lifecycle interfaces by
calling the bean's setters for all configuration attributes.
Enum to specify behaviour regarding ignored modules.
Detects double brace initialization.
Restricts using
Unicode escapes
(such as \u221e).
Detects inline conditionals.
Finds nested blocks (blocks that are used freely in the code).
Checks if call to superclass constructor without arguments is present.
Checks that there are no import statements that use the
* notation.
Checks that there are no static import statements.
A base class for CellEditors, providing default implementations for all
methods in the CellEditor interface and support for managing a series
of listeners.
File filter
BeforeExecutionExclusionFileFilter decides which files should be
excluded from being processed by the utility.An interface for before execution file filtering events.
A before execution file filter set applies filters to events.
Utility class that has methods to check javadoc comment position in java file.
Represents the policy for checking block statements.
Handler for parents of blocks ('if', 'else', 'while', etc).
Tools for parsing block tags from a Javadoc comment.
Restricts the number of boolean operators (
&&, ||,
&, | and ^) in an expression.Handler for case statements.
Handler for catch blocks.
Checks that
catch parameter names conform to a specified pattern.This class provides the functionality to check a set of files.
An implementation of a ANT task for calling checkstyle.
Details about a formatter to be used.
Poor mans enumeration for the formatter types.
Represents a custom listener.
Represents a property that consists of a key and value.
Represents an error condition within Checkstyle.
Contains utility methods for the checks.
Measures the number of instantiations of other classes
within the given class or record.
Handler for class definitions.
Checks the number of other types a given class/record/interface/enum/annotation
relies on.
Checks for implicit modifiers on nested types in classes and records.
Checks that class type parameter names conform to a specified pattern.
Helper class to select a code.
Presentation model for CodeSelector.
Representation of the comment block.
This interface is used to be notified by parser about comments
in the parsed code.
Controls the indentation between comments and surrounding code.
Contains utility methods.
A component that can be configured.
A Configuration is used to configure a Configurable component.
Loads a configuration from a standard configuration XML file.
Enum to specify behaviour regarding ignored modules.
Checks that constant names conform to a specified pattern.
A context to be used in subcomponents.
A Component that needs context information from it's container(parent object) to work.
Checks that classes and records which define a covariant
equals() method
also override method equals(Object).
Checks that the groups of import declarations appear in the order specified
by the user.
Checks cyclomatic complexity against a specified limit.
Checks that the parts of a class, record, or interface declaration appear in the order
suggested by the
Code Conventions for the Java Programming Language.
Check that the
default is after all the cases in a switch statement.Default implementation of the Configuration interface.
A default implementation of the Context interface.
Simple plain logger for text output.
Contains constant definitions common to the package.
Checks for restricted tokens beneath other tokens.
Checks that classes are designed for extension (subclass creation).
A interface of Checkstyle's AST nodes for traversing trees generated from the
Java code.
The implementation of
DetailAST.Represents a set of abstract syntax tree.
DetailNode is used to construct tree during parsing Javadoc comments.
Parses file as javadoc DetailNode tree and prints to system output stream.
Options for a detector.
Handler for do...while blocks.
Represents element node of Xpath-tree.
Handler for else blocks.
Checks for empty blocks.
Checks for empty catch blocks.
Checks the padding of an empty for initializer; that is whether a white
space is required at an empty for initializer, or such white space is
forbidden.
Checks the padding of an empty for iterator; that is whether a white
space is required at an empty for iterator, or such white space is
forbidden.
Checks for empty line separators after header, package, all import declarations,
fields, constructors, methods, nested classes,
static initializers and instance initializers.
Detects empty statements (standalone
";" semicolon).
Checks that any combination of String literals
is on the left side of an
equals() comparison.
Checks that classes that either override
equals() or hashCode() also
overrides the other.
Restricts the number of executable statements to a specified limit.
Checks if any class or object member is explicitly initialized
to default for its type value (
null for object
references, zero for numeric types and char
and false for boolean.The following interface should be implemented by each module (inheritor of
AbstractCheck, implementor of FileSetCheck, or Filter) which uses
external resources of any kind for its configuration.
Checks for fall-through in
switch statements.Represents the contents of a file.
Checks for long source files.
Interface for Checking a set of files for some criteria.
This annotation means that the check contains file-related context and therefore
cannot be used from the others threads at the same time.
Checks that there are no tab characters (
'\t') in the source code.Represents the text contents of a file of arbitrary plain text type.
An interface for filtering AuditEvents.
A filter set applies filters to AuditEvents.
Utility methods for suppression filters.
Checks that a class which has only private constructors
is declared as final.
Checks that local variables that never have their values changed are declared final.
Handler for finally blocks.
Checks that parameters for methods, constructors, catch and for-each blocks are final.
Handler for for loops.
Represents a full identifier, including dots, with associated
position information.
Java 1.5 Recognizer
This grammar is in the PUBLIC DOMAIN
Checks that the whitespace around the Generic tokens (angle brackets)
"<" and ">" are correct to the typical convention.
This annotation means that the check contains global context,
which will be updated while Checkstyle processes files.
Factory for handlers.
Checks that a source file begins with a specified header.
Checks that a local variable or a parameter does not shadow
a field that is defined in the same class.
Makes sure that utility classes (classes that contain only static methods or fields in their API)
do not have a public constructor.
Handler for if statements.
Checks that certain exception types do not appear in a
catch statement.
Checks identifiers with a regular expression for a set of illegal names, such as those
that are restricted or contextual keywords.
Checks for imports from a set of illegal packages.
Checks for illegal instantiations where a factory method is preferred.
Checks that specified types are not declared to be thrown.
Checks for illegal tokens.
Checks specified tokens text for matching an illegal pattern.
Checks that particular classes or interfaces are never used.
Controls what can be imported in each package and file.
Responsible for loading the contents of an import control configuration file.
Handler for import statements.
Checks the ordering/grouping of imports.
Represents the policy for checking import order statements.
Checks correct indentation of Java code.
Encapsulates representation of notion of expected indentation levels.
Handler for array index operation.
Tools for extracting inline tags from Javadoc comments.
Checks for assignments in subexpressions, such as in
String s = Integer.toString(i = 2);.
Checks nested (internal) classes/interfaces are declared at the bottom of the
primary (top-level) class after all init and static init blocks,
method, constructor and field declarations.
Implements Joshua Bloch, Effective Java, Item 17 -
Use Interfaces only to define types.
Checks for implicit modifiers on interface members and nested types.
Checks that interface type parameter names conform to a specified pattern.
Checks that Javadocs are located at the correct position.
Value object for storing data about an invalid Javadoc validTags.
Checks that a
javadoc block tag appears only at the beginning of a line, ignoring
leading asterisks and white space.
Checks that the Javadoc content begins from the same position
for all Javadoc comments in the project.
Represents the locations for the javadoc content.
Used for parsing Javadoc comment as DetailNode tree.
Contains information about parse error message.
Contains result of parsing javadoc comment: DetailNode tree and parse
error message.
Class for scraping module metadata from the corresponding class' class-level javadoc.
Checks the Javadoc of a method or constructor.
Checks that there is at least one whitespace after the leading asterisk.
Implementation of DetailNode interface that is mutable.
Checks that each Java package has a Javadoc file used for commenting.
Checks the Javadoc paragraph.
This class is used internally in the build process to write a property file
with short descriptions (the first sentences) of TokenTypes constants.
Validates Javadoc comments to help ensure they are well formed.
Represents a Javadoc tag.
Checks the indentation of the continuation lines in at-clauses.
This enum defines the various Javadoc tags and there properties.
The Javadoc Type.
Value object for combining the list of valid validTags with information
about invalid validTags encountered in a certain Javadoc comment.
Contains the constants for all the tokens contained in the Abstract
Syntax Tree for the javadoc grammar.
Checks the Javadoc comments for annotation/enum/class/interface definitions.
Contains utility methods for working with Javadoc.
The type of Javadoc tag we want returned.
Checks that a variable has a Javadoc comment.
Determines complexity of methods, classes and files by counting
the Non Commenting Source Statements (NCSS).
Helper methods to parse java source files.
Enum to be used for test if comments should be used.
Handler for labels.
Handler for lambda expressions.
Checks lambda parameter names.
Checks for the placement of left curly braces (
'{') for code blocks.Represents the options for placing the left curly brace
'{'.Immutable line and column numbers.
Checks for long lines.
Represents the options for line separator settings.
This class checks line-wrapping into definitions and expressions.
Enum to be used for test if first line's indentation should be checked or not.
Checks that local final variable names conform to a specified pattern.
Represents a message that can be localised.
Custom ResourceBundle.Control implementation which allows explicitly read
the properties files as UTF-8.
Checks that local, non-
final variable names conform to a specified pattern.
Checks that there are no
"magic numbers" where a magic
number is a numeric literal that is not defined as a constant.
Entry point for starting the checkstyle GUI.
Wrapper command line program for the Checker.
Displays information about a parse tree.
Model for checkstyle frame.
Parsing modes which available in GUI.
Represents a suppressor for matches.
Handler for member definitions.
Checks that instance variable names conform to a specified pattern.
Used by FileSetChecks to distribute AuditEvents to AuditListeners.
Class which handles all the metadata generation and writing calls.
Handler for method calls.
Checks the number of methods declared in each type declaration by access modifier
or total count.
Handler for method definitions.
Checks for long methods and constructors.
Checks that method names conform to a specified pattern.
Checks the padding between the identifier of a method definition,
constructor definition, method call, or constructor invocation;
and the left parenthesis of the parameter list.
Checks that method type parameter names conform to a specified pattern.
Represents the strategy when none of the rules (allow/disallow tags) match
inside subpackage and import-control tag of ImportControlCheck config.
Checks that classes (except abstract ones) define a constructor and don't rely
on the default one.
Verifies that the annotation
@Deprecated and the Javadoc tag
@deprecated are both present when either of them is present.
Checks for missing Javadoc comments for a method or constructor.
Checks for missing Javadoc comments in package-info.java files.
Checks for missing Javadoc comments for class, enum, interface, and annotation interface
definitions.
Verifies that the
@Override annotation is present
when the @inheritDoc javadoc tag is present.
Checks that switch statement has a
default clause.
Checks that for loop control variables are not modified
inside the for block.
Checks that the order of modifiers conforms to the suggestions in the
Java Language specification, § 8.1.1, 8.3.1, 8.4.3 and
9.4.
Simple POJO class for module details.
A module factory creates Objects from a given name.
Simple POJO class module's property details.
Contains utility methods for module reflection.
Enum holding the types of module which can exist.
Checks for multiple occurrences of the same string literal within a single file.
Checks that each variable declaration is in its own statement
and on its own line.
Ensures that exception classes (classes with names conforming to some regular
expression and explicitly extending classes with names conforming to other
regular expression) are immutable, that is, that they have only final fields.
Checks for braces around code blocks.
Restricts nested
for blocks to a specified depth.
Restricts nested if-else blocks to a specified depth.
Restricts nested try-catch-finally blocks to a specified depth.
An implementation of
MatchSuppressor that never suppresses a
match.Handler for operator new.
Checks whether files end with a line separator.
Checks that array initialization do not contain a trailing comma.
Checks that the clone method is not overridden from the
Object class.
Checks whether file contains code.
Checks that enum definition does not contain a trailing comma.
Checks that there is no method
finalize with zero parameters.Checks that chosen statements are not line-wrapped.
Checks that the at-clause tag is followed by description.
Checks that there is no whitespace after a token.
Checks that there is no whitespace before a token.
Checks the NPATH complexity against a specified limit.
Handler for inner classes.
Checks that there is only one statement per line.
Checks that each top-level class, interface, enum
or annotation resides in a source file of its own.
Checks the policy on how to wrap lines on operators.
Detects if keys in properties files are in correct order.
Checks that the outer type name and the file name match.
Checks for the number of types declared at the outer (or root) level in a file.
Checks that overloaded methods are grouped together.
Checks that all package annotations are in the package-info.java file.
Ensures that a class has a package declaration, and (optionally) whether
the package name matches the directory name for the source file.
Handler for package definitions.
Checks that package names conform to a specified pattern.
Loads a list of package names from a package name XML file.
A factory for creating objects from package names and names.
Enum class to define loading options.
Represents the options for whitespace around parentheses.
Disallows assignment of parameters.
Checks that method parameter names conform to a specified pattern.
Checks the number of parameters of a method or constructor.
Checks the policy on the padding of parentheses; that is whether a space is required
after a left parenthesis and before a right parenthesis, or such spaces are
forbidden.
The model that backs the parse tree in the GUI.
The model that backs the parse tree in the GUI.
Checks that pattern variable names conform to a specified pattern.
A default no-op handler.
Resolves external properties from an
underlying
Properties object.This class maintains a persistent(on file-system) store of the files
that have checked ok(no validation events) and their associated
timestamp.
Resolves properties in module configurations.
Checks the number of record components in the
header of a record definition.
Checks that record type parameter names conform to a specified pattern.
Checks for redundant import statements.
Checks for redundant modifiers.
Checks that a specified pattern exists, exists less than
a set number of times, or does not exist in the file.
Checks the header of a source file against a header that contains a
regular expression for each line of the source header.
Checks that a specified pattern matches across multiple lines in any file type.
Checks that a specified pattern matches based on file and/or folder path.
Checks that a specified pattern matches a single line in any file type.
Checks that a specified pattern matches a single line in Java files.
Checks that one blank line before the block tag if it is present in Javadoc.
Checks that references to instance variables and methods of the present
object are explicitly of the form "this.varName" or "this.methodName(args)"
and that those references don't rely on the default behavior when "this." is absent.
Restricts the number of return statements in methods, constructors and lambda expressions.
Checks the placement of right curly braces (
''}) for code blocks.Represents the options for placing the right curly brace
'}'.The first module that is run as part of Checkstyle and controls its entire
behavior and children.
Represents root node of Xpath-tree.
Represents a Java visibility scope.
Contains utility methods for working on scope.
Checks line wrapping with separators.
Severity level for a check violation.
An audit listener that counts how many
AuditEvents
of a given severity have been generated.
Filter
SeverityMatchFilter decides audit events according to the
severity level of the event.
Checks for over-complicated boolean expressions.
Checks for over-complicated boolean return statements.
Checks that a Javadoc block can fit in a single line and doesn't contain at-clauses.
Checks that non-whitespace characters are separated by no more than one
whitespace.
Handler for a list of statements.
This annotation means that the check does not contain mutable state and
may be safely used from others threads at the same time.
Handler for static initialization blocks.
Checks that
static, non-final variable names conform to a specified pattern.
Checks that string literals are not used with
== or !=.
Checks that
Javadoc summary sentence does not contain phrases that are not recommended to use.
Checks that an overriding
clone() method invokes super.clone().
Checks that an overriding
finalize() method invokes super.finalize().This filter element is immutable and processes
AuditEvent
objects based on the criteria of file, check, module id, line, and
column.
Filter
SuppressionCommentFilter uses pairs of comments to suppress audit events.Enum to be used for switching checkstyle reporting for tags.
Filter
SuppressionFilter rejects audit events for Check violations according to a
suppressions XML document
in a file.
Filter
SuppressionSingleFilter suppresses audit events for Checks violations in the
specified file, class, checks, message, module id, lines, and columns.Loads a filter chain of suppressions.
Class for constructing xpath queries to suppress nodes
with specified line and column number.
Filter
SuppressionXpathFilter works as
SuppressionFilter.
Filter
SuppressionXpathSingleFilter suppresses audit events for Checks
violations in the specified file, class, checks, message, module id, and xpath.
Allows to specify what warnings that
@SuppressWarnings is not allowed to suppress.
Filter
SuppressWarningsFilter uses annotation
SuppressWarnings to suppress audit events.
Maintains a set of check suppressions from
@SuppressWarnings annotations.
Filter
SuppressWithNearbyCommentFilter uses nearby comments to suppress audit events.
Filter
SuppressWithPlainTextCommentFilter uses plain text to suppress
audit events.Handler for switch statements.
Handler for switch rules.
Handler for synchronized statements.
Value object for storing data about a parsed tag.
A block of text from an input file that does not necessarily
have any grammatical structure.
Thread mode settings for the checkstyle modules.
Restricts throws statements to a specified count.
Checks for
TODO: comments.Contains the constants for all the tokens contained in the Abstract
Syntax Tree.
Contains utility methods for tokens.
The check to ensure that requires that comments be the only thing on a line.
Ensures the correct translation of code by checking property files for consistency
regarding their keys.
This example shows how to create a simple TreeTable component,
by using a JTree as a renderer (and editor) for the cells in a
particular column in the JTable.
This is a wrapper class takes a TreeTableModel and implements
the table model interface.
Responsible for walking an abstract syntax tree and notifying interested
checks at each each node.
Raw
TreeWalker event for audit.An interface for filtering
TreeWalkerAuditEvent.Handler for try blocks.
Checks the policy on the padding of parentheses for typecasts.
Checks that type names conform to a specified pattern.
Detects uncommented
main methods.
Detects duplicated keys in properties files.
Checks if unnecessary parentheses are used in a statement or expression.
Checks if unnecessary semicolon is used after type declaration.
Checks if unnecessary semicolon is used after type member declaration.
Checks if unnecessary semicolon is in enum definitions.
Checks if unnecessary semicolon is used in last resource declaration.
Checks for unused import statements.
Checks that long constants are defined with an upper ell.
Checks the distance between declaration of variable and its first usage.
Checks visibility of class members.
Handler for while loops.
Checks that a token is followed by whitespace, with the exception that it
does not check for whitespace after the semicolon of an empty for iterator.
Checks that a token is surrounded by whitespace.
Represents the options for wrapping on an operator.
Requires user defined Javadoc tag to be present in Javadoc comment with defined format.
Contains the common implementation of a loader, for loading a configuration
from an XML file.
Used for setting specific for secure java installations features to SAXParserFactory.
Simple XML logger.
Class having utilities required to read module details from an XML metadata file of a module.
Class to write module details object into an XML file.
Catches
TreeWalkerAuditEvent and generates corresponding xpath query.Generates suppressions.xml file, based on violations occurred.
This filter element is immutable and processes
TreeWalkerAuditEvent
objects based on the criteria of file, check, module id, xpathQuery.Generates xpath queries.
Contains utility methods for xpath.
Handler for yield expression.