# All Classes

All Classes Interface Summary Class Summary Enum Summary Exception Summary
AbstractCommandVisitor: This class can be extended by `CommandVisitor` implementations that don't provide support for all the available `Command`s.
AbstractFilter
AbstractPlugin
AbstractRepeatPlugin
AggregatePluginInvoke: Plugin invoke which aggregates the behavior of several plugin invokes.
ArrayLiteral: Syntactical structure for an array of items.
Atom: An `Atom` defines an `ExpressionNode` that can be translated to simple text, like identifiers or primitive constants (strings, booleans and numbers).
AttributeList: Contains the list of attributes inside an HTML tag.
AttributePlugin: Implementation for the attribute plugin.
BackendCompiler: A `BackendCompiler` can be hooked in into the `SightlyCompiler` in order to transpile HTL `Command`s into other JVM supported languages.
BinaryOperation: A {code BinaryOperation} defines an expression where a binary operator is applied (e.g.
BinaryOperator: Binary operators used in expressions.
BooleanConstant: Defines a Boolean constant (e.g.
BroadcastHandler: Broadcasts commands to other handlers
CallPlugin
CoalescingWrites: Aggregate consecutive writes in bigger chunks of text
Command: A `Command` represents the type of instruction a certain HTL expression or block element should execute.
CommandHandler: The `CommandHandler` is the mechanism through which a `CommandStream` can be processed synchronously, as the stream is written.
CommandStream: This interface defines a stream to which `Command`s are pushed during the compilation of a HTL script by the `SightlyCompiler`.
CommandVariableUsage: Extracts the variables used in a command
CommandVisitor: The `CommandVisitor` is the mechanism through which a `Command` can be processed.
CompilationResult: This class encapsulates the result of a compile operation performed by the `SightlyCompiler`.
CompilationResultImpl
CompilationUnit: This class describes a compilation unit that the `SightlyCompiler` will process during the call of the `compile` methods.
CompilerContext: Default implementation for the compiler context
CompilerMessage: This class describes the messages (warnings or errors) the `SightlyCompiler` will produce when compiling a script.
CompilerMessageImpl
Conditional: This `Command` imposes a condition on the next rendering commands.
Conditional.End
Conditional.Start
ConstantFolding: Optimization which evaluates constant expressions during compilation-time
DeadCodeRemoval: Removes code under conditionals which are proven to fail.
DefaultPluginInvoke: Empty implementation for plugin invocation.
DocumentHandler: Invoked by the `HTMLParser` when elements are scanned.
DocumentParser
ElementContext: Data structure used by `MarkupHandler`.
ElementContext.Attribute
ElementPlugin
EmitterVisitor: Command visitor which writes to an output stream.
EvalResult: Data structure used in expression reducing
Expression: This class represents a HTL Expression.
ExpressionContext: Defines a context for the `Expression` that will be processed by a `Filter`.
ExpressionNode: Defines a node in a HTL expression tree.
ExpressionParser
ExpressionReducer: Try to evaluate constant parts in expressions
ExpressionWrapper: This object wraps expressions in filter applications depending on options.
Filter: A filter is a transformation which performs modifications on expressions.
FormatFilter: Implementation for the format filter & runtime support.
Fragment: A segment in an interpolation.
Fragment.Expr: A fragment which is an expression.
Fragment.Text: A text fragment.
HtmlParser: HTML parser.
I18nFilter: Filter for i18n translation
Identifier: Defines a single variable.
IgnoreRange: Ignore a nested range of commands.
IncludePlugin: Implementation for the include plugin
Interpolation: A sequence with alternating string fragments and HTL expressions.
JoinFilter: Filter providing support for the `join` option applied to arrays.
ListPlugin
LoggingHandler: Handler which logs all commands
Loop: This `Command` renders a sequence of commands repeatedly.
Loop.End
Loop.Start
MapLiteral: Defines a syntactical construction representing a map.
MarkupContext: Indicates what type of content is being rendered.
MarkupHandler: Implementation for the markup handler
MarkupUtils: Utility methods related to markup
NodeTransformer
NodeVisitor<T>: A `NodeVisitor` represents the mechanism through which `ExpressionNode` entities are processed.
NullLiteral: Defines the null literal.
NumericConstant: Defines a numeric constant expression (e.g.
ObjectModel: Deprecated. This class has been moved to `ObjectModel`.
OutputVariable: This `Command` renders a variable's value.
OutText: This `Command` renders a text fragment.
ParserHelper: Helper utilities for the ANTLR parser.
Patterns: The `Patterns` class provides various static methods that implement commonly used stream processing commands.
Plugin: Common interface for plugins
PluginCallInfo: Data related to a plugin call
PluginInvoke: General interface for plugin invocations.
Procedure: This `Command` allows defining a HTL template - the only functional construct of the language.
Procedure.Call
Procedure.End
Procedure.Start
PropertyAccess: Defines an expression in which an object is queried for a specific property (e.g.
PushStream: A stream that can be written into.
PushStream.StreamMessage
RepeatPlugin
ResourcePlugin: The resource plugin.
RuntimeCall: A `RuntimeCall` is a special expression which provides access to utility functions from the runtime.
RuntimeFunction: Deprecated. constants are available in `RuntimeCall` starting with version 1.2.0 of the `org.apache.sling.scripting.sightly.compiler.expression.nodes` API.
SanityChecker: A visitor which checks a stream for correct closing of things
SequenceStreamTransformer: Applies a list of transformations in sequence.
SetPlugin: Implementation for the `data-sly-set` plugin
SideEffectVisitor: Expression visitor which does not return anything for nodes; instead it performs specific side-effects depending on the expression nodes types.
SightlyCompiler: The `SightlyCompiler` interprets a HTL script and transforms it internally into a `CommandStream`.
SightlyCompilerException: Exception thrown by the `SightlyCompiler` during various processing operations.
SightlyLexer
SightlyParser
SightlyParser.AndBinaryOpContext
SightlyParser.AtomContext
SightlyParser.ComparisonOpContext
SightlyParser.ComparisonTermContext
SightlyParser.ExpressionContext
SightlyParser.ExprNodeContext
SightlyParser.FactorContext
SightlyParser.FieldContext
SightlyParser.InBinaryOpContext
SightlyParser.InterpolationContext
SightlyParser.OptionContext
SightlyParser.OptionListContext
SightlyParser.OrBinaryOpContext
SightlyParser.SimpleContext
SightlyParser.StringConstContext
SightlyParser.TermContext
SightlyParser.TextFragContext
SightlyParser.ValueListContext
SightlyParserBaseListener: This class provides an empty implementation of `SightlyParserListener`, which can be extended to create a listener which only needs to handle a subset of the available methods.
SightlyParserErrorListener: The `SightlyParserErrorListener` handles parsing error reporting by sending offending input to a logger.
SightlyParserListener: This interface defines a complete listener for a parse tree produced by `SightlyParser`.
SimpleFrontend: DOM-based compiler implementation
StatefulRangeIgnore: Variant of `IgnoreRange` to be used in stateful visitors.
StatefulVisitor: This `CommandVisitor` allows storing states for `Command` evaluation.
Streams: Utility functions for streams.
StreamTransformer: Interface for stream transformations.
StringConstant: Defines a simple string constant (e.g.
SymbolGenerator
Syntax: HTL Syntax specific elements.
SyntheticMapRemoval: This optimization handles variables initialized to map literals.
Template
TemplateAttribute
TemplateCommentNode
TemplateElementNode
TemplateNode
TemplateParser: The template parser parses an HTML document and returns a reusable tree representation.
TemplateParser.TemplateParserContext
TemplatePlugin: The template plugin
TemplateTextNode
TernaryOperator: Defines the HTL ternary operator (e.g.
TestPlugin: Implementation for the test plugin
TextPlugin: The `data-sly-text` plugin.
TrackingVisitor<T>: Command visitor which tracks variables in commands.
TreeTraverser
UnaryOperation: Defines a unary operation (e.g.
UnaryOperator: Unary operators used in expressions.
UniformVisitor: Abstract visitor that allows to skip processing some commands.
UnusedVariableRemoval: This optimization removes variables which are bound but never used in the command stream.
UnwrapPlugin: The unwrapped plugin
URIManipulationFilter: The `URIManipulationFilter` provides support for Sightly's URI Manipulation options according to the language specification
UsePlugin
VariableBinding: This `Command` marks the binding of a variable.
VariableBinding.End
VariableBinding.Global
VariableBinding.Start
VariableFinder: SideEffectVisitor which extracts all the variables from an expression.
VariableTracker<T>: Tracks information related to HTL variables, at different levels of the compiler.
VisitorHandler: Delegates commands to a visitor.
XSSFilter: XSS filter implementation.