<?xml version="1.0"?>
<doc>
    <assembly>
        <name>NVelocity</name>
    </assembly>
    <members>
        <member name="T:NVelocity.App.Events.EventCartridge">
            <summary>
            'Package' of event handlers...
            </summary>
        </member>
        <member name="M:NVelocity.App.Events.EventCartridge.ReferenceInsert(System.Collections.Stack,System.String,System.Object)">
            <summary>
            Called during Velocity merge before a reference value will
            be inserted into the output stream.
            </summary>
            <param name="referenceStack">the stack of objects used to reach this reference</param>
            <param name="reference">reference from template about to be inserted</param>
            <param name="value"> value about to be inserted (after toString() )</param>
            <returns>
            Object on which toString() should be called for output.
            </returns>
        </member>
        <member name="M:NVelocity.App.Events.EventCartridge.ShouldLogOnNullSet(System.String,System.String)">
            <summary>
            Called during Velocity merge to determine if when
            a #set() results in a null assignment, a warning
            is logged.
            </summary>
            <returns>true if to be logged, false otherwise</returns>
        </member>
        <member name="M:NVelocity.App.Events.EventCartridge.HandleMethodException(System.Type,System.String,System.Exception)">
            <summary>
            Called during Velocity merge if a reference is null
            </summary>
            <param name="type">Class that is causing the exception</param>
            <param name="method">method called that causes the exception</param>
            <param name="e">Exception thrown by the method</param>
            <returns>Object to return as method result</returns>
            <exception cref="T:System.Exception">exception to be wrapped and propagated to app</exception>
        </member>
        <member name="M:NVelocity.App.Events.EventCartridge.AttachToContext(NVelocity.Context.IContext)">
            <summary>
            Attached the EventCartridge to the context
            </summary>
            <param name="context">context to attach to</param>
            <returns>true if successful, false otherwise</returns>
        </member>
        <member name="T:NVelocity.App.Events.EventHandler">
             <summary>  Base interface for all event handlers
             *
             </summary>
             <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
             </author>
             <version> $Id: EventHandler.cs,v 1.3 2003/10/27 13:54:07 corts Exp $
            
             </version>
        </member>
        <member name="T:NVelocity.App.Events.NullSetEventHandler">
            <summary>
            Lets an app approve / veto writing a log message when RHS of #set() is null.
            </summary>
        </member>
        <member name="P:NVelocity.App.Events.NullSetEventArgs.LHS">
            <summary>
            Reference literal of left-hand-side of set statement
            </summary>
        </member>
        <member name="P:NVelocity.App.Events.NullSetEventArgs.RHS">
            <summary>
            reference literal of right-hand-side of set statement
            </summary>
        </member>
        <member name="T:NVelocity.App.Tools.VelocityFormatter">
            <summary>
            Formatting tool for inserting into the Velocity WebContext.  Can
            format dates or lists of objects.
            
            <para>Here's an example of some uses:
            <code><pre>
            $formatter.formatShortDate($object.Date)
            $formatter.formatLongDate($db.getRecord(232).getDate())
            $formatter.formatArray($array)
            $formatter.limitLen(30, $object.Description)
            </pre></code>
            </para>
            </summary>
            <author><a href="mailto:sean@somacity.com">Sean Legassick</a></author>
            <author><a href="mailto:dlr@collab.net">Daniel Rall</a></author>
            <version>$Id: VelocityFormatter.cs,v 1.5 2003/11/05 04:15:02 corts Exp $</version>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.#ctor(NVelocity.Context.IContext)">
            <summary>
            Constructor needs a backPointer to the context.
            </summary>
            <param name="context">A Context.</param>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatShortDate(System.DateTime)">
            <summary>
            Formats a date in 'short' style.
            </summary>
            <param name="date">A Date.</param>
            <returns>A String.</returns>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatLongDate(System.DateTime)">
            <summary>
            Formats a date in 'long' style.
            </summary>
            <param name="date">A Date.</param>
            <returns>A String.</returns>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatShortDateTime(System.DateTime)">
            <summary>
            Formats a date/time in 'short' style.
            </summary>
            <param name="date">A Date.</param>
            <returns>A String.</returns>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatLongDateTime(System.DateTime)">
            <summary>
            Formats a date/time in 'long' style.
            </summary>
            <param name="date">A Date.</param>
            <returns>A String.</returns>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatArray(System.Object)">
            <summary>
            Formats an array into the form "A, B and C".
            </summary>
            <param name="array">An Object.</param>
            <returns>A String.</returns>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatArray(System.Object,System.String)">
            <summary> 
            Formats an array into the form
            "A&lt;delim&gt;B&lt;delim&gt;C".
            </summary>
            <param name="array">An Object.</param>
            <param name="delim">A String.</param>
            <returns>A String.</returns>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatArray(System.Object,System.String,System.String)">
            <summary>
            Formats an array into the form
            "A&lt;delim&gt;B&lt;finalDelimiter&gt;C".
            </summary>
            <param name="array">An Object.</param>
            <param name="delim">A String.</param>
            <param name="finalDelimiter">A String.</param>
            <returns>A String.</returns>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatVector(System.Collections.IList)">
            <summary>
            Formats a list into the form "A, B and C".
            </summary>
            <param name="list">A list.</param>
            <returns>A String.</returns>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatVector(System.Collections.IList,System.String)">
            <summary>
            Formats a list into the form "A&lt;delim&gt;B&lt;delim&gt;C".
            </summary>
            <param name="list">A list.</param>
            <param name="delim">A String.</param>
            <returns>A String.</returns>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatVector(System.Collections.IList,System.String,System.String)">
            <summary>
            Formats a list into the form
            "Adelim&gt;B&lt;finalDelimiter&gt;C".
            </summary>
            <param name="list">A list.</param>
            <param name="delim">A String.</param>
            <param name="finalDelimiter">A String.</param>
            <returns>A String.</returns>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.LimitLen(System.Int32,System.String)">
            <summary>
            Limits 'string' to 'maximumLength' characters.  If the string gets
            curtailed, "..." is appended to it.
            </summary>
            <param name="maximumLength">An int with the maximum length.</param>
            <param name="value">A String.</param>
            <returns>A String.</returns>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.LimitLen(System.Int32,System.String,System.String)">
            <summary>
            Limits 'string' to 'maximumLength' character.  If the string gets
            curtailed, 'suffix' is appended to it.
            </summary>
            <param name="maximumLength">An int with the maximum length.</param>
            <param name="value">A String.</param>
            <param name="suffix">A String.</param>
            <returns>A String.</returns>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.MakeAlternator(System.String,System.String,System.String)">
            <summary>
            Makes an alternator object that alternates between two values.
            
            <para>Example usage in a Velocity template:
            
            <code>
            &lt;table&gt;
            $formatter.makeAlternator("rowColor", "#c0c0c0", "#e0e0e0")
            #foreach $item in $items
            &lt;tr&gt;&lt;td bgcolor="$rowColor"&gt;$item.Name&lt;/td&gt;&lt;/tr&gt;
            $rowColor.alternate()
            #end
            &lt;/table&gt;
            </code>
            </para>
            </summary>
            <param name="name">The name for the alternator int the context.</param>
            <param name="alt1">The first alternate.</param>
            <param name="alt2">The second alternate.</param>
            <returns>The newly created instance.</returns>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.MakeAlternator(System.String,System.String,System.String,System.String)">
            <summary>
            Makes an alternator object that alternates between three values.
            </summary>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.MakeAlternator(System.String,System.String,System.String,System.String,System.String)">
            <summary>
            Makes an alternator object that alternates between four values.
            </summary>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.MakeAutoAlternator(System.String,System.String,System.String)">
            <summary>
            Makes an alternator object that alternates between two values
            automatically.
            </summary>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.IsNull(System.Object,System.Object)">
            <summary>
            Returns a default value if the object passed is null.
            </summary>
        </member>
        <member name="T:NVelocity.App.Tools.VelocityFormatter.VelocityAlternator">
            <summary>
            Class that returns alternating values in a template.  It stores
            a list of alternate Strings, whenever alternate() is called it
            switches to the next in the list.  The current alternate is
            retrieved through toString() - i.e. just by referencing the
            object in a Velocity template.  For an example of usage see the
            makeAlternator() method below.
            </summary>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.VelocityAlternator.#ctor(System.String[])">
            <summary>
            Constructor takes an array of Strings.
            </summary>
            <param name="alternates">A String[].
            </param>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.VelocityAlternator.Alternate">
            <summary>
            Alternates to the next in the list.
            </summary>
            <returns>The current alternate in the sequence.</returns>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.VelocityAlternator.ToString">
            <summary>
            Returns the current alternate.
            </summary>
            <returns>A String.</returns>
        </member>
        <member name="T:NVelocity.App.Tools.VelocityFormatter.VelocityAutoAlternator">
            <summary>
            As VelocityAlternator, but calls <code>alternate()</code>
            automatically on rendering in a template.
            </summary>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.VelocityAutoAlternator.#ctor(System.String[])">
             <summary>
             Constructor takes an array of Strings.
             </summary>
             <param name="alternates">A String[].
            
             </param>
        </member>
        <member name="M:NVelocity.App.Tools.VelocityFormatter.VelocityAutoAlternator.ToString">
            <summary>
            Returns the current alternate, and automatically alternates
            to the next alternate in its sequence (triggered upon
            rendering).
            </summary>
            <returns>The current alternate in the sequence.</returns>
        </member>
        <member name="T:NVelocity.App.FieldMethodizer">
             <summary>
             <para>This is a small utility class allow easy access to static fields in a class,
             such as string constants.  Velocity will not introspect for class
             fields (and won't in the future :), but writing setter/getter methods to do
             this really is a pain,  so use this if you really have
             to access fields.</para>
            
             <para>The idea it so enable access to the fields just like you would in Java.
             For example, in Java, you would access a static field like
             <blockquote><pre>
             MyClass.STRING_CONSTANT
             </pre></blockquote>
             and that is the same thing we are trying to allow here.</para>
            
             <para>So to use in your Java code, do something like this :
             <blockquote><pre>
             context.put("runtime", new FieldMethodizer( "NVelocity.Runtime.Runtime" ));
             </pre></blockquote>
             and then in your template, you can access any of your static fields in this way :
             <blockquote><pre>
             $runtime.RUNTIME_LOG_WARN_STACKTRACE
             </pre></blockquote></para>
            
             <para>Right now, this class only methodizes <code>public static</code> fields.  It seems
             that anything else is too dangerous.  This class is for convenience accessing
             'constants'.  If you have fields that aren't <code>static</code> it may be better
             to handle them by explicitly placing them into the context.</para>
             </summary>
             <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
             </author>
             <version>$Id: FieldMethodizer.cs,v 1.3 2003/10/27 13:54:07 corts Exp $</version>
        </member>
        <member name="F:NVelocity.App.FieldMethodizer.fieldHash">
            <summary>
            Hold the field objects by field name
            </summary>
        </member>
        <member name="F:NVelocity.App.FieldMethodizer.classHash">
            <summary>
            Hold the class objects by field name
            </summary>
        </member>
        <member name="M:NVelocity.App.FieldMethodizer.#ctor">
            <summary>
            Allow object to be initialized without any data. You would use
            addObject() to add data later.
            </summary>
        </member>
        <member name="M:NVelocity.App.FieldMethodizer.#ctor(System.String)">
            <summary>
            Constructor that takes as it's arg the name of the class
            to methodize.
            </summary>
            <param name="s">Name of class to methodize.</param>
        </member>
        <member name="M:NVelocity.App.FieldMethodizer.#ctor(System.Object)">
            <summary>
            Constructor that takes as it's arg a living
            object to methodize.  Note that it will still
            only methodized the public static fields of
            the class.
            </summary>
            <param name="o">object to methodize.</param>
        </member>
        <member name="M:NVelocity.App.FieldMethodizer.AddObject(System.String)">
            <summary>
            Add the Name of the class to methodize
            </summary>
        </member>
        <member name="M:NVelocity.App.FieldMethodizer.AddObject(System.Object)">
            <summary> Add an Object to methodize
            </summary>
        </member>
        <member name="M:NVelocity.App.FieldMethodizer.Get(System.String)">
            <summary>
            Accessor method to get the fields by name.
            </summary>
            <param name="fieldName">Name of static field to retrieve</param>
            <returns>The value of the given field.</returns>
        </member>
        <member name="M:NVelocity.App.FieldMethodizer.Inspect(System.Type)">
            <summary>  Method that retrieves all public static fields
            in the class we are methodizing.
            </summary>
        </member>
        <member name="T:NVelocity.App.Velocity">
            <summary>
            This class provides  services to the application
            developer, such as :
            <ul>
            <li> Simple Velocity Runtime engine initialization methods.</li>
            <li> Functions to apply the template engine to streams and strings</li>
            to allow embedding and dynamic template generation.
            <li> Methods to access Velocimacros directly.</li>
            </ul>
            <br/><br/>
            While the most common way to use NVelocity is via templates, as
            Velocity is a general-purpose template engine, there are other
            uses that NVelocity is well suited for, such as processing dynamically
            created templates, or processing content streams.
            <br/><br/>
            The methods herein were developed to allow easy access to the NVelocity
            facilities without direct spelunking of the internals.  If there is
            something you feel is necessary to add here, please, send a patch.
            </summary>
        </member>
        <member name="M:NVelocity.App.Velocity.Init">
            <summary>
            initialize the NVelocity runtime engine, using the default
            properties of the NVelocity distribution
            </summary>
        </member>
        <member name="M:NVelocity.App.Velocity.Init(System.String)">
            <summary>
            initialize the Velocity runtime engine, using default properties
            plus the properties in the properties file passed in as the arg
            </summary>
            <param name="propsFilename">
            file containing properties to use to initialize
            the Velocity runtime
            </param>
        </member>
        <member name="M:NVelocity.App.Velocity.Init(Commons.Collections.ExtendedProperties)">
            <summary>
            initialize the Velocity runtime engine, using default properties
            plus the properties in the passed in java.util.Properties object
            </summary>
            <param name="p">
            Proprties object containing initialization properties
            </param>
        </member>
        <member name="M:NVelocity.App.Velocity.SetProperty(System.String,System.Object)">
            <summary>
            Set a Velocity Runtime property.
            </summary>
            <param name="key">key</param>
            <param name="value">value</param>
        </member>
        <member name="M:NVelocity.App.Velocity.AddProperty(System.String,System.Object)">
            <summary>
            Add a Velocity Runtime property.
            </summary>
            <param name="key">key</param>
            <param name="value">value</param>
        </member>
        <member name="M:NVelocity.App.Velocity.ClearProperty(System.String)">
            <summary>
            Clear a NVelocity Runtime property.
            </summary>
            <param name="key">of property to clear</param>
        </member>
        <member name="M:NVelocity.App.Velocity.SetExtendedProperties(Commons.Collections.ExtendedProperties)">
            <summary>
            Set an entire configuration at once. This is
            useful in cases where the parent application uses
            the ExtendedProperties class and the velocity configuration
            is a subset of the parent application's configuration.
            </summary>
        </member>
        <member name="M:NVelocity.App.Velocity.GetProperty(System.String)">
            <summary>
            Get a Velocity Runtime property.
            </summary>
            <param name="key">property to retrieve</param>
            <returns>property value or null if the property not currently set</returns>
        </member>
        <member name="M:NVelocity.App.Velocity.Evaluate(NVelocity.Context.IContext,System.IO.TextWriter,System.String,System.String)">
            <summary>
            renders the input string using the context into the output writer.
            To be used when a template is dynamically constructed, or want to use
            Velocity as a token replacer.
            </summary>
            <param name="context">context to use in rendering input string</param>
            <param name="writer"> Writer in which to render the output</param>
            <param name="logTag"> string to be used as the template name for log messages in case of error</param>
            <param name="inString">input string containing the VTL to be rendered</param>
            <returns>true if successful, false otherwise.  If false, see Velocity runtime log</returns>
        </member>
        <member name="M:NVelocity.App.Velocity.Evaluate(NVelocity.Context.IContext,System.IO.TextWriter,System.String,System.IO.Stream)">
            <summary>
            Renders the input stream using the context into the output writer.
            To be used when a template is dynamically constructed, or want to
            use Velocity as a token replacer.
            </summary>
            <param name="context">context to use in rendering input string</param>
            <param name="writer"> Writer in which to render the output</param>
            <param name="logTag"> string to be used as the template name for log messages in case of error</param>
            <param name="instream">input stream containing the VTL to be rendered</param>
            <returns>true if successful, false otherwise.  If false, see Velocity runtime log</returns>
        </member>
        <member name="M:NVelocity.App.Velocity.Evaluate(NVelocity.Context.IContext,System.IO.TextWriter,System.String,System.IO.TextReader)">
            <summary>
            Renders the input reader using the context into the output writer.
            To be used when a template is dynamically constructed, or want to
            use Velocity as a token replacer.
            </summary>
            <param name="context">context to use in rendering input string</param>
            <param name="writer"> Writer in which to render the output</param>
            <param name="logTag"> string to be used as the template name for log messages in case of error</param>
            <param name="reader">Reader containing the VTL to be rendered</param>
            <returns>true if successful, false otherwise.  If false, see Velocity runtime log</returns>
        </member>
        <member name="M:NVelocity.App.Velocity.InvokeVelocimacro(System.String,System.String,System.String[],NVelocity.Context.IContext,System.IO.TextWriter)">
            <summary>
            Invokes a currently registered Velocimacro with the parameters provided
            and places the rendered stream into the writer.
            
            Note : currently only accepts args to the VM if they are in the context.
            </summary>
            <param name="vmName">name of Velocimacro to call</param>
            <param name="logTag">string to be used for template name in case of error</param>
            <param name="parameters">args used to invoke Velocimacro. In context key format :
            eg  "foo","bar" (rather than "$foo","$bar")
            </param>
            <param name="context">Context object containing data/objects used for rendering.</param>
            <param name="writer"> Writer for output stream</param>
            <returns>true if Velocimacro exists and successfully invoked, false otherwise.</returns>
        </member>
        <member name="M:NVelocity.App.Velocity.MergeTemplate(System.String,NVelocity.Context.IContext,System.IO.TextWriter)">
            <summary>
            merges a template and puts the rendered stream into the writer
            </summary>
            <param name="templateName">name of template to be used in merge</param>
            <param name="context"> filled context to be used in merge</param>
            <param name="writer"> writer to write template into</param>
            <returns>true if successful, false otherwise.  Errors logged to velocity log.</returns>
        </member>
        <member name="M:NVelocity.App.Velocity.MergeTemplate(System.String,System.String,NVelocity.Context.IContext,System.IO.TextWriter)">
            <summary>
            merges a template and puts the rendered stream into the writer
            </summary>
            <param name="templateName">name of template to be used in merge</param>
            <param name="encoding">encoding used in template</param>
            <param name="context"> filled context to be used in merge</param>
            <param name="writer"> writer to write template into</param>
            <returns>true if successful, false otherwise.  Errors logged to velocity log</returns>
        </member>
        <member name="M:NVelocity.App.Velocity.GetTemplate(System.String)">
            <summary>
            Returns a <code>Template</code> from the Velocity
            resource management system.
            </summary>
            <param name="name">The file name of the desired template.
            </param>
            <returns>    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
            </returns>
        </member>
        <member name="M:NVelocity.App.Velocity.GetTemplate(System.String,System.String)">
            <summary>
            Returns a <code>Template</code> from the Velocity
            resource management system.
            </summary>
            <param name="name">The file name of the desired template.</param>
            <param name="encoding">The character encoding to use for the template.</param>
            <returns>The <see cref="T:NVelocity.Template"/> instance.</returns>
            <exception cref="T:NVelocity.Exception.ResourceNotFoundException">
            If template is not found from any available source.
            </exception>
            <exception cref="T:NVelocity.Exception.ParseErrorException">
            If template cannot be parsed due to syntax (or other) error.
            </exception>
            <exception cref="T:System.Exception">
            If an error occurs in template initialization.
            </exception>
        </member>
        <member name="M:NVelocity.App.Velocity.ResourceExists(System.String)">
            <summary>
            <p>Determines whether a resource is accessible via the
            currently configured resource loaders. <see cref="T:NVelocity.Runtime.Resource.Resource"/>
            is the generic description of templates, static content, etc.</p>
            
            <p>Note that the current implementation will <b>not</b> change
            the state of the system in any real way - so this cannot be
            used to pre-load the resource cache, as the previous
            implementation did as a side-effect.</p>
            </summary>
            <param name="templateName"> name of the template to search for</param>
            <returns>Whether the resource was located.</returns>
        </member>
        <member name="M:NVelocity.App.Velocity.Warn(System.Object)">
            <summary>
            Log a warning message.
            </summary>
            <param name="message">message to log
            </param>
        </member>
        <member name="M:NVelocity.App.Velocity.Info(System.Object)">
            <summary>
            Log an info message.
            </summary>
            <param name="message">message to log</param>
        </member>
        <member name="M:NVelocity.App.Velocity.Error(System.Object)">
            <summary>
            Log an error message.
            </summary>
            <param name="message">message to log</param>
        </member>
        <member name="M:NVelocity.App.Velocity.Debug(System.Object)">
            <summary>
            Log a debug message.
            </summary>
            <param name="message">message to log</param>
        </member>
        <member name="M:NVelocity.App.Velocity.SetApplicationAttribute(System.Object,System.Object)">
            <summary>
            <p>
            Set the an ApplicationAttribute, which is an Object
            set by the application which is accessible from
            any component of the system that gets a RuntimeServices.
            This allows communication between the application
            environment and custom pluggable components of the
            Velocity engine, such as loaders and loggers.
            </p>
            <p>
            Note that there is no enforcement or rules for the key
            used - it is up to the application developer.  However, to
            help make the intermixing of components possible, using
            the target Class name (e.g.  com.foo.bar ) as the key
            might help avoid collision.
            </p>
            </summary>
            <param name="key">object 'name' under which the object is stored
            </param>
            <param name="value">object to store under this key
            </param>
        </member>
        <member name="M:NVelocity.App.Velocity.TemplateExists(System.String)">
            <summary>
            <see>#ResourceExists(String)</see>
            </summary>
        </member>
        <member name="T:NVelocity.App.VelocityEngine">
            <summary>
            This class provides a separate new-able instance of the
            Velocity template engine.  The alternative model for use
            is using the Velocity class which employs the singleton
            model.
            
            Please ensure that you call one of the init() variants.
            This is critical for proper behavior.
            
            Coming soon : Velocity will call
            the parameter-less init() at the first use of this class
            if the init() wasn't explicitly called.  While this will
            ensure that Velocity functions, it almost certainly won't
            function in the way you intend, so please make sure to
            call init().
            </summary>
            <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a></author>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.#ctor">
            <summary>
            Init-less CTOR
            </summary>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.#ctor(System.String)">
            <summary>
            CTOR that invokes an init(String), initializing
            the engine using the properties file specified
            </summary>
            <exception cref="T:System.Exception"></exception>
            <param name="propsFilename">name of properties file to init with</param>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.#ctor(Commons.Collections.ExtendedProperties)">
            <summary>
            CTOR that invokes an init(String), initializing
            the engine using the Properties specified
            </summary>
            <param name="p">name of properties to init with</param>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.SetExtendedProperties(Commons.Collections.ExtendedProperties)">
            <summary>
            Set an entire configuration at once. This is
            useful in cases where the parent application uses
            the ExtendedProperties class and the velocity configuration
            is a subset of the parent application's configuration.
            </summary>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.Init">
            <summary>
            initialize the Velocity runtime engine, using the default
            properties of the Velocity distribution
            </summary>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.Init(System.String)">
            <summary>
            initialize the Velocity runtime engine, using default properties
            plus the properties in the properties file passed in as the arg
            </summary>
            <param name="propsFilename">file containing properties to use to initialize
            the Velocity runtime</param>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.Init(Commons.Collections.ExtendedProperties)">
            <summary>
            initialize the Velocity runtime engine, using default properties
            plus the properties in the passed in java.util.Properties object
            </summary>
            <param name="p"> Properties object containing initialization properties</param>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.SetProperty(System.String,System.Object)">
            <summary>
            Set a Velocity Runtime property.
            </summary>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.AddProperty(System.String,System.Object)">
            <summary>
            Add a Velocity Runtime property.
            </summary>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.ClearProperty(System.String)">
            <summary>
            Clear a Velocity Runtime property.
            </summary>
            <param name="key">key of property to clear</param>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.GetProperty(System.String)">
            <summary>
            Get a Velocity Runtime property.
            </summary>
            <param name="key">property to retrieve</param>
            <returns>
            property value or null if the property not currently set
            </returns>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.Evaluate(NVelocity.Context.IContext,System.IO.TextWriter,System.String,System.String)">
            <summary>
            renders the input string using the context into the output writer.
            To be used when a template is dynamically constructed, or want to use
            Velocity as a token replacer.
            </summary>
            <param name="context">context to use in rendering input string</param>
            <param name="writer"> Writer in which to render the output</param>
            <param name="logTag"> string to be used as the template name for log messages in case of error</param>
            <param name="inString">input string containing the VTL to be rendered</param>
            <returns>true if successful, false otherwise.  If false, see Velocity runtime log</returns>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.Evaluate(NVelocity.Context.IContext,System.IO.TextWriter,System.String,System.IO.Stream)">
            <summary>
            Renders the input stream using the context into the output writer.
            To be used when a template is dynamically constructed, or want to
            use Velocity as a token replacer.
            </summary>
            <param name="context">context to use in rendering input string</param>
            <param name="writer"> Writer in which to render the output</param>
            <param name="logTag"> string to be used as the template name for log messages in case of error</param>
            <param name="instream">input stream containing the VTL to be rendered</param>
            <returns>true if successful, false otherwise.  If false, see Velocity runtime log</returns>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.Evaluate(NVelocity.Context.IContext,System.IO.TextWriter,System.String,System.IO.TextReader)">
            <summary>
            Renders the input reader using the context into the output writer.
            To be used when a template is dynamically constructed, or want to
            use Velocity as a token replacer.
            </summary>
            <param name="context">context to use in rendering input string</param>
            <param name="writer"> Writer in which to render the output</param>
            <param name="logTag"> string to be used as the template name for log messages in case of error</param>
            <param name="reader">Reader containing the VTL to be rendered</param>
            <returns>true if successful, false otherwise.  If false, see Velocity runtime log</returns>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.InvokeVelocimacro(System.String,System.String,System.String[],NVelocity.Context.IContext,System.IO.TextWriter)">
            <summary>
            Invokes a currently registered Velocimacro with the parameters provided
            and places the rendered stream into the writer.
            Note : currently only accepts args to the VM if they are in the context.
            </summary>
            <param name="vmName">name of Velocimacro to call</param>
            <param name="logTag">string to be used for template name in case of error</param>
            <param name="parameters">args used to invoke Velocimacro. In context key format :
            eg  "foo","bar" (rather than "$foo","$bar")
            </param>
            <param name="context">Context object containing data/objects used for rendering.</param>
            <param name="writer"> Writer for output stream</param>
            <returns>true if Velocimacro exists and successfully invoked, false otherwise.</returns>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.MergeTemplate(System.String,NVelocity.Context.IContext,System.IO.TextWriter)">
            <summary>
            merges a template and puts the rendered stream into the writer
            </summary>
            <param name="templateName">name of template to be used in merge</param>
            <param name="context"> filled context to be used in merge</param>
            <param name="writer"> writer to write template into</param>
            <returns>true if successful, false otherwise.  Errors logged to velocity log.</returns>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.MergeTemplate(System.String,System.String,NVelocity.Context.IContext,System.IO.TextWriter)">
            <summary>
            merges a template and puts the rendered stream into the writer
            </summary>
            <param name="templateName">name of template to be used in merge</param>
            <param name="encoding">encoding used in template</param>
            <param name="context"> filled context to be used in merge</param>
            <param name="writer"> writer to write template into</param>
            <returns>true if successful, false otherwise.  Errors logged to velocity log</returns>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.GetTemplate(System.String)">
            <summary>
            Returns a <code>Template</code> from the Velocity
            resource management system.
            </summary>
            <param name="name">The file name of the desired template.</param>
            <returns>The template.</returns>
            <exception cref="T:NVelocity.Exception.ResourceNotFoundException">
            if template not found from any available source.
            </exception>
            <exception cref="T:NVelocity.Exception.ParseErrorException">
            if template cannot be parsed due
            to syntax (or other) error.
            </exception>
            <exception cref="T:System.Exception">
            if an error occurs in template initialization
            </exception>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.GetTemplate(System.String,System.String)">
            <summary>
            Returns a <code>Template</code> from the Velocity
            resource management system.
            </summary>
            <param name="name">The file name of the desired template.</param>
            <param name="encoding">The character encoding to use for the template.</param>
            <returns>The template.</returns>
            <exception cref="T:NVelocity.Exception.ResourceNotFoundException">
            if template not found from any available source.
            </exception>
            <exception cref="T:NVelocity.Exception.ParseErrorException">
            if template cannot be parsed due
            to syntax (or other) error.
            </exception>
            <exception cref="T:System.Exception">
            if an error occurs in template initialization
            </exception>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.TemplateExists(System.String)">
            <summary>
            Determines if a template is accessible via the currently
            configured resource loaders.
            <br/><br/>
            Note that the current implementation will <b>not</b>
            change the state of the system in any real way - so this
            cannot be used to pre-load the resource cache, as the
            previous implementation did as a side-effect.
            <br/><br/>
            The previous implementation exhibited extreme laziness and
            sloth, and the author has been flogged.
            </summary>
            <param name="templateName"> name of the template to search for
            </param>
            <returns>true if found, false otherwise
            </returns>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.Warn(System.Object)">
            <summary>
            Log a warning message.
            </summary>
            <param name="message">message to log</param>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.Info(System.Object)">
            
             <summary>
             Log an info message.
             </summary>
             <param name="message">message to log</param>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.Error(System.Object)">
            <summary>
            Log an error message.
            </summary>
            <param name="message">message to log</param>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.Debug(System.Object)">
            <summary>
            Log a debug message.
            </summary>
            <param name="message">message to log</param>
        </member>
        <member name="M:NVelocity.App.VelocityEngine.SetApplicationAttribute(System.Object,System.Object)">
            <summary>
            <p>
            Set the an ApplicationAttribute, which is an Object
            set by the application which is accessible from
            any component of the system that gets a RuntimeServices.
            This allows communication between the application
            environment and custom pluggable components of the
            Velocity engine, such as loaders and loggers.
            </p>
            <p>
            Note that there is no enforcement or rules for the key
            used - it is up to the application developer.  However, to
            help make the intermixing of components possible, using
            the target Class name (e.g.  com.foo.bar ) as the key
            might help avoid collision.
            </p>
            </summary>
            <param name="key">object 'name' under which the object is stored</param>
            <param name="value">object to store under this key</param>
        </member>
        <member name="T:Commons.Collections.CollectionsUtil">
            <summary>
            Static utility methods for collections
            </summary>
        </member>
        <member name="T:Commons.Collections.ExtendedProperties">
             <summary>
             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.
            
             <para>The Extended Properties syntax is explained here:
            
             <ul>
             <li>
             Each property has the syntax <code>key = value</code>
             </li>
             <li>
             The <i>key</i> may use any character but the equal sign '='.
             </li>
             <li>
             <i>value</i> may be separated on different lines if a backslash
             is placed at the end of the line that continues below.
             </li>
             <li>
             If <i>value</i> is a list of strings, each token is separated
             by a comma ','.
             </li>
             <li>
             Commas in each token are escaped placing a backslash right before
             the comma.
             </li>
             <li>
             If a <i>key</i> is used more than once, the values are appended
             like if they were on the same line separated with commas.
             </li>
             <li>
             Blank lines and lines starting with character '#' are skipped.
             </li>
             <li>
             If a property is named "include" (or whatever is defined by
             setInclude() and getInclude() and the value of that property is
             the full path to a file on disk, that file will be included into
             the ConfigurationsRepository. You can also pull in files relative
             to the parent configuration file. So if you have something
             like the following:
            
             include = additional.properties
            
             Then "additional.properties" is expected to be in the same
             directory as the parent configuration file.
            
             Duplicate name values will be replaced, so be careful.
            
             </li>
             </ul>
             </para>
             <para>Here is an example of a valid extended properties file:
             </para>
             <para><pre>
             # lines starting with # are comments
            
             # This is the simplest property
             key = value
            
             # A long property may be separated on multiple lines
             longvalue = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \
             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
            
             # This is a property with many tokens
             tokens_on_a_line = first token, second token
            
             # This sequence generates exactly the same result
             tokens_on_multiple_lines = first token
             tokens_on_multiple_lines = second token
            
             # commas may be escaped in tokens
             commas.excaped = Hi\, what'up?
             </pre>
             </para>
             <para><b>NOTE</b>: this class has <b>not</b> been written for
             performance nor low memory usage.  In fact, it's way slower than it
             could be and generates too much memory garbage.  But since
             performance is not an issue during intialization (and there is not
             much time to improve it), I wrote it this way.  If you don't like
             it, go ahead and tune it up!</para>
             </summary>
        </member>
        <member name="F:Commons.Collections.ExtendedProperties.defaults">
            <summary> Default configurations repository.
            </summary>
        </member>
        <member name="F:Commons.Collections.ExtendedProperties.file">
            <summary>
            The file connected to this repository (holding comments and such).
            </summary>
        </member>
        <member name="F:Commons.Collections.ExtendedProperties.basePath">
            <summary>
            Base path of the configuration file used to create
            this ExtendedProperties object.
            </summary>
        </member>
        <member name="F:Commons.Collections.ExtendedProperties.fileSeparator">
            <summary>
            File separator.
            </summary>
        </member>
        <member name="F:Commons.Collections.ExtendedProperties.isInitialized">
            <summary>
            Has this configuration been initialized.
            </summary>
        </member>
        <member name="F:Commons.Collections.ExtendedProperties.include">
            <summary>
            This is the name of the property that can point to other
            properties file for including other properties files.
            </summary>
        </m…