/**
* Allow an external system to set an ExtendedProperties object to use. This is useful where the
* external system also uses the ExtendedProperties class and the velocity configuration is a
* subset of parent application's configuration. This is the case with Turbine.
*
* @param ExtendedProperties configuration
*/
public static void setConfiguration(ExtendedProperties configuration) {
ri.setConfiguration(configuration);
}
/**
* Return the velocity runtime configuration object.
*
* @return ExtendedProperties configuration object which houses the velocity runtime properties.
*/
public static ExtendedProperties getConfiguration() {
return ri.getConfiguration();
}
/** @see org.apache.velocity.runtime.RuntimeServices#getApplicationAttribute(Object) */
public static Object getApplicationAttribute(Object key) {
return ri.getApplicationAttribute(key);
}
/**
* String property accessor method to hide the configuration implementation
*
* @param key property key
* @return value of key or null
*/
public static String getString(String key) {
return ri.getString(key);
}
/**
* Int property accessor method to hide the configuration implementation.
*
* @param key property key
* @param int default value
* @return int value
*/
public static int getInt(String key, int defaultValue) {
return ri.getInt(key, defaultValue);
}
/**
* Returns the appropriate VelocimacroProxy object if strVMname is a valid current Velocimacro.
*
* @param String vmName Name of velocimacro requested
* @return String VelocimacroProxy
*/
public static Directive getVelocimacro(String vmName, String templateName) {
return ri.getVelocimacro(vmName, templateName);
}
/**
* Checks to see if a VM exists
*
* @param name Name of velocimacro
* @return boolean True if VM by that name exists, false if not
*/
public static boolean isVelocimacro(String vmName, String templateName) {
return ri.isVelocimacro(vmName, templateName);
}
/**
* Returns a JavaCC generated Parser.
*
* @return Parser javacc generated parser
*/
private static Parser createNewParser() {
return ri.createNewParser();
}
/**
* Parse the input and return the root of AST node structure. <br>
* <br>
* In the event that it runs out of parsers in the pool, it will create and let them be GC'd
* dynamically, logging that it has to do that. This is considered an exceptional condition. It is
* expected that the user will set the PARSER_POOL_SIZE property appropriately for their
* application. We will revisit this.
*
* @param InputStream inputstream retrieved by a resource loader
* @param String name of the template being parsed
*/
public static SimpleNode parse(Reader reader, String templateName) throws ParseException {
return ri.parse(reader, templateName);
}
/**
* Initialize the Velocity Runtime with a Properties object.
*
* @param Properties
*/
public static void init(Properties p) throws Exception {
ri.init(p);
}
/**
* Initialize the Velocity Runtime with the name of ExtendedProperties object.
*
* @param Properties
*/
public static void init(String configurationFile) throws Exception {
ri.init(configurationFile);
}
/**
* Allows an external caller to get a property. The calling routine is required to know the type,
* as this routine will return an Object, as that is what properties can be.
*
* @param key property to return
*/
public static Object getProperty(String key) {
return ri.getProperty(key);
}
/**
* Clear the values pertaining to a particular property.
*
* @param String key of property to clear
*/
public static void clearProperty(String key) {
ri.clearProperty(key);
}
/**
* Add a property to the configuration. If it already exists then the value stated here will be
* added to the configuration entry. For example, if
*
* <p>resource.loader = file
*
* <p>is already present in the configuration and you
*
* <p>addProperty("resource.loader", "classpath")
*
* <p>Then you will end up with a Vector like the following:
*
* <p>["file", "classpath"]
*
* @param String key
* @param String value
*/
public static void addProperty(String key, Object value) {
ri.addProperty(key, value);
}
/**
* Log a debug message.
*
* @param Object message to log
*/
public static void debug(Object message) {
ri.debug(message);
}
/**
* Parse the input and return the root of the AST node structure.
*
* @param InputStream inputstream retrieved by a resource loader
* @param String name of the template being parsed
* @param dumpNamespace flag to dump the Velocimacro namespace for this template
*/
public static SimpleNode parse(Reader reader, String templateName, boolean dumpNamespace)
throws ParseException {
return ri.parse(reader, templateName, dumpNamespace);
}
/**
* String property accessor method with default to hide the configuration implementation.
*
* @param String key property key
* @param String defaultValue default value to return if key not found in resource manager.
* @return String value of key or default
*/
public static String getString(String key, String defaultValue) {
return ri.getString(key, defaultValue);
}
/**
* Returns a <code>Template</code> from the resource manager
*
* @param name The name of the desired template.
* @param encoding Character encoding of the template
* @return The template.
* @throws ResourceNotFoundException if template not found from any available source.
* @throws ParseErrorException if template cannot be parsed due to syntax (or other) error.
* @throws Exception if an error occurs in template initialization
*/
public static Template getTemplate(String name, String encoding)
throws ResourceNotFoundException, ParseErrorException, Exception {
return ri.getTemplate(name, encoding);
}
/**
* Adds a new Velocimacro. Usually called by Macro only while parsing.
*
* @param String name Name of velocimacro
* @param String macro String form of macro body
* @param String argArray Array of strings, containing the #macro() arguments. the 0th is the
* name.
* @return boolean True if added, false if rejected for some reason (either parameters or
* permission settings)
*/
public static boolean addVelocimacro(
String name, Node macro, String argArray[], String sourceTemplate) {
return ri.addVelocimacro(name, macro, argArray, sourceTemplate);
}
/**
* Returns a static content resource from the resource manager.
*
* @param name Name of content resource to get
* @param encoding Character encoding to use
* @return parsed ContentResource object ready for use
* @throws ResourceNotFoundException if template not found from any available source.
*/
public static ContentResource getContent(String name, String encoding)
throws ResourceNotFoundException, ParseErrorException, Exception {
return ri.getContent(name, encoding);
}
/**
* tells the vmFactory to dump the specified namespace. This is to support clearing the VM list
* when in inline-VM-local-scope mode
*/
public static boolean dumpVMNamespace(String namespace) {
return ri.dumpVMNamespace(namespace);
}
/**
* Determines is a template exists, and returns name of the loader that provides it. This is a
* slightly less hokey way to support the Velocity.templateExists() utility method, which was
* broken when per-template encoding was introduced. We can revisit this.
*
* @param resourceName Name of template or content resource
* @return class name of loader than can provide it
*/
public static String getLoaderNameForResource(String resourceName) {
return ri.getLoaderNameForResource(resourceName);
}
/**
* Int property accessor method to hide the configuration implementation.
*
* @param String key property key
* @return int value
*/
public static int getInt(String key) {
return ri.getInt(key);
}
/**
* Log a warning message.
*
* @param Object message to log
*/
public static void warn(Object message) {
ri.warn(message);
}
/**
* Boolean property accessor method to hide the configuration implementation.
*
* @param String key property key
* @param boolean default default value if property not found
* @return boolean value of key or default value
*/
public static boolean getBoolean(String key, boolean def) {
return ri.getBoolean(key, def);
}
/**
* Log an info message.
*
* @param Object message to log
*/
public static void info(Object message) {
ri.info(message);
}
/**
* Return the Introspector for this RuntimeInstance
*
* @return Introspector object for this runtime instance
*/
public static Introspector getIntrospector() {
return ri.getIntrospector();
}
/**
* Log an error message.
*
* @param Object message to log
*/
public static void error(Object message) {
ri.error(message);
}
/** @see org.apache.velocity.runtime.RuntimeServices#getUberspect() */
public static Uberspect getUberspect() {
return ri.getUberspect();
}
/**
* Allows an external system to set a property in the Velocity Runtime.
*
* @param String property key
* @param String property value
*/
public static void setProperty(String key, Object value) {
ri.setProperty(key, value);
}
