All Classes and Interfaces
Class
Description
Default implementation of a
chainable uberspector that forwards all calls to the wrapped
uberspector (when that is possible).This class is the abstract base class for all conventional
Velocity Context implementations.
Abstract class that is used to execute an arbitrary
method that is in introspected.
An Iterator wrapper for an Object[].
A class that wraps an array with a List interface.
Handles number addition of nodes.
Please look at the Parser.jjt file which is what controls the generation of this class.
Please look at the Parser.jjt file which is what controls the generation of this class.
Please look at the Parser.jjt file which is
what controls the generation of this class.
Represents all comments...
Numeric comparison support
This class is responsible for handling the pluggable
directives in VTL.
Handles number division of nodes
Please look at the Parser.jjt file which is what controls the generation of this class.
Please look at the Parser.jjt file which is what controls the generation of this class.
This class is responsible for handling the ElseIf VTL control statement.
This class is responsible for handling the Else VTL control statement.
Handles
arg1 == arg2
This operator requires that the LHS and RHS are both of the
same Class, both numbers or both coerce-able to strings.This class is responsible for handling Escapes
in VTL.
This class is responsible for handling EscapedDirectives
in VTL.
Handles floating point numbers.
Handles arg1 >= arg2
Handles arg1 > arg2
ASTIdentifier.java
Method support for identifiers : $foo
mainly used by ASTReference
Introspection is now moved to 'just in time' or at render / execution
time.
Please look at the Parser.jjt file which is
what controls the generation of this class.
This node is responsible for the bracket notation at the end of
a reference, e.g., $foo[1]
Handles integer numbers.
handles the range 'operator' [ n ..
Handles arg1 <= arg2
Handles arg1 < arg2
AST Node for creating a map / dictionary.
Helps handle math
Please look at the Parser.jjt file which is what controls the generation of this class.
Please look at the Parser.jjt file which is what controls the generation of this class.
ASTMethod.java
Method support for references : $foo.method()
NOTE :
introspection is now done at render time.
Internal class used as key for method cache.
Handles modulus division
Please look at the Parser.jjt file which is what controls the generation of this class.
Please look at the Parser.jjt file which is what controls the generation of this class.
Handles multiplication
Please look at the Parser.jjt file which is what controls the generation of this class.
Please look at the Parser.jjt file which is what controls the generation of this class.
Handles
arg1 != arg2 by negating evaluation of ASTEQNodePlease look at the Parser.jjt file which is
what controls the generation of this class.
This class is responsible for handling the references in
VTL ($foo).
Node for the #set directive
ASTStringLiteral support.
Handles subtraction of nodes (in #set() )
Please look at the Parser.jjt file which is what controls the generation of this class.
Please look at the Parser.jjt file which is what controls the generation of this class.
This node holds the "Textblock" data which should not be interpreted by Velocity.
This is the base class for all visitors.
Directive that puts an unrendered AST block in the context
under the specified key, postponing rendering until the
reference is used and rendered.
actual class placed in the context, holds the context
being used for the render, as well as the parent (which already holds
everything else we need).
BlockMacro directive is used to invoke Velocity macros with normal parameters and a macro body.
Handles discovery and valuation of a
boolean object property, of the
form public boolean is<property> when executed.
Break directive used for interrupting scopes.
Interface that marks uberspectors as chainable, meaning that multiple uberspectors can be
combined in a chain (using the Decorator pattern).
This is an abstract internal-use-only context implementation to be
used as a subclass for other internal-use-only contexts that wrap
other internal-use-only contexts.
This interface describes a character stream that maintains line and
column number positions of the characters.
A cache of introspection information for a specific class instance.
A cache of introspection information for a specific class instance.
This is the cache to store and look up the method information.
ClasspathResourceLoader is a simple loader that will load
templates from the classpath.
Simple utility functions for manipulating classes and resources
from the classloader.
This class represent a general text resource that may have been
retrieved from any number of possible sources.
Interface describing the application data context.
Event handlers implementing this interface will automatically
have the method setContext called before each event.
Deprecated.
Converts a value to type T
This is a simple template file loader that loads templates
from a DataSource instead of plain files.
Example context impl that uses a database to store stuff :)
yes, this is silly
expects a mysql db test with table
CREATE TABLE contextstore (
k varchar(100),
val blob
);
very fragile, crappy code....
the ultimate in silliness...
Directive that puts an unrendered AST block in the context
under the specified key, postponing rendering until the
reference is used and rendered.
Chainable Uberspector that checks for deprecated method calls.
Deprecated.
Deprecated.
it will disappear along with deprecated key names in 3.0.
Base class for all directives used in Velocity.
Base class for all directives used in Velocity.
Support for getAs<java.lang.reflect.Type>() convention for rendering (String), evaluating (Boolean)
or doing math with (Number) references.
An Iterator wrapper for an Enumeration.
Deprecated.
impractical use
Deprecated.
impractical use
Base class for escaping references.
Escapes the characters in a String to be suitable to pass to an SQL query.
Deprecated.
impractical use
Evaluates the directive argument as a VTL string, using the existing
context.
Stores the event handlers.
This class is a simple demonstration of how the event handling
features of the Velocity Servlet Engine are used.
Base interface for all event handlers
Calls on request all registered event handlers for a particular event.
This class is a simple demonstration of how the Velocity Template Engine
can be used in a standalone application.
This class is a simple demonstration of how the Velocity Template Engine
can be used in a standalone application using the Velocity utility class.
All Exceptions that can provide additional information about the place
where the error happened (template name, column and line number) can
implement this interface and the ParseErrorException will then be able
to deal with this information.
This class extends normal Java properties by adding the possibility
to use the same key many times concatenating the value strings
instead of overwriting them.
This class is used to read properties lines.
This class divides into tokens a property value.
This is a small utility class allow easy access to static fields in a class,
such as string constants.
A loader for templates stored on the file system.
Velocity will call the writeReference method on any Writer that
implements this interface when rendering references within a template.
The #for directive provides the behavior of the #foreach directive but also
provides an 'index' keyword that allows the user to define an optional index variable
that tracks the loop iterations.
Foreach directive used for moving through arrays,
or objects that provide an Iterator.
This represents scoping and metadata for #foreach,
adding index, count, hasNext, isFirst and isLast info.
Executor that simply tries to execute a get(key)
operation.
Pluggable directive that handles the #include() statement in VTL.
Event handler for include type directives (e.g.
Simple event handler that checks to see if an included page is available.
Event handler that looks for included files relative to the path of the
current template.
Helper class to fix indentation in structured mode.
Little class to carry in info such as template name, line and column
for information error reporting from the uberspector implementations
Base class for directives which do input operations
(e.g.
interface to bring all necessary internal and user contexts together.
This adapter class is the container for all context types for internal
use.
class to encapsulate the 'stuff' for internal operation of velocity.
Interface for event support.
interface to encapsulate the 'stuff' for internal operation of velocity.
interface for internal context wrapping functionality
Holds information for node-local context data introspection
information.
This basic function of this class is to return a Method
object for a particular class given the name of a method
and the parameters to the method in the form of an Object[]
The first time the Introspector sees a
class it creates a class method map for the
class in question.
Lookup a a Method object for a particular class given the name of a method
and its parameters.
This is the internal introspector cache implementation.
Event handler called when an invalid reference is encountered.
Convenience class to use when reporting out invalid syntax
with line, column, and template name.
A small wrapper around a Jar
ResourceLoader to load templates from multiple Jar files.
When the introspector.uberspect.class configuration property contains several
uberspector class names, it means those uberspectors will be chained.
Track location in template files during rendering by populating the slf4j MDC tags
file, line and column.Macro implements the macro definition directive of VTL.
MacroArgs holds the information for a single argument in a
macro definition.
Application-level exception thrown when macro calls within macro calls
exceeds the maximum allowed depth.
Exception to indicate problem happened while constructing #macro()
For internal use in parser - not to be passed to app level
GetExecutor that is smart about Maps.
SetExecutor that is smart about Maps.
Separate exception class to distinguish math problems.
Utility-class for all arithmetic-operations.
All operations (+ - / *) return a Number which type is the type of the bigger argument.
Example:
Overflow checking:
For integral values (byte, short, int) there is an implicit overflow correction (the next "bigger" type will be returned).
All operations (+ - / *) return a Number which type is the type of the bigger argument.
Example:
add ( new Integer(10), new Integer(1)) will return an Integer-Object with the value 11add ( new Long(10), new Integer(1)) will return an Long-Object with the value 11add ( new Integer(10), new Float(1)) will return an Float-Object with the value 11Overflow checking:
For integral values (byte, short, int) there is an implicit overflow correction (the next "bigger" type will be returned).
Event handler called when a method throws an exception.
Application-level exception thrown when a reference method is
invoked and an exception is thrown.
Simple distinguishable exception, used when
we run across ambiguous overloading.
This file describes the interface between the Velocity code
and the JavaCC generated code.
Utilities for dealing with the AST node structure.
This class is simply a visitor implementation
that traverses the AST, produced by the Velocity
parsing process, and creates a visual structure
of the AST.
Pluggable directive that handles the
#parse()
statement in VTL.Application-level exception thrown when a resource of any type
has a syntax or other error which prevents it from being parsed.
This exception is thrown when parse errors are encountered.
Class gathering configured replacement characters for a specific parser class.
Provides instances of parsers as needed.
This wraps the original parser SimplePool class.
Interface used in implementation of visitor pattern.
Simple event handler that renders method exceptions in the page
rather than throwing the exception.
Returned the value of object property when executed.
Returns the value of a public field when executed.
Executor that simply tries to execute a put(key, value)
operation.
Reference 'Stream insertion' event handler.
This interface characterize objects other than ASTNodes that can be rendered
to a writer using a context.
Use this event handler to flag invalid references.
This class represent a general text resource that
may have been retrieved from any number of possible
sources.
Interface that defines the shape of a pluggable resource cache
for the included ResourceManager
Default implementation of the resource cache for the default
ResourceManager.
A simple LRU Map based on
LinkedHashSet.Class responsible for instantiating
Resource objects,
given name and type.This is abstract class the all text resource loaders should
extend.
Factory to grab a template loader.
Class to manage the text resource for the Velocity
Runtime.
Class to manage the text resource for the Velocity Runtime.
Application-level exception thrown when a resource of any type
isn't found by the Velocity engine.
This class defines the keys that are used in the velocity.properties file so that they can be referenced as a constant within
Java code.
Space gobbling modes
This is the Runtime system for Velocity.
This class acts as a proxy for potential macros.
Interface for internal runtime services that are needed by the
various components w/in Velocity.
Use this interface to automatically
have the method setRuntimeServices called at initialization.
This is the Runtime system for Velocity.
This handles context scoping and metadata for directives.
Class to encapsulate and provide access to info about
the current scope for debugging.
Interface used to determine which methods are allowed to be executed.
Prevent "dangerous" classloader/reflection related calls.
Use a custom introspector that prevents classloader related method
calls.
Abstract class that is used to execute an arbitrary
method that is in introspected.
Executor for looking up property names in the passed in class
This will try to find a set<foo>(key, value) method
Executor for setting public fields in objects
Simple object pool.
This class is responsible for parsing a Velocity
xtemplate.
Token literal values and constants.
Token Manager.
Holds the state of the parsing process.
Interface used in implementation of visitor pattern.
This class implements the #stop directive which allows
a user to stop the merging and rendering process.
Stop command for directive Control objects.
Writer implementation that outputs to a StringBuilder.Wrapper for Strings containing templates, allowing to add additional meta
data like timestamps.
Resource loader that works with Strings.
A StringResourceRepository functions as a central repository for Velocity templates
stored in Strings.
Default implementation of StringResourceRepository.
This class provides some methods for dynamically
invoking methods in objects, and some string
manipulation and formatting methods.
This class is used for controlling all template
operations.
Any object in the context which implements TemplateBoolean will use the
getAsBoolean() method for #if( $ref ) calls.
Exception generated to indicate parse errors caught during
directive initialization (e.g.
Any object in the context which implements TemplateNumber will be treated
as a number for the purposes of arithmetic operations and comparison.
This is an extension of the ParseException, which also takes a
template name.
Any object in the context which implements TemplateString will use the
getAsString() method for rendering and empty-checks instead of toString().
Describes the input token stream.
Token Manager Error.
Example context impl that uses a TreeMap
Not much point other than to show how easy it is.
A conversion handler adds admissible conversions between Java types whenever Velocity introspection has to map
VTL methods and property accessors to Java methods.
A conversion handler adds admissible conversions between Java types whenever Velocity introspection has to map
VTL methods and property accessors to Java methods.
'Federated' introspection/reflection interface to allow the introspection
behavior in Velocity to be customized.
Implementation of Uberspect to provide the default introspective
functionality of Velocity
Implementation of VelMethod
Implementation of Uberspect to additionally provide access to public fields.
This is an input stream that is unicode BOM aware.
Helper class to bundle encoding and BOM marker.
This is a simple URL-based loader.
Method used for regular method invocation
$foo.bar()
VelocimacroFactory.java
manages the set of VMs in a running Velocity engine.
small container class to hold the tuple
of a template and modification time.
Manages VMs in namespaces.
wrapper class for holding VM information
VelocimacroProxy.java
a proxy Directive-derived object to fit with the current directive system
This class provides services to the application
developer, such as:
Simple Velocity Runtime engine initialization methods.
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
General purpose implementation of the application Context
interface for general application use.
This class provides a separate new-able instance of the
Velocity template engine.
Base class for Velocity runtime exceptions thrown to the
application layer.
Implementation of a fast Writer.
Interface defining a 'getter'.
Interface used for setting values that appear to be properties in
Velocity.
Example to show basic XML handling in a template.
TypeConversionHandler