All Classes and Interfaces
Class
Description
A base node visitor that can be extended for the sake of using it's navigational abilities.
Abstract base class for loaders which user the servlet context to load templates.
This class implements the 'base64encode' filter.
This class implements the 'base64encode' filter.
Key to be used in the cache
Node for the cache tag
Token parser for the cache tag
Uses a classloader to find templates located on the classpath.
Expression which implements the string concatenation.
Implementation for the test function 'defined'.
This loader will delegate control to a list of children loaders.
The delegating loader cache key is used as the cache key for
DelegatingLoader.Factory class for creating
EscaperNodeVisitor.Created by mitchell on 2016-11-13.
An evaluation context will store all stateful data that is necessary for the evaluation of a
template.
Evaluation options.
Parses expressions.
Base class that allows implementing a customizer to modify Pebbles build-in extensions.
Storage for the extensions and the components retrieved from the various extensions.
Provides configuration methods and builds the
ExtensionRegistry.This loader searches for a file located anywhere on the filesystem.
The right hand side to the filter expression.
Parses the "filter" tag.
Returns the first element of a collection
Represents a "for" loop within the template.
From Node for
From Token parser for
A Writer that will wrap around the user-provided writer if the user also provided an
ExecutorService to the main PebbleEngine.
Used to get an attribute from an object.
A data structure that represents the entire inheritance hierarchy of the current template and
tracks which level in the hierarchy we are currently evaluating.
Concatenates all entries of a collection, optionally glued together with a particular character
such as a comma.
Returns the last element of a collection
This class reads the template input and builds single items out of it.
A Writer that will wrap around the internal writer if the user also provided a limit
on the size of the rendered template.
Interface used to find templates for Pebble.
Implementation of
NodeVisitorFactory to handle MacroAndBlockRegistrantNodeVisitor.Will visit all the nodes of the AST provided by the parser.
The node visitor factory creates
NodeVisitors.This class acts as a sort of wrapper around Java's built in operators.
A small utility class used to pair relevant objects together.
Parser options.
Utility class to handle relative paths.
The main class used for compiling templates.
A builder to configure and construct an instance of a PebbleEngine.
A template object constructed by an instance of
PebbleEngine.The actual implementation of a PebbleTemplate
A $
SpecializedWriter that's pooled in a $ThreadLocal.Implementation of
NodeVisitorFactory to create PrettyPrintNodeVisitor.Expression which implements the range function.
Range function to iterate over long or a string with a length of 1.
This class wraps a
RenderableNode into an expression.This class implements the 'replace' filter.
Revert the order of an input list
Sort list items in the reverse order
Wrap a string in this to mark the string as safe to ignore by the Escape extension.
A scope is a map of variables.
A stack data structure used to represent the scope of variables that are currently accessible.
Loader that uses a servlet context to find templates.
Loader that uses a servlet context to find templates.
This class implements the 'sha256' filter.
Implementations of this class are provided by the TokenParsers and handed to the main Parser.
This loader is not intended to be used in a production system; it is primarily for testing and
debugging.
A $
SpecializedWriter that wraps a $StringWriter.The syntax describes the different syntax parts of the Pebble language.
Helper class to create new instances of
Syntax.An implementation of CharSequence that is tuned to be used specifically by
LexerImpl.The right hand side to the test expression.
Represents static text in a template.
A TokenParser is responsible for converting a stream of Tokens into a Node.
A small utility class to handle type operation.
This is just a dummy class to point developers into the right direction; the verbatim tag had to
be implemented directly into the lexer.