DefaultJavaPrettyPrinter (Spoon Core 9.1.0-SNAPSHOT API)

java.lang.Object
- spoon.reflect.visitor.DefaultJavaPrettyPrinter

All Implemented Interfaces:

CtVisitor, PrettyPrinter

Direct Known Subclasses:

SniperJavaPrettyPrinter
```
public class DefaultJavaPrettyPrinter
extends java.lang.Object
implements CtVisitor, PrettyPrinter
```
A visitor for generating Java code from the program compile-time model.

Field Summary

Fields
Modifier and Type	Field and Description
`static java.lang.String`	`BLOCK_COMMENT_END` The end of a block/JavaDoc comment
`static java.lang.String`	`BLOCK_COMMENT_START` The beginning of a block comment
`static java.lang.String`	`COMMENT_STAR` The star at the beginning of a block/JavaDoc comment line
`protected Environment`	`env` Environment which Spoon is executed.
`static java.lang.String`	`ERROR_MESSAGE_TO_STRING`
`protected boolean`	`ignoreImplicit` If true: always prints fully qualified names by ignoring the isImplicit attribute of AST nodes Default value is "true" for backward compatibility.
`static java.lang.String`	`INLINE_COMMENT_START` The beginning of an inline comment
`boolean`	`inlineElseIf`
`static java.lang.String`	`JAVA_FILE_EXTENSION` Java file extension (.java).
`static java.lang.String`	`JAVA_MODULE_DECLARATION` Module declaration file name.
`static java.lang.String`	`JAVA_PACKAGE_DECLARATION` Package declaration file name.
`static java.lang.String`	`JAVADOC_START` The beginning of a JavaDoc comment
`static java.lang.String`	`LINE_SEPARATOR` Line separator which is used by the system
`protected static org.slf4j.Logger`	`LOGGER`
`protected java.util.List<Processor<CtElement>>`	`preprocessors` Handle imports of classes.
`protected CtCompilationUnit`	`sourceCompilationUnit` Compilation unit we are printing.

Constructor Summary

Constructors
Constructor and Description

DefaultJavaPrettyPrinter(Environment env)
Creates a new code generator visitor.

Constructors
Constructor and Description
`DefaultJavaPrettyPrinter(Environment env)` Creates a new code generator visitor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`applyPreProcessors(CtElement el)` Warning, this may change the state of the object
`void`	`calculate(CtCompilationUnit sourceCompilationUnit, java.util.List<CtType<?>> types)` Calculates the resulting source file for a list of types.
`protected void`	`enter(CtElement e)` This method is called by `scan(CtElement)` when entering a scanned element.
`protected void`	`enterCtExpression(CtExpression<?> e)` Enters an expression.
`protected void`	`enterCtStatement(CtStatement s)` Enters a statement.
`protected void`	`exit(CtElement e)` This method is called by `scan(CtElement)` when entering a scanned element.
`protected void`	`exitCtExpression(CtExpression<?> e)` Exits an expression.
`protected void`	`exitCtStatement(CtStatement statement)` Exits a statement.
`PrintingContext`	`getContext()`
`ElementPrinterHelper`	`getElementPrinterHelper()`
`protected ModelList<CtImport>`	`getImports(CtCompilationUnit compilationUnit)`
`java.util.Map<java.lang.Integer,java.lang.Integer>`	`getLineNumberMapping()` Gets the line number mapping between the generated code and the original code.
`java.lang.String`	`getLineSeparator()`
`java.util.List<Processor<CtElement>>`	`getPreprocessors()`
`protected TokenWriter`	`getPrinterTokenWriter()`
`java.lang.String`	`getResult()` Gets the contents of the compilation unit.
`protected boolean`	`isMinimizeRoundBrackets()`
`java.lang.String`	`prettyprint(CtElement e)` pretty-prints the element, call `#toString()` to get the result
`java.lang.String`	`printCompilationUnit(CtCompilationUnit compilationUnit)` Prints the compilation unit of module-info, package-info or types.
`java.lang.String`	`printElement(CtElement element)` Prints an element.
`java.lang.String`	`printModuleInfo(CtModule module)` Prints the module info.
`java.lang.String`	`printPackageInfo(CtPackage pack)` Prints the package info.
`java.lang.String`	`printTypes(CtType<?>... type)` Prints the types of one compilation unit It always resets the printing context at the beginning of this process.
`void`	`reset()`
`DefaultJavaPrettyPrinter`	`scan(CtElement e)` The generic scan method for an element.
`void`	`setIgnoreImplicit(boolean ignoreImplicit)`
`DefaultJavaPrettyPrinter`	`setLineSeparator(java.lang.String lineSeparator)`
`protected void`	`setMinimizeRoundBrackets(boolean minimizeRoundBrackets)` When set to true, this activates round bracket minimization for expressions.
`void`	`setPreprocessors(java.util.List<Processor<CtElement>> preprocessors)` Set preprocessors that the printer automatically runs on the model before printing it.
`DefaultJavaPrettyPrinter`	`setPrinterTokenWriter(TokenWriter tokenWriter)` Set `TokenWriter`, which has to be used to print tokens
`java.lang.String`	`toString()` Gets the currently pretty-printed string.
`<A extends java.lang.annotation.Annotation> void`	`visitCtAnnotation(CtAnnotation<A> annotation)` Visits an annotation.
`<T> void`	`visitCtAnnotationFieldAccess(CtAnnotationFieldAccess<T> annotationFieldAccess)` Visits a field of an annotation.
`<T> void`	`visitCtAnnotationMethod(CtAnnotationMethod<T> annotationMethod)` Visits an annotation method declaration.
`<A extends java.lang.annotation.Annotation> void`	`visitCtAnnotationType(CtAnnotationType<A> annotationType)` Visits an annotation type declaration.
`void`	`visitCtAnonymousExecutable(CtAnonymousExecutable impl)` Visits an anonymous executable.
`<T> void`	`visitCtArrayRead(CtArrayRead<T> arrayRead)` Visits an array read access.
`<T> void`	`visitCtArrayTypeReference(CtArrayTypeReference<T> reference)` Visits a reference to an array type.
`<T> void`	`visitCtArrayWrite(CtArrayWrite<T> arrayWrite)` Visits an array write access.
`<T> void`	`visitCtAssert(CtAssert<T> asserted)` Visits an assert.
`<T,A extends T> void`	`visitCtAssignment(CtAssignment<T,A> assignement)` Visits an assignment.
`<T> void`	`visitCtBinaryOperator(CtBinaryOperator<T> operator)` Visits a binary operator.
`<R> void`	`visitCtBlock(CtBlock<R> block)` Visits a block of code.
`void`	`visitCtBreak(CtBreak breakStatement)` Visits a `break` statement.
`<E> void`	`visitCtCase(CtCase<E> caseStatement)` Visits a `case` clause.
`void`	`visitCtCatch(CtCatch catchBlock)` Visits a `catch` clause.
`<T> void`	`visitCtCatchVariable(CtCatchVariable<T> catchVariable)` Visits a catch variable declaration.
`<T> void`	`visitCtCatchVariableReference(CtCatchVariableReference<T> reference)` Visits a reference to a catch variable.
`<T> void`	`visitCtClass(CtClass<T> ctClass)` Visits a class declaration.
`<T> void`	`visitCtCodeSnippetExpression(CtCodeSnippetExpression<T> expression)` Visits a code snippet expression.
`void`	`visitCtCodeSnippetStatement(CtCodeSnippetStatement statement)` Visits a code snippet statement.
`void`	`visitCtComment(CtComment comment)` Visits a comment
`void`	`visitCtCompilationUnit(CtCompilationUnit compilationUnit)` Visits a compilation unit
`<T> void`	`visitCtConditional(CtConditional<T> conditional)` Visits a conditional expression
`<T> void`	`visitCtConstructor(CtConstructor<T> constructor)` Visits a constructor declaration.
`<T> void`	`visitCtConstructorCall(CtConstructorCall<T> ctConstructorCall)` Visits a call to a constructor.
`void`	`visitCtContinue(CtContinue continueStatement)` Visits a `continue` statement.
`void`	`visitCtDo(CtDo doLoop)` Visits a `do` loop.
`<T extends java.lang.Enum<?>> void`	`visitCtEnum(CtEnum<T> ctEnum)` Visits an enumeration declaration.
`<T> void`	`visitCtEnumValue(CtEnumValue<T> enumValue)` Visits an enum value declaration.
`<T> void`	`visitCtExecutableReference(CtExecutableReference<T> reference)` Visits a reference to an executable.
`<T,E extends CtExpression<?>> void`	`visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression)` Visits a reference to an executable.
`<T> void`	`visitCtField(CtField<T> f)` Visits a field declaration.
`<T> void`	`visitCtFieldRead(CtFieldRead<T> fieldRead)` Visits a field read access.
`<T> void`	`visitCtFieldReference(CtFieldReference<T> reference)` Visits a reference to a field.
`<T> void`	`visitCtFieldWrite(CtFieldWrite<T> fieldWrite)` Visits a field write access.
`void`	`visitCtFor(CtFor forLoop)` Visits a `for` loop.
`void`	`visitCtForEach(CtForEach foreach)` Visits an enhanced `for` loop.
`void`	`visitCtIf(CtIf ifElement)` Visits an `if` statement.
`void`	`visitCtImport(CtImport ctImport)` Visits an import declaration
`<T> void`	`visitCtInterface(CtInterface<T> intrface)` Visits an interface declaration.
`<T> void`	`visitCtIntersectionTypeReference(CtIntersectionTypeReference<T> reference)` Visits an intersection type.
`<T> void`	`visitCtInvocation(CtInvocation<T> invocation)` Visits an executable invocation.
`void`	`visitCtJavaDoc(CtJavaDoc comment)` Visits a javadoc comment
`void`	`visitCtJavaDocTag(CtJavaDocTag docTag)` Visits a javadoc tag
`<T> void`	`visitCtLambda(CtLambda<T> lambda)` Visits an anonymous method construction.
`<T> void`	`visitCtLiteral(CtLiteral<T> literal)` Visits a literal expression.
`<T> void`	`visitCtLocalVariable(CtLocalVariable<T> localVariable)` Visits a local variable declaration.
`<T> void`	`visitCtLocalVariableReference(CtLocalVariableReference<T> reference)` Visits a reference to a local variable.
`<T> void`	`visitCtMethod(CtMethod<T> m)` Visits a method declaration.
`void`	`visitCtModule(CtModule module)` Visits a module declaration
`void`	`visitCtModuleReference(CtModuleReference moduleReference)` Visits a module reference
`void`	`visitCtModuleRequirement(CtModuleRequirement moduleRequirement)` Visits a "require" directive in a module declaration.
`<T> void`	`visitCtNewArray(CtNewArray<T> newArray)` Visits an array construction.
`<T> void`	`visitCtNewClass(CtNewClass<T> newClass)` Visits an anonymous class construction.
`<T,A extends T> void`	`visitCtOperatorAssignment(CtOperatorAssignment<T,A> assignment)` Visits an operator assignment.
`void`	`visitCtPackage(CtPackage ctPackage)` Visits a package declaration.
`void`	`visitCtPackageDeclaration(CtPackageDeclaration packageDeclaration)` Visits a package declaration
`void`	`visitCtPackageExport(CtPackageExport moduleExport)` Visits a package export in a module declaration.
`void`	`visitCtPackageReference(CtPackageReference reference)` Visits a reference to a package.
`<T> void`	`visitCtParameter(CtParameter<T> parameter)` Visits a parameter declaration.
`<T> void`	`visitCtParameterReference(CtParameterReference<T> reference)` Visits a reference to a parameter.
`void`	`visitCtProvidedService(CtProvidedService moduleProvidedService)` Visits a "provides" directive in a module declaration.
`<R> void`	`visitCtReturn(CtReturn<R> returnStatement)` Visits a `return` statement.
`void`	`visitCtStatementList(CtStatementList statements)` Visits a statement list.
`<T> void`	`visitCtSuperAccess(CtSuperAccess<T> f)` Visits an access to a super invocation.
`<E> void`	`visitCtSwitch(CtSwitch<E> switchStatement)` Visits a `switch` statement.
`<T,S> void`	`visitCtSwitchExpression(CtSwitchExpression<T,S> switchExpression)` Visits a `switch` expression.
`void`	`visitCtSynchronized(CtSynchronized synchro)` Visits a `synchronized` modifier.
`void`	`visitCtTextBlock(CtTextBlock ctTextBlock)` Visits a literal TextBlock string.
`<T> void`	`visitCtThisAccess(CtThisAccess<T> thisAccess)` Visits a this access.
`void`	`visitCtThrow(CtThrow throwStatement)` Visits a `throw` statement.
`void`	`visitCtTry(CtTry tryBlock)` Visits a `try` statement.
`void`	`visitCtTryWithResource(CtTryWithResource tryWithResource)` Visits a `try` with resource statement.
`<T> void`	`visitCtTypeAccess(CtTypeAccess<T> typeAccess)` Visits a type access.
`void`	`visitCtTypeMemberWildcardImportReference(CtTypeMemberWildcardImportReference wildcardReference)` Visits an import wildcard static type member reference
`void`	`visitCtTypeParameter(CtTypeParameter typeParameter)` Visits a type parameter declaration.
`void`	`visitCtTypeParameterReference(CtTypeParameterReference ref)` Visits a reference to a type parameter.
`<T> void`	`visitCtTypeReference(CtTypeReference<T> ref)` Visits a reference to a type.
`<T> void`	`visitCtUnaryOperator(CtUnaryOperator<T> operator)` Visits a unary operator.
`<T> void`	`visitCtUnboundVariableReference(CtUnboundVariableReference<T> reference)` Visits a reference to an unbound field
`void`	`visitCtUsedService(CtUsedService usedService)` Visits a "uses" directive in a module declaration.
`<T> void`	`visitCtVariableRead(CtVariableRead<T> variableRead)` Visits a variable read access.
`<T> void`	`visitCtVariableWrite(CtVariableWrite<T> variableWrite)` Visits a variable write access.
`void`	`visitCtWhile(CtWhile whileLoop)` Visits a `while` loop.
`void`	`visitCtWildcardReference(CtWildcardReference wildcardReference)` Visits a reference to a wildcard.
`void`	`visitCtYieldStatement(CtYieldStatement statement)` Visits a yield statement.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - JAVA_FILE_EXTENSION
```
public static final java.lang.String JAVA_FILE_EXTENSION
```
    Java file extension (.java).
    
    See Also:
    
    Constant Field Values
  - JAVA_PACKAGE_DECLARATION
```
public static final java.lang.String JAVA_PACKAGE_DECLARATION
```
    Package declaration file name.
    
    See Also:
    
    Constant Field Values
  - JAVA_MODULE_DECLARATION
```
public static final java.lang.String JAVA_MODULE_DECLARATION
```
    Module declaration file name.
    
    See Also:
    
    Constant Field Values
  - LINE_SEPARATOR
```
public static final java.lang.String LINE_SEPARATOR
```
    Line separator which is used by the system
  - COMMENT_STAR
```
public static final java.lang.String COMMENT_STAR
```
    The star at the beginning of a block/JavaDoc comment line
    
    See Also:
    
    Constant Field Values
  - BLOCK_COMMENT_END
```
public static final java.lang.String BLOCK_COMMENT_END
```
    The end of a block/JavaDoc comment
    
    See Also:
    
    Constant Field Values
  - JAVADOC_START
```
public static final java.lang.String JAVADOC_START
```
    The beginning of a JavaDoc comment
    
    See Also:
    
    Constant Field Values
  - INLINE_COMMENT_START
```
public static final java.lang.String INLINE_COMMENT_START
```
    The beginning of an inline comment
    
    See Also:
    
    Constant Field Values
  - BLOCK_COMMENT_START
```
public static final java.lang.String BLOCK_COMMENT_START
```
    The beginning of a block comment
    
    See Also:
    
    Constant Field Values
  - preprocessors
```
protected final java.util.List<Processor<CtElement>> preprocessors
```
    Handle imports of classes.
  - env
```
protected Environment env
```
    Environment which Spoon is executed.
  - sourceCompilationUnit
```
protected CtCompilationUnit sourceCompilationUnit
```
    Compilation unit we are printing.
  - ignoreImplicit
```
protected boolean ignoreImplicit
```
    If true: always prints fully qualified names by ignoring the isImplicit attribute of AST nodes Default value is "true" for backward compatibility. If false: obey "implicit" directive
  - inlineElseIf
```
public boolean inlineElseIf
```
  - LOGGER
```
protected static final org.slf4j.Logger LOGGER
```
  - ERROR_MESSAGE_TO_STRING
```
public static final java.lang.String ERROR_MESSAGE_TO_STRING
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - DefaultJavaPrettyPrinter
```
public DefaultJavaPrettyPrinter(Environment env)
```
    Creates a new code generator visitor.
- Method Detail
  - getLineSeparator
```
public java.lang.String getLineSeparator()
```
    Returns:
    
    current line separator. By default there is CR LF, LF or CR depending on the Operation system defined by System.getProperty("line.separator")
  - setLineSeparator
```
public DefaultJavaPrettyPrinter setLineSeparator(java.lang.String lineSeparator)
```
    Parameters:
    
    lineSeparator - characters which will be printed as End of line. By default there is System.getProperty("line.separator")
  - printElement
```
public java.lang.String printElement(CtElement element)
```
    Prints an element. This method shall be called by the toString() method of an element. It is responsible for any initialization required to print an arbitrary element.
    
    Specified by:
    
    printElement in interface PrettyPrinter
    
    Parameters:
    
    element -
    
    Returns:
    
    A string containing the pretty printed element (and descendants).
  - enterCtExpression
```
protected void enterCtExpression(CtExpression<?> e)
```
    Enters an expression.
  - enterCtStatement
```
protected void enterCtStatement(CtStatement s)
```
    Enters a statement.
  - exitCtStatement
```
protected void exitCtStatement(CtStatement statement)
```
    Exits a statement.
  - exitCtExpression
```
protected void exitCtExpression(CtExpression<?> e)
```
    Exits an expression.
  - enter
```
protected void enter(CtElement e)
```
    This method is called by scan(CtElement) when entering a scanned element. To be overridden to implement specific behavior. Same KISS design as for CtScanner.
  - exit
```
protected void exit(CtElement e)
```
    This method is called by scan(CtElement) when entering a scanned element. To be overridden to implement specific behavior.
  - prettyprint
```
public java.lang.String prettyprint(CtElement e)
```
    Description copied from interface: PrettyPrinter
    
    pretty-prints the element, call #toString() to get the result
    
    Specified by:
    
    prettyprint in interface PrettyPrinter
  - scan
```
public DefaultJavaPrettyPrinter scan(CtElement e)
```
    The generic scan method for an element.
  - toString
```
public java.lang.String toString()
```
    Gets the currently pretty-printed string.
    
    Overrides:
    
    toString in class java.lang.Object
  - visitCtAnnotation
```
public <A extends java.lang.annotation.Annotation> void visitCtAnnotation(CtAnnotation<A> annotation)
```
    Description copied from interface: CtVisitor
    
    Visits an annotation.
    
    Specified by:
    
    visitCtAnnotation in interface CtVisitor
  - visitCtAnnotationType
```
public <A extends java.lang.annotation.Annotation> void visitCtAnnotationType(CtAnnotationType<A> annotationType)
```
    Description copied from interface: CtVisitor
    
    Visits an annotation type declaration.
    
    Specified by:
    
    visitCtAnnotationType in interface CtVisitor
  - visitCtAnonymousExecutable
```
public void visitCtAnonymousExecutable(CtAnonymousExecutable impl)
```
    Description copied from interface: CtVisitor
    
    Visits an anonymous executable.
    
    Specified by:
    
    visitCtAnonymousExecutable in interface CtVisitor
  - visitCtArrayRead
```
public <T> void visitCtArrayRead(CtArrayRead<T> arrayRead)
```
    Description copied from interface: CtVisitor
    
    Visits an array read access.
    
    Specified by:
    
    visitCtArrayRead in interface CtVisitor
  - visitCtArrayWrite
```
public <T> void visitCtArrayWrite(CtArrayWrite<T> arrayWrite)
```
    Description copied from interface: CtVisitor
    
    Visits an array write access.
    
    Specified by:
    
    visitCtArrayWrite in interface CtVisitor
  - visitCtArrayTypeReference
```
public <T> void visitCtArrayTypeReference(CtArrayTypeReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to an array type.
    
    Specified by:
    
    visitCtArrayTypeReference in interface CtVisitor
  - visitCtAssert
```
public <T> void visitCtAssert(CtAssert<T> asserted)
```
    Description copied from interface: CtVisitor
    
    Visits an assert.
    
    Specified by:
    
    visitCtAssert in interface CtVisitor
  - visitCtAssignment
```
public <T,A extends T> void visitCtAssignment(CtAssignment<T,A> assignement)
```
    Description copied from interface: CtVisitor
    
    Visits an assignment.
    
    Specified by:
    
    visitCtAssignment in interface CtVisitor
  - visitCtBinaryOperator
```
public <T> void visitCtBinaryOperator(CtBinaryOperator<T> operator)
```
    Description copied from interface: CtVisitor
    
    Visits a binary operator.
    
    Specified by:
    
    visitCtBinaryOperator in interface CtVisitor
  - visitCtBlock
```
public <R> void visitCtBlock(CtBlock<R> block)
```
    Description copied from interface: CtVisitor
    
    Visits a block of code.
    
    Specified by:
    
    visitCtBlock in interface CtVisitor
  - visitCtBreak
```
public void visitCtBreak(CtBreak breakStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a break statement.
    
    Specified by:
    
    visitCtBreak in interface CtVisitor
  - visitCtCase
```
public <E> void visitCtCase(CtCase<E> caseStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a case clause.
    
    Specified by:
    
    visitCtCase in interface CtVisitor
  - visitCtCatch
```
public void visitCtCatch(CtCatch catchBlock)
```
    Description copied from interface: CtVisitor
    
    Visits a catch clause.
    
    Specified by:
    
    visitCtCatch in interface CtVisitor
  - visitCtClass
```
public <T> void visitCtClass(CtClass<T> ctClass)
```
    Description copied from interface: CtVisitor
    
    Visits a class declaration.
    
    Specified by:
    
    visitCtClass in interface CtVisitor
  - visitCtTypeParameter
```
public void visitCtTypeParameter(CtTypeParameter typeParameter)
```
    Description copied from interface: CtVisitor
    
    Visits a type parameter declaration.
    
    Specified by:
    
    visitCtTypeParameter in interface CtVisitor
  - visitCtConditional
```
public <T> void visitCtConditional(CtConditional<T> conditional)
```
    Description copied from interface: CtVisitor
    
    Visits a conditional expression
    
    Specified by:
    
    visitCtConditional in interface CtVisitor
  - visitCtConstructor
```
public <T> void visitCtConstructor(CtConstructor<T> constructor)
```
    Description copied from interface: CtVisitor
    
    Visits a constructor declaration.
    
    Specified by:
    
    visitCtConstructor in interface CtVisitor
  - visitCtContinue
```
public void visitCtContinue(CtContinue continueStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a continue statement.
    
    Specified by:
    
    visitCtContinue in interface CtVisitor
  - visitCtDo
```
public void visitCtDo(CtDo doLoop)
```
    Description copied from interface: CtVisitor
    
    Visits a do loop.
    
    Specified by:
    
    visitCtDo in interface CtVisitor
  - visitCtEnum
```
public <T extends java.lang.Enum<?>> void visitCtEnum(CtEnum<T> ctEnum)
```
    Description copied from interface: CtVisitor
    
    Visits an enumeration declaration.
    
    Specified by:
    
    visitCtEnum in interface CtVisitor
  - visitCtExecutableReference
```
public <T> void visitCtExecutableReference(CtExecutableReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to an executable.
    
    Specified by:
    
    visitCtExecutableReference in interface CtVisitor
  - visitCtField
```
public <T> void visitCtField(CtField<T> f)
```
    Description copied from interface: CtVisitor
    
    Visits a field declaration.
    
    Specified by:
    
    visitCtField in interface CtVisitor
  - visitCtEnumValue
```
public <T> void visitCtEnumValue(CtEnumValue<T> enumValue)
```
    Description copied from interface: CtVisitor
    
    Visits an enum value declaration.
    
    Specified by:
    
    visitCtEnumValue in interface CtVisitor
  - visitCtFieldRead
```
public <T> void visitCtFieldRead(CtFieldRead<T> fieldRead)
```
    Description copied from interface: CtVisitor
    
    Visits a field read access.
    
    Specified by:
    
    visitCtFieldRead in interface CtVisitor
  - visitCtFieldWrite
```
public <T> void visitCtFieldWrite(CtFieldWrite<T> fieldWrite)
```
    Description copied from interface: CtVisitor
    
    Visits a field write access.
    
    Specified by:
    
    visitCtFieldWrite in interface CtVisitor
  - visitCtThisAccess
```
public <T> void visitCtThisAccess(CtThisAccess<T> thisAccess)
```
    Description copied from interface: CtVisitor
    
    Visits a this access.
    
    Specified by:
    
    visitCtThisAccess in interface CtVisitor
  - visitCtSuperAccess
```
public <T> void visitCtSuperAccess(CtSuperAccess<T> f)
```
    Description copied from interface: CtVisitor
    
    Visits an access to a super invocation.
    
    Specified by:
    
    visitCtSuperAccess in interface CtVisitor
  - visitCtJavaDoc
```
public void visitCtJavaDoc(CtJavaDoc comment)
```
    Description copied from interface: CtVisitor
    
    Visits a javadoc comment
    
    Specified by:
    
    visitCtJavaDoc in interface CtVisitor
  - visitCtJavaDocTag
```
public void visitCtJavaDocTag(CtJavaDocTag docTag)
```
    Description copied from interface: CtVisitor
    
    Visits a javadoc tag
    
    Specified by:
    
    visitCtJavaDocTag in interface CtVisitor
  - visitCtImport
```
public void visitCtImport(CtImport ctImport)
```
    Description copied from interface: CtVisitor
    
    Visits an import declaration
    
    Specified by:
    
    visitCtImport in interface CtVisitor
  - visitCtModule
```
public void visitCtModule(CtModule module)
```
    Description copied from interface: CtVisitor
    
    Visits a module declaration
    
    Specified by:
    
    visitCtModule in interface CtVisitor
  - visitCtModuleReference
```
public void visitCtModuleReference(CtModuleReference moduleReference)
```
    Description copied from interface: CtVisitor
    
    Visits a module reference
    
    Specified by:
    
    visitCtModuleReference in interface CtVisitor
  - visitCtPackageExport
```
public void visitCtPackageExport(CtPackageExport moduleExport)
```
    Description copied from interface: CtVisitor
    
    Visits a package export in a module declaration.
    
    Specified by:
    
    visitCtPackageExport in interface CtVisitor
  - visitCtModuleRequirement
```
public void visitCtModuleRequirement(CtModuleRequirement moduleRequirement)
```
    Description copied from interface: CtVisitor
    
    Visits a "require" directive in a module declaration.
    
    Specified by:
    
    visitCtModuleRequirement in interface CtVisitor
  - visitCtProvidedService
```
public void visitCtProvidedService(CtProvidedService moduleProvidedService)
```
    Description copied from interface: CtVisitor
    
    Visits a "provides" directive in a module declaration.
    
    Specified by:
    
    visitCtProvidedService in interface CtVisitor
  - visitCtUsedService
```
public void visitCtUsedService(CtUsedService usedService)
```
    Description copied from interface: CtVisitor
    
    Visits a "uses" directive in a module declaration.
    
    Specified by:
    
    visitCtUsedService in interface CtVisitor
  - visitCtCompilationUnit
```
public void visitCtCompilationUnit(CtCompilationUnit compilationUnit)
```
    Description copied from interface: CtVisitor
    
    Visits a compilation unit
    
    Specified by:
    
    visitCtCompilationUnit in interface CtVisitor
  - getImports
```
protected ModelList<CtImport> getImports(CtCompilationUnit compilationUnit)
```
  - visitCtPackageDeclaration
```
public void visitCtPackageDeclaration(CtPackageDeclaration packageDeclaration)
```
    Description copied from interface: CtVisitor
    
    Visits a package declaration
    
    Specified by:
    
    visitCtPackageDeclaration in interface CtVisitor
  - visitCtTypeMemberWildcardImportReference
```
public void visitCtTypeMemberWildcardImportReference(CtTypeMemberWildcardImportReference wildcardReference)
```
    Description copied from interface: CtVisitor
    
    Visits an import wildcard static type member reference
    
    Specified by:
    
    visitCtTypeMemberWildcardImportReference in interface CtVisitor
  - visitCtComment
```
public void visitCtComment(CtComment comment)
```
    Description copied from interface: CtVisitor
    
    Visits a comment
    
    Specified by:
    
    visitCtComment in interface CtVisitor
  - visitCtAnnotationFieldAccess
```
public <T> void visitCtAnnotationFieldAccess(CtAnnotationFieldAccess<T> annotationFieldAccess)
```
    Description copied from interface: CtVisitor
    
    Visits a field of an annotation.
    
    Specified by:
    
    visitCtAnnotationFieldAccess in interface CtVisitor
  - visitCtFieldReference
```
public <T> void visitCtFieldReference(CtFieldReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a field.
    
    Specified by:
    
    visitCtFieldReference in interface CtVisitor
  - visitCtFor
```
public void visitCtFor(CtFor forLoop)
```
    Description copied from interface: CtVisitor
    
    Visits a for loop.
    
    Specified by:
    
    visitCtFor in interface CtVisitor
  - visitCtForEach
```
public void visitCtForEach(CtForEach foreach)
```
    Description copied from interface: CtVisitor
    
    Visits an enhanced for loop.
    
    Specified by:
    
    visitCtForEach in interface CtVisitor
  - visitCtIf
```
public void visitCtIf(CtIf ifElement)
```
    Description copied from interface: CtVisitor
    
    Visits an if statement.
    
    Specified by:
    
    visitCtIf in interface CtVisitor
  - visitCtInterface
```
public <T> void visitCtInterface(CtInterface<T> intrface)
```
    Description copied from interface: CtVisitor
    
    Visits an interface declaration.
    
    Specified by:
    
    visitCtInterface in interface CtVisitor
  - visitCtInvocation
```
public <T> void visitCtInvocation(CtInvocation<T> invocation)
```
    Description copied from interface: CtVisitor
    
    Visits an executable invocation.
    
    Specified by:
    
    visitCtInvocation in interface CtVisitor
  - visitCtLiteral
```
public <T> void visitCtLiteral(CtLiteral<T> literal)
```
    Description copied from interface: CtVisitor
    
    Visits a literal expression.
    
    Specified by:
    
    visitCtLiteral in interface CtVisitor
  - visitCtTextBlock
```
public void visitCtTextBlock(CtTextBlock ctTextBlock)
```
    Description copied from interface: CtVisitor
    
    Visits a literal TextBlock string.
    
    Specified by:
    
    visitCtTextBlock in interface CtVisitor
  - visitCtLocalVariable
```
public <T> void visitCtLocalVariable(CtLocalVariable<T> localVariable)
```
    Description copied from interface: CtVisitor
    
    Visits a local variable declaration.
    
    Specified by:
    
    visitCtLocalVariable in interface CtVisitor
  - visitCtLocalVariableReference
```
public <T> void visitCtLocalVariableReference(CtLocalVariableReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a local variable.
    
    Specified by:
    
    visitCtLocalVariableReference in interface CtVisitor
  - visitCtCatchVariable
```
public <T> void visitCtCatchVariable(CtCatchVariable<T> catchVariable)
```
    Description copied from interface: CtVisitor
    
    Visits a catch variable declaration.
    
    Specified by:
    
    visitCtCatchVariable in interface CtVisitor
  - visitCtCatchVariableReference
```
public <T> void visitCtCatchVariableReference(CtCatchVariableReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a catch variable.
    
    Specified by:
    
    visitCtCatchVariableReference in interface CtVisitor
  - visitCtMethod
```
public <T> void visitCtMethod(CtMethod<T> m)
```
    Description copied from interface: CtVisitor
    
    Visits a method declaration.
    
    Specified by:
    
    visitCtMethod in interface CtVisitor
  - visitCtAnnotationMethod
```
public <T> void visitCtAnnotationMethod(CtAnnotationMethod<T> annotationMethod)
```
    Description copied from interface: CtVisitor
    
    Visits an annotation method declaration.
    
    Specified by:
    
    visitCtAnnotationMethod in interface CtVisitor
  - visitCtNewArray
```
public <T> void visitCtNewArray(CtNewArray<T> newArray)
```
    Description copied from interface: CtVisitor
    
    Visits an array construction.
    
    Specified by:
    
    visitCtNewArray in interface CtVisitor
  - visitCtConstructorCall
```
public <T> void visitCtConstructorCall(CtConstructorCall<T> ctConstructorCall)
```
    Description copied from interface: CtVisitor
    
    Visits a call to a constructor.
    
    Specified by:
    
    visitCtConstructorCall in interface CtVisitor
  - visitCtNewClass
```
public <T> void visitCtNewClass(CtNewClass<T> newClass)
```
    Description copied from interface: CtVisitor
    
    Visits an anonymous class construction.
    
    Specified by:
    
    visitCtNewClass in interface CtVisitor
  - visitCtLambda
```
public <T> void visitCtLambda(CtLambda<T> lambda)
```
    Description copied from interface: CtVisitor
    
    Visits an anonymous method construction.
    
    Specified by:
    
    visitCtLambda in interface CtVisitor
  - visitCtExecutableReferenceExpression
```
public <T,E extends CtExpression<?>> void visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to an executable.
    
    Specified by:
    
    visitCtExecutableReferenceExpression in interface CtVisitor
  - visitCtOperatorAssignment
```
public <T,A extends T> void visitCtOperatorAssignment(CtOperatorAssignment<T,A> assignment)
```
    Description copied from interface: CtVisitor
    
    Visits an operator assignment.
    
    Specified by:
    
    visitCtOperatorAssignment in interface CtVisitor
  - visitCtPackage
```
public void visitCtPackage(CtPackage ctPackage)
```
    Description copied from interface: CtVisitor
    
    Visits a package declaration.
    
    Specified by:
    
    visitCtPackage in interface CtVisitor
  - visitCtPackageReference
```
public void visitCtPackageReference(CtPackageReference reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a package.
    
    Specified by:
    
    visitCtPackageReference in interface CtVisitor
  - visitCtParameter
```
public <T> void visitCtParameter(CtParameter<T> parameter)
```
    Description copied from interface: CtVisitor
    
    Visits a parameter declaration.
    
    Specified by:
    
    visitCtParameter in interface CtVisitor
  - visitCtParameterReference
```
public <T> void visitCtParameterReference(CtParameterReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a parameter.
    
    Specified by:
    
    visitCtParameterReference in interface CtVisitor
  - visitCtReturn
```
public <R> void visitCtReturn(CtReturn<R> returnStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a return statement.
    
    Specified by:
    
    visitCtReturn in interface CtVisitor
  - visitCtStatementList
```
public void visitCtStatementList(CtStatementList statements)
```
    Description copied from interface: CtVisitor
    
    Visits a statement list.
    
    Specified by:
    
    visitCtStatementList in interface CtVisitor
  - visitCtSwitch
```
public <E> void visitCtSwitch(CtSwitch<E> switchStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a switch statement.
    
    Specified by:
    
    visitCtSwitch in interface CtVisitor
  - visitCtSwitchExpression
```
public <T,S> void visitCtSwitchExpression(CtSwitchExpression<T,S> switchExpression)
```
    Description copied from interface: CtVisitor
    
    Visits a switch expression.
    
    Specified by:
    
    visitCtSwitchExpression in interface CtVisitor
  - visitCtSynchronized
```
public void visitCtSynchronized(CtSynchronized synchro)
```
    Description copied from interface: CtVisitor
    
    Visits a synchronized modifier.
    
    Specified by:
    
    visitCtSynchronized in interface CtVisitor
  - visitCtThrow
```
public void visitCtThrow(CtThrow throwStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a throw statement.
    
    Specified by:
    
    visitCtThrow in interface CtVisitor
  - visitCtTry
```
public void visitCtTry(CtTry tryBlock)
```
    Description copied from interface: CtVisitor
    
    Visits a try statement.
    
    Specified by:
    
    visitCtTry in interface CtVisitor
  - visitCtTryWithResource
```
public void visitCtTryWithResource(CtTryWithResource tryWithResource)
```
    Description copied from interface: CtVisitor
    
    Visits a try with resource statement.
    
    Specified by:
    
    visitCtTryWithResource in interface CtVisitor
  - visitCtTypeParameterReference
```
public void visitCtTypeParameterReference(CtTypeParameterReference ref)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a type parameter.
    
    Specified by:
    
    visitCtTypeParameterReference in interface CtVisitor
  - visitCtWildcardReference
```
public void visitCtWildcardReference(CtWildcardReference wildcardReference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a wildcard.
    
    Specified by:
    
    visitCtWildcardReference in interface CtVisitor
  - visitCtIntersectionTypeReference
```
public <T> void visitCtIntersectionTypeReference(CtIntersectionTypeReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits an intersection type.
    
    Specified by:
    
    visitCtIntersectionTypeReference in interface CtVisitor
  - visitCtTypeReference
```
public <T> void visitCtTypeReference(CtTypeReference<T> ref)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a type.
    
    Specified by:
    
    visitCtTypeReference in interface CtVisitor
  - visitCtTypeAccess
```
public <T> void visitCtTypeAccess(CtTypeAccess<T> typeAccess)
```
    Description copied from interface: CtVisitor
    
    Visits a type access.
    
    Specified by:
    
    visitCtTypeAccess in interface CtVisitor
  - visitCtUnaryOperator
```
public <T> void visitCtUnaryOperator(CtUnaryOperator<T> operator)
```
    Description copied from interface: CtVisitor
    
    Visits a unary operator.
    
    Specified by:
    
    visitCtUnaryOperator in interface CtVisitor
  - visitCtVariableRead
```
public <T> void visitCtVariableRead(CtVariableRead<T> variableRead)
```
    Description copied from interface: CtVisitor
    
    Visits a variable read access.
    
    Specified by:
    
    visitCtVariableRead in interface CtVisitor
  - visitCtVariableWrite
```
public <T> void visitCtVariableWrite(CtVariableWrite<T> variableWrite)
```
    Description copied from interface: CtVisitor
    
    Visits a variable write access.
    
    Specified by:
    
    visitCtVariableWrite in interface CtVisitor
  - visitCtWhile
```
public void visitCtWhile(CtWhile whileLoop)
```
    Description copied from interface: CtVisitor
    
    Visits a while loop.
    
    Specified by:
    
    visitCtWhile in interface CtVisitor
  - visitCtCodeSnippetExpression
```
public <T> void visitCtCodeSnippetExpression(CtCodeSnippetExpression<T> expression)
```
    Description copied from interface: CtVisitor
    
    Visits a code snippet expression.
    
    Specified by:
    
    visitCtCodeSnippetExpression in interface CtVisitor
  - visitCtCodeSnippetStatement
```
public void visitCtCodeSnippetStatement(CtCodeSnippetStatement statement)
```
    Description copied from interface: CtVisitor
    
    Visits a code snippet statement.
    
    Specified by:
    
    visitCtCodeSnippetStatement in interface CtVisitor
  - getElementPrinterHelper
```
public ElementPrinterHelper getElementPrinterHelper()
```
  - getContext
```
public PrintingContext getContext()
```
  - visitCtUnboundVariableReference
```
public <T> void visitCtUnboundVariableReference(CtUnboundVariableReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to an unbound field
    
    Specified by:
    
    visitCtUnboundVariableReference in interface CtVisitor
  - printCompilationUnit
```
public java.lang.String printCompilationUnit(CtCompilationUnit compilationUnit)
```
    Description copied from interface: PrettyPrinter
    
    Prints the compilation unit of module-info, package-info or types.
    
    Specified by:
    
    printCompilationUnit in interface PrettyPrinter
  - applyPreProcessors
```
public void applyPreProcessors(CtElement el)
```
    Warning, this may change the state of the object
  - printPackageInfo
```
public java.lang.String printPackageInfo(CtPackage pack)
```
    Description copied from interface: PrettyPrinter
    
    Prints the package info. It always resets the printing context at the beginning of this process.
    
    Specified by:
    
    printPackageInfo in interface PrettyPrinter
  - printModuleInfo
```
public java.lang.String printModuleInfo(CtModule module)
```
    Description copied from interface: PrettyPrinter
    
    Prints the module info. It always resets the printing context at the beginning of this process.
    
    Specified by:
    
    printModuleInfo in interface PrettyPrinter
  - printTypes
```
public java.lang.String printTypes(CtType<?>... type)
```
    Description copied from interface: PrettyPrinter
    
    Prints the types of one compilation unit It always resets the printing context at the beginning of this process.
    
    Specified by:
    
    printTypes in interface PrettyPrinter
  - getResult
```
public java.lang.String getResult()
```
    Description copied from interface: PrettyPrinter
    
    Gets the contents of the compilation unit.
    
    Specified by:
    
    getResult in interface PrettyPrinter
  - reset
```
public void reset()
```
  - calculate
```
public void calculate(CtCompilationUnit sourceCompilationUnit,
                      java.util.List<CtType<?>> types)
```
    Description copied from interface: PrettyPrinter
    
    Calculates the resulting source file for a list of types. The source compilation unit is required for calculating the line numbers mapping. It always resets the printing context at the beginning of this process.
    
    Specified by:
    
    calculate in interface PrettyPrinter
  - getLineNumberMapping
```
public java.util.Map<java.lang.Integer,java.lang.Integer> getLineNumberMapping()
```
    Description copied from interface: PrettyPrinter
    
    Gets the line number mapping between the generated code and the original code.
    
    Specified by:
    
    getLineNumberMapping in interface PrettyPrinter
  - getPrinterTokenWriter
```
protected TokenWriter getPrinterTokenWriter()
```
    Returns:
    
    current TokenWriter, so the subclasses of DefaultJavaPrettyPrinter can print tokens too
  - setPrinterTokenWriter
```
public DefaultJavaPrettyPrinter setPrinterTokenWriter(TokenWriter tokenWriter)
```
    Set TokenWriter, which has to be used to print tokens
  - setPreprocessors
```
public void setPreprocessors(java.util.List<Processor<CtElement>> preprocessors)
```
    Set preprocessors that the printer automatically runs on the model before printing it. Typically, such preprocessors validate or adjust the model before printing.
    
    Parameters:
    
    preprocessors - list of processors to run on the model before printing
  - getPreprocessors
```
public java.util.List<Processor<CtElement>> getPreprocessors()
```
    Returns:
    
    all processors currently set to run on the model before printing
  - setIgnoreImplicit
```
public void setIgnoreImplicit(boolean ignoreImplicit)
```
    Parameters:
    
    ignoreImplicit - true to ignore `isImplicit` attribute on model and always print fully qualified names
  - visitCtYieldStatement
```
public void visitCtYieldStatement(CtYieldStatement statement)
```
    Description copied from interface: CtVisitor
    
    Visits a yield statement.
    
    Specified by:
    
    visitCtYieldStatement in interface CtVisitor
  - isMinimizeRoundBrackets
```
protected boolean isMinimizeRoundBrackets()
```
    Returns:
    
    true if the printer is minimizing the amount of round brackets in expressions
  - setMinimizeRoundBrackets
```
protected void setMinimizeRoundBrackets(boolean minimizeRoundBrackets)
```
    When set to true, this activates round bracket minimization for expressions. This means that the printer will attempt to only write round brackets strictly necessary for preserving syntactical structure (and by extension, semantics). As an example, the expression 1 + 2 + 3 + 4 is written as ((1 + 2) + 3) + 4 without round bracket minimization, but entirely without parentheses when minimization is enabled. However, an expression 1 + 2 + (3 + 4) is still written as 1 + 2 + (3 + 4) to preserve syntactical structure, even though the brackets are semantically redundant.
    
    Parameters:
    
    minimizeRoundBrackets - set whether or not to minimize round brackets in expressions

Class DefaultJavaPrettyPrinter

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

JAVA_FILE_EXTENSION

JAVA_PACKAGE_DECLARATION

JAVA_MODULE_DECLARATION

LINE_SEPARATOR

COMMENT_STAR

BLOCK_COMMENT_END

JAVADOC_START

INLINE_COMMENT_START

BLOCK_COMMENT_START

preprocessors

env

sourceCompilationUnit

ignoreImplicit

inlineElseIf

LOGGER

ERROR_MESSAGE_TO_STRING

Constructor Detail

DefaultJavaPrettyPrinter

Method Detail

getLineSeparator

setLineSeparator

printElement

enterCtExpression

enterCtStatement

exitCtStatement

exitCtExpression

enter

exit

prettyprint

scan

toString

visitCtAnnotation

visitCtAnnotationType

visitCtAnonymousExecutable

visitCtArrayRead

visitCtArrayWrite

visitCtArrayTypeReference

visitCtAssert

visitCtAssignment

visitCtBinaryOperator

visitCtBlock

visitCtBreak

visitCtCase

visitCtCatch

visitCtClass

visitCtTypeParameter

visitCtConditional

visitCtConstructor

visitCtContinue

visitCtDo

visitCtEnum

visitCtExecutableReference

visitCtField

visitCtEnumValue

visitCtFieldRead

visitCtFieldWrite

visitCtThisAccess

visitCtSuperAccess

visitCtJavaDoc

visitCtJavaDocTag

visitCtImport

visitCtModule

visitCtModuleReference

visitCtPackageExport

visitCtModuleRequirement

visitCtProvidedService

visitCtUsedService

visitCtCompilationUnit

getImports

visitCtPackageDeclaration

visitCtTypeMemberWildcardImportReference

visitCtComment

visitCtAnnotationFieldAccess

visitCtFieldReference