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...
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 OR both are subclasses of java.lang.NumberThis class is responsible for handling Escapes
in VTL.
This class is responsible for handling EscapedDirectives
in VTL.
Handles floating point numbers.
Handles arg1 >= arg2
Only subclasses of Number can be compared.
Please look at the Parser.jjt file which is what controls the generation of this class.
Only subclasses of Number can be compared.
Please look at the Parser.jjt file which is what controls the generation of this class.
Handles arg1 > arg2
Only subclasses of Number can be compared.
Please look at the Parser.jjt file which is what controls the generation of this class.
Only subclasses of Number can be compared.
Please look at the Parser.jjt file which is what controls the generation of this class.
ASTIdentifier.java
Method support for identifiers : $foo
mainly used by ASTRefrence
Introspection is now moved to 'just in time' or at render / execution
time.
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
Only subclasses of Number can be compared.
Please look at the Parser.jjt file which is what controls the generation of this class.
Only subclasses of Number can be compared.
Please look at the Parser.jjt file which is what controls the generation of this class.
Handles arg1 < arg2
Only subclasses of Number can be compared.
Please look at the Parser.jjt file which is what controls the generation of this class.
Only subclasses of Number can be compared.
Please look at the Parser.jjt file which is what controls the generation of this class.
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
This operator requires that the LHS and RHS are both of the
same Class OR both are subclasses of java.lang.NumberPlease 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 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.
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.
This is a simple template file loader that loads templates
from a DataSource instead of plain files.
Directive that puts an unrendered AST block in the context
under the specified key, postponing rendering until the
reference is used and rendered.
Base class for all directives used in Velocity.
Base class for all directives used in Velocity.
An Iterator wrapper for an Enumeration.
Evaluates the directive argument as a VTL string, using the existing
context.
Deprecated.
Will be removed in 2.0
Stores the event handlers.
Base interface for all event handlers
Strategy object used to execute event handler method.
Calls on request all registered event handlers for a particular event.
Use this to create a new Exception.
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 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.
Foreach directive used for moving through arrays,
or objects that provide an Iterator.
A special context to use when the foreach iterator returns a null.
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.
Pre-init logger.
Pluggable directive that handles the #include() statement in VTL.
Event handler for include type directives (e.g.
Defines the execution strategy for includeEvent
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.
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.
The introspector cache API definition.
This is the internal introspector cache implementation.
Event handler called when an invalid reference is encountered.
Defines the execution strategy for invalidGetMethod
Defines the execution strategy for invalidGetMethod
Defines the execution strategy for invalidGetMethod
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.
Implementation of a simple java.util.logging LogChute.
When the runtime.introspection.uberspect configuration property contains several
uberspector class names, it means those uberspectors will be chained.
Deprecated.
Use the #[[unparsed content]]# syntax instead.
Convenient wrapper for LogChute functions.
Base interface that logging systems need to implement.
Wrapper to make user's custom LogSystem implementations work
with the new LogChute setup.
This is a wrapper around a log object, that can add a prefix to log messages
and also turn logging on and off dynamically.
This class is responsible for instantiating the correct LogChute
Deprecated.
Use LogChute instead!
Macro implements the macro definition directive of VTL.
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
Factory class for creating Maps.
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.
Defines the execution strategy for methodException
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.
Logger used in case of failure.
Deprecated.
Use NullLogChute.
Event handler called when the RHS of #set is null.
Defines the execution strategy for shouldLogOnNullSet
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.
This class is responsible for parsing a Velocity
template.
Token literal values and constants.
Provides instances of parsers as needed.
This wraps the original parser SimplePool class.
Token Manager.
Holds the state of the parsing process.
Interface used in implementation of visitor pattern.
Deprecated.
Use HoldingLogChute instead!
Simple event handler that renders method exceptions in the page
rather than throwing the exception.
Returned the value of object property when executed.
Context for Velocity macro arguments.
Executor that simply tries to execute a put(key, value)
operation.
Reference 'Stream insertion' event handler.
Defines the execution strategy for referenceInsert
This interface caraterize 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.
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.
Deprecated.
Use RuntimeInstance or RuntimeSingleton instead.
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.
This is the Runtime system for Velocity.
Deprecated.
This functionality has been taken over by the Log class
Deprecated.
This will be removed along with the RuntimeLogger interface.
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
Simple object pool.
This class implements the #stop directive which allows
a user to stop the merging and rendering process.
Stop command for directive Control objects.
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 methods used by torque.
Logger used when no other is configured.
This class is used for controlling all template
operations.
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.
Describes the input token stream.
'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
Marker interface to let an uberspector indicate it can and wants to
log
Thanks to Paulo for the suggestion
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 implemention 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.
Deprecated.
This class has been replaced by NumberTool, DateTool,
DisplayTool, and AlternatorTool available from the Velocity-Tools sub-project.
Implementation of a fast Writer.
Interface defining a 'getter'.
Interface used for setting values that appear to be properties in
Velocity.