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.
A JDOM Element that is tailored for Anakia needs.
A customized JDOMFactory for Anakia that produces AnakiaElement instances instead of ordinary JDOM Element instances.
The purpose of this Ant Task is to allow you to use Velocity as an XML transformation tool like XSLT is.
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.
 
 
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.
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.Number
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

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.
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.
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.
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.
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.
Handles multiplication

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.Number
 
 
Please 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.
 
This node holds the "Textblock" data which should not be interpreted by Velocity.
 
 
 
Implementation of a Avalon logger.
Implementation of a Avalon logger.
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.
ClasspathResourceLoader is a simple loader that will load templates from the classpath.
Simple utility functions for manipulating classes and resources from the classloader.
Redirects Velocity's LogChute messages to commons-logging.
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.
This class is for escaping CDATA sections.
Escape all HTML entities.
Escapes the characters in a String to be suitable for use in JavaScript.
Base class for escaping references.
Escapes the characters in a String to be suitable to pass to an SQL query.
Escape all XML entities.
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.
A general file utility for use in the context
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.
A text/code generator class
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.
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.
Interface for event support.
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.
Implementation of a simple log4j system that will either latch onto an existing category, or just do a simple rolling file log.
Deprecated.
Use Log4JLogChute instead.
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:
add ( new Integer(10), new Integer(1)) will return an Integer-Object with the value 11
add ( new Long(10), new Integer(1)) will return an Long-Object with the value 11
add ( new Integer(10), new Float(1)) will return an Float-Object with the value 11

Overflow 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.
Provides a class for wrapping a list of JDOM objects primarily for use in template engines and other kinds of text transformation tools.
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
This class extends XMLOutputter in order to provide a way to walk an Element tree into a String.
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.
 
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.
A property utility class for the texen text/code generator Usually this class is only used from a Velocity context.
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.
Simple wrapper for the servlet log.
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
Deprecated.
Use Log4JLogChute instead.
 
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.
An ant task for generating output by using Velocity
Describes the input token stream.
 
This class allows you to walk a tree of JDOM Element objects.
'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.
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.
Manages VMs in namespaces.
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.
 
Deprecated.
This servlet has been replaced by VelocityViewServlet, 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.
Deprecated.
Obsolete and outdated.
This class adds an entrypoint into XPath functionality, for Anakia.