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.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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.
 
 
A special type to be implemented by $Writers so Pebble can bypass $Numbers String allocation and directly write primitives.
 
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.
 
 
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.