• R/O
  • SSH
  • HTTPS

ea2ddl: コミット


コミットメタ情報

リビジョン135 (tree)
日時2011-09-21 01:11:57
作者taktos9

ログメッセージ

NVelocity を追加

変更サマリ

差分

--- trunk/ea2ddl.net/ea2ddl.net/Model/TableModel.cs (revision 134)
+++ trunk/ea2ddl.net/ea2ddl.net/Model/TableModel.cs (revision 135)
@@ -15,8 +15,14 @@
1515 /// </summary>
1616 public class TableModel
1717 {
18+ public string Name {get; internal set;}
19+
1820 public TableModel()
1921 {
2022 }
23+
24+ public override string ToString() {
25+ return Name;
26+ }
2127 }
2228 }
--- trunk/ea2ddl.net/lib/NVelocity.xml (nonexistent)
+++ trunk/ea2ddl.net/lib/NVelocity.xml (revision 135)
@@ -0,0 +1,7340 @@
1+<?xml version="1.0"?>
2+<doc>
3+ <assembly>
4+ <name>NVelocity</name>
5+ </assembly>
6+ <members>
7+ <member name="T:NVelocity.App.Events.EventCartridge">
8+ <summary>
9+ 'Package' of event handlers...
10+ </summary>
11+ </member>
12+ <member name="M:NVelocity.App.Events.EventCartridge.ReferenceInsert(System.Collections.Stack,System.String,System.Object)">
13+ <summary>
14+ Called during Velocity merge before a reference value will
15+ be inserted into the output stream.
16+ </summary>
17+ <param name="referenceStack">the stack of objects used to reach this reference</param>
18+ <param name="reference">reference from template about to be inserted</param>
19+ <param name="value"> value about to be inserted (after toString() )</param>
20+ <returns>
21+ Object on which toString() should be called for output.
22+ </returns>
23+ </member>
24+ <member name="M:NVelocity.App.Events.EventCartridge.ShouldLogOnNullSet(System.String,System.String)">
25+ <summary>
26+ Called during Velocity merge to determine if when
27+ a #set() results in a null assignment, a warning
28+ is logged.
29+ </summary>
30+ <returns>true if to be logged, false otherwise</returns>
31+ </member>
32+ <member name="M:NVelocity.App.Events.EventCartridge.HandleMethodException(System.Type,System.String,System.Exception)">
33+ <summary>
34+ Called during Velocity merge if a reference is null
35+ </summary>
36+ <param name="type">Class that is causing the exception</param>
37+ <param name="method">method called that causes the exception</param>
38+ <param name="e">Exception thrown by the method</param>
39+ <returns>Object to return as method result</returns>
40+ <exception cref="T:System.Exception">exception to be wrapped and propagated to app</exception>
41+ </member>
42+ <member name="M:NVelocity.App.Events.EventCartridge.AttachToContext(NVelocity.Context.IContext)">
43+ <summary>
44+ Attached the EventCartridge to the context
45+ </summary>
46+ <param name="context">context to attach to</param>
47+ <returns>true if successful, false otherwise</returns>
48+ </member>
49+ <member name="T:NVelocity.App.Events.EventHandler">
50+ <summary> Base interface for all event handlers
51+ *
52+ </summary>
53+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
54+ </author>
55+ <version> $Id: EventHandler.cs,v 1.3 2003/10/27 13:54:07 corts Exp $
56+
57+ </version>
58+ </member>
59+ <member name="T:NVelocity.App.Events.NullSetEventHandler">
60+ <summary>
61+ Lets an app approve / veto writing a log message when RHS of #set() is null.
62+ </summary>
63+ </member>
64+ <member name="P:NVelocity.App.Events.NullSetEventArgs.LHS">
65+ <summary>
66+ Reference literal of left-hand-side of set statement
67+ </summary>
68+ </member>
69+ <member name="P:NVelocity.App.Events.NullSetEventArgs.RHS">
70+ <summary>
71+ reference literal of right-hand-side of set statement
72+ </summary>
73+ </member>
74+ <member name="T:NVelocity.App.FieldMethodizer">
75+ <summary>
76+ <para>This is a small utility class allow easy access to static fields in a class,
77+ such as string constants. Velocity will not introspect for class
78+ fields (and won't in the future :), but writing setter/getter methods to do
79+ this really is a pain, so use this if you really have
80+ to access fields.</para>
81+
82+ <para>The idea it so enable access to the fields just like you would in Java.
83+ For example, in Java, you would access a static field like
84+ <blockquote><pre>
85+ MyClass.STRING_CONSTANT
86+ </pre></blockquote>
87+ and that is the same thing we are trying to allow here.</para>
88+
89+ <para>So to use in your Java code, do something like this :
90+ <blockquote><pre>
91+ context.put("runtime", new FieldMethodizer( "NVelocity.Runtime.Runtime" ));
92+ </pre></blockquote>
93+ and then in your template, you can access any of your static fields in this way :
94+ <blockquote><pre>
95+ $runtime.RUNTIME_LOG_WARN_STACKTRACE
96+ </pre></blockquote></para>
97+
98+ <para>Right now, this class only methodizes <code>public static</code> fields. It seems
99+ that anything else is too dangerous. This class is for convenience accessing
100+ 'constants'. If you have fields that aren't <code>static</code> it may be better
101+ to handle them by explicitly placing them into the context.</para>
102+ </summary>
103+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
104+ </author>
105+ <version>$Id: FieldMethodizer.cs,v 1.3 2003/10/27 13:54:07 corts Exp $</version>
106+ </member>
107+ <member name="F:NVelocity.App.FieldMethodizer.fieldHash">
108+ <summary>
109+ Hold the field objects by field name
110+ </summary>
111+ </member>
112+ <member name="F:NVelocity.App.FieldMethodizer.classHash">
113+ <summary>
114+ Hold the class objects by field name
115+ </summary>
116+ </member>
117+ <member name="M:NVelocity.App.FieldMethodizer.#ctor">
118+ <summary>
119+ Allow object to be initialized without any data. You would use
120+ addObject() to add data later.
121+ </summary>
122+ </member>
123+ <member name="M:NVelocity.App.FieldMethodizer.#ctor(System.String)">
124+ <summary>
125+ Constructor that takes as it's arg the name of the class
126+ to methodize.
127+ </summary>
128+ <param name="s">Name of class to methodize.</param>
129+ </member>
130+ <member name="M:NVelocity.App.FieldMethodizer.#ctor(System.Object)">
131+ <summary>
132+ Constructor that takes as it's arg a living
133+ object to methodize. Note that it will still
134+ only methodized the public static fields of
135+ the class.
136+ </summary>
137+ <param name="o">object to methodize.</param>
138+ </member>
139+ <member name="M:NVelocity.App.FieldMethodizer.AddObject(System.String)">
140+ <summary>
141+ Add the Name of the class to methodize
142+ </summary>
143+ </member>
144+ <member name="M:NVelocity.App.FieldMethodizer.AddObject(System.Object)">
145+ <summary> Add an Object to methodize
146+ </summary>
147+ </member>
148+ <member name="M:NVelocity.App.FieldMethodizer.Get(System.String)">
149+ <summary>
150+ Accessor method to get the fields by name.
151+ </summary>
152+ <param name="fieldName">Name of static field to retrieve</param>
153+ <returns>The value of the given field.</returns>
154+ </member>
155+ <member name="M:NVelocity.App.FieldMethodizer.Inspect(System.Type)">
156+ <summary> Method that retrieves all public static fields
157+ in the class we are methodizing.
158+ </summary>
159+ </member>
160+ <member name="T:NVelocity.App.Tools.VelocityFormatter">
161+ <summary>
162+ Formatting tool for inserting into the Velocity WebContext. Can
163+ format dates or lists of objects.
164+
165+ <para>Here's an example of some uses:
166+ <code><pre>
167+ $formatter.formatShortDate($object.Date)
168+ $formatter.formatLongDate($db.getRecord(232).getDate())
169+ $formatter.formatArray($array)
170+ $formatter.limitLen(30, $object.Description)
171+ </pre></code>
172+ </para>
173+ </summary>
174+ <author><a href="mailto:sean@somacity.com">Sean Legassick</a></author>
175+ <author><a href="mailto:dlr@collab.net">Daniel Rall</a></author>
176+ <version>$Id: VelocityFormatter.cs,v 1.5 2003/11/05 04:15:02 corts Exp $</version>
177+ </member>
178+ <member name="M:NVelocity.App.Tools.VelocityFormatter.#ctor(NVelocity.Context.IContext)">
179+ <summary>
180+ Constructor needs a backPointer to the context.
181+ </summary>
182+ <param name="context">A Context.</param>
183+ </member>
184+ <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatShortDate(System.DateTime)">
185+ <summary>
186+ Formats a date in 'short' style.
187+ </summary>
188+ <param name="date">A Date.</param>
189+ <returns>A String.</returns>
190+ </member>
191+ <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatLongDate(System.DateTime)">
192+ <summary>
193+ Formats a date in 'long' style.
194+ </summary>
195+ <param name="date">A Date.</param>
196+ <returns>A String.</returns>
197+ </member>
198+ <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatShortDateTime(System.DateTime)">
199+ <summary>
200+ Formats a date/time in 'short' style.
201+ </summary>
202+ <param name="date">A Date.</param>
203+ <returns>A String.</returns>
204+ </member>
205+ <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatLongDateTime(System.DateTime)">
206+ <summary>
207+ Formats a date/time in 'long' style.
208+ </summary>
209+ <param name="date">A Date.</param>
210+ <returns>A String.</returns>
211+ </member>
212+ <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatArray(System.Object)">
213+ <summary>
214+ Formats an array into the form "A, B and C".
215+ </summary>
216+ <param name="array">An Object.</param>
217+ <returns>A String.</returns>
218+ </member>
219+ <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatArray(System.Object,System.String)">
220+ <summary>
221+ Formats an array into the form
222+ "A&lt;delim&gt;B&lt;delim&gt;C".
223+ </summary>
224+ <param name="array">An Object.</param>
225+ <param name="delim">A String.</param>
226+ <returns>A String.</returns>
227+ </member>
228+ <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatArray(System.Object,System.String,System.String)">
229+ <summary>
230+ Formats an array into the form
231+ "A&lt;delim&gt;B&lt;finalDelimiter&gt;C".
232+ </summary>
233+ <param name="array">An Object.</param>
234+ <param name="delim">A String.</param>
235+ <param name="finalDelimiter">A String.</param>
236+ <returns>A String.</returns>
237+ </member>
238+ <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatVector(System.Collections.IList)">
239+ <summary>
240+ Formats a list into the form "A, B and C".
241+ </summary>
242+ <param name="list">A list.</param>
243+ <returns>A String.</returns>
244+ </member>
245+ <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatVector(System.Collections.IList,System.String)">
246+ <summary>
247+ Formats a list into the form "A&lt;delim&gt;B&lt;delim&gt;C".
248+ </summary>
249+ <param name="list">A list.</param>
250+ <param name="delim">A String.</param>
251+ <returns>A String.</returns>
252+ </member>
253+ <member name="M:NVelocity.App.Tools.VelocityFormatter.FormatVector(System.Collections.IList,System.String,System.String)">
254+ <summary>
255+ Formats a list into the form
256+ "Adelim&gt;B&lt;finalDelimiter&gt;C".
257+ </summary>
258+ <param name="list">A list.</param>
259+ <param name="delim">A String.</param>
260+ <param name="finalDelimiter">A String.</param>
261+ <returns>A String.</returns>
262+ </member>
263+ <member name="M:NVelocity.App.Tools.VelocityFormatter.LimitLen(System.Int32,System.String)">
264+ <summary>
265+ Limits 'string' to 'maximumLength' characters. If the string gets
266+ curtailed, "..." is appended to it.
267+ </summary>
268+ <param name="maximumLength">An int with the maximum length.</param>
269+ <param name="value">A String.</param>
270+ <returns>A String.</returns>
271+ </member>
272+ <member name="M:NVelocity.App.Tools.VelocityFormatter.LimitLen(System.Int32,System.String,System.String)">
273+ <summary>
274+ Limits 'string' to 'maximumLength' character. If the string gets
275+ curtailed, 'suffix' is appended to it.
276+ </summary>
277+ <param name="maximumLength">An int with the maximum length.</param>
278+ <param name="value">A String.</param>
279+ <param name="suffix">A String.</param>
280+ <returns>A String.</returns>
281+ </member>
282+ <member name="M:NVelocity.App.Tools.VelocityFormatter.MakeAlternator(System.String,System.String,System.String)">
283+ <summary>
284+ Makes an alternator object that alternates between two values.
285+
286+ <para>Example usage in a Velocity template:
287+
288+ <code>
289+ &lt;table&gt;
290+ $formatter.makeAlternator("rowColor", "#c0c0c0", "#e0e0e0")
291+ #foreach $item in $items
292+ &lt;tr&gt;&lt;td bgcolor="$rowColor"&gt;$item.Name&lt;/td&gt;&lt;/tr&gt;
293+ $rowColor.alternate()
294+ #end
295+ &lt;/table&gt;
296+ </code>
297+ </para>
298+ </summary>
299+ <param name="name">The name for the alternator int the context.</param>
300+ <param name="alt1">The first alternate.</param>
301+ <param name="alt2">The second alternate.</param>
302+ <returns>The newly created instance.</returns>
303+ </member>
304+ <member name="M:NVelocity.App.Tools.VelocityFormatter.MakeAlternator(System.String,System.String,System.String,System.String)">
305+ <summary>
306+ Makes an alternator object that alternates between three values.
307+ </summary>
308+ </member>
309+ <member name="M:NVelocity.App.Tools.VelocityFormatter.MakeAlternator(System.String,System.String,System.String,System.String,System.String)">
310+ <summary>
311+ Makes an alternator object that alternates between four values.
312+ </summary>
313+ </member>
314+ <member name="M:NVelocity.App.Tools.VelocityFormatter.MakeAutoAlternator(System.String,System.String,System.String)">
315+ <summary>
316+ Makes an alternator object that alternates between two values
317+ automatically.
318+ </summary>
319+ </member>
320+ <member name="M:NVelocity.App.Tools.VelocityFormatter.IsNull(System.Object,System.Object)">
321+ <summary>
322+ Returns a default value if the object passed is null.
323+ </summary>
324+ </member>
325+ <member name="T:NVelocity.App.Tools.VelocityFormatter.VelocityAlternator">
326+ <summary>
327+ Class that returns alternating values in a template. It stores
328+ a list of alternate Strings, whenever alternate() is called it
329+ switches to the next in the list. The current alternate is
330+ retrieved through toString() - i.e. just by referencing the
331+ object in a Velocity template. For an example of usage see the
332+ makeAlternator() method below.
333+ </summary>
334+ </member>
335+ <member name="M:NVelocity.App.Tools.VelocityFormatter.VelocityAlternator.#ctor(System.String[])">
336+ <summary>
337+ Constructor takes an array of Strings.
338+ </summary>
339+ <param name="alternates">A String[].
340+ </param>
341+ </member>
342+ <member name="M:NVelocity.App.Tools.VelocityFormatter.VelocityAlternator.Alternate">
343+ <summary>
344+ Alternates to the next in the list.
345+ </summary>
346+ <returns>The current alternate in the sequence.</returns>
347+ </member>
348+ <member name="M:NVelocity.App.Tools.VelocityFormatter.VelocityAlternator.ToString">
349+ <summary>
350+ Returns the current alternate.
351+ </summary>
352+ <returns>A String.</returns>
353+ </member>
354+ <member name="T:NVelocity.App.Tools.VelocityFormatter.VelocityAutoAlternator">
355+ <summary>
356+ As VelocityAlternator, but calls <code>alternate()</code>
357+ automatically on rendering in a template.
358+ </summary>
359+ </member>
360+ <member name="M:NVelocity.App.Tools.VelocityFormatter.VelocityAutoAlternator.#ctor(System.String[])">
361+ <summary>
362+ Constructor takes an array of Strings.
363+ </summary>
364+ <param name="alternates">A String[].
365+
366+ </param>
367+ </member>
368+ <member name="M:NVelocity.App.Tools.VelocityFormatter.VelocityAutoAlternator.ToString">
369+ <summary>
370+ Returns the current alternate, and automatically alternates
371+ to the next alternate in its sequence (triggered upon
372+ rendering).
373+ </summary>
374+ <returns>The current alternate in the sequence.</returns>
375+ </member>
376+ <member name="T:NVelocity.App.Velocity">
377+ <summary>
378+ This class provides services to the application
379+ developer, such as :
380+ <ul>
381+ <li> Simple Velocity Runtime engine initialization methods.</li>
382+ <li> Functions to apply the template engine to streams and strings</li>
383+ to allow embedding and dynamic template generation.
384+ <li> Methods to access Velocimacros directly.</li>
385+ </ul>
386+ <br/><br/>
387+ While the most common way to use NVelocity is via templates, as
388+ Velocity is a general-purpose template engine, there are other
389+ uses that NVelocity is well suited for, such as processing dynamically
390+ created templates, or processing content streams.
391+ <br/><br/>
392+ The methods herein were developed to allow easy access to the NVelocity
393+ facilities without direct spelunking of the internals. If there is
394+ something you feel is necessary to add here, please, send a patch.
395+ </summary>
396+ </member>
397+ <member name="M:NVelocity.App.Velocity.Init">
398+ <summary>
399+ initialize the NVelocity runtime engine, using the default
400+ properties of the NVelocity distribution
401+ </summary>
402+ </member>
403+ <member name="M:NVelocity.App.Velocity.Init(System.String)">
404+ <summary>
405+ initialize the Velocity runtime engine, using default properties
406+ plus the properties in the properties file passed in as the arg
407+ </summary>
408+ <param name="propsFilename">
409+ file containing properties to use to initialize
410+ the Velocity runtime
411+ </param>
412+ </member>
413+ <member name="M:NVelocity.App.Velocity.Init(Commons.Collections.ExtendedProperties)">
414+ <summary>
415+ initialize the Velocity runtime engine, using default properties
416+ plus the properties in the passed in java.util.Properties object
417+ </summary>
418+ <param name="p">
419+ Proprties object containing initialization properties
420+ </param>
421+ </member>
422+ <member name="M:NVelocity.App.Velocity.SetProperty(System.String,System.Object)">
423+ <summary>
424+ Set a Velocity Runtime property.
425+ </summary>
426+ <param name="key">key</param>
427+ <param name="value">value</param>
428+ </member>
429+ <member name="M:NVelocity.App.Velocity.AddProperty(System.String,System.Object)">
430+ <summary>
431+ Add a Velocity Runtime property.
432+ </summary>
433+ <param name="key">key</param>
434+ <param name="value">value</param>
435+ </member>
436+ <member name="M:NVelocity.App.Velocity.ClearProperty(System.String)">
437+ <summary>
438+ Clear a NVelocity Runtime property.
439+ </summary>
440+ <param name="key">of property to clear</param>
441+ </member>
442+ <member name="M:NVelocity.App.Velocity.SetExtendedProperties(Commons.Collections.ExtendedProperties)">
443+ <summary>
444+ Set an entire configuration at once. This is
445+ useful in cases where the parent application uses
446+ the ExtendedProperties class and the velocity configuration
447+ is a subset of the parent application's configuration.
448+ </summary>
449+ </member>
450+ <member name="M:NVelocity.App.Velocity.GetProperty(System.String)">
451+ <summary>
452+ Get a Velocity Runtime property.
453+ </summary>
454+ <param name="key">property to retrieve</param>
455+ <returns>property value or null if the property not currently set</returns>
456+ </member>
457+ <member name="M:NVelocity.App.Velocity.Evaluate(NVelocity.Context.IContext,System.IO.TextWriter,System.String,System.String)">
458+ <summary>
459+ renders the input string using the context into the output writer.
460+ To be used when a template is dynamically constructed, or want to use
461+ Velocity as a token replacer.
462+ </summary>
463+ <param name="context">context to use in rendering input string</param>
464+ <param name="writer"> Writer in which to render the output</param>
465+ <param name="logTag"> string to be used as the template name for log messages in case of error</param>
466+ <param name="inString">input string containing the VTL to be rendered</param>
467+ <returns>true if successful, false otherwise. If false, see Velocity runtime log</returns>
468+ </member>
469+ <member name="M:NVelocity.App.Velocity.Evaluate(NVelocity.Context.IContext,System.IO.TextWriter,System.String,System.IO.Stream)">
470+ <summary>
471+ Renders the input stream using the context into the output writer.
472+ To be used when a template is dynamically constructed, or want to
473+ use Velocity as a token replacer.
474+ </summary>
475+ <param name="context">context to use in rendering input string</param>
476+ <param name="writer"> Writer in which to render the output</param>
477+ <param name="logTag"> string to be used as the template name for log messages in case of error</param>
478+ <param name="instream">input stream containing the VTL to be rendered</param>
479+ <returns>true if successful, false otherwise. If false, see Velocity runtime log</returns>
480+ </member>
481+ <member name="M:NVelocity.App.Velocity.Evaluate(NVelocity.Context.IContext,System.IO.TextWriter,System.String,System.IO.TextReader)">
482+ <summary>
483+ Renders the input reader using the context into the output writer.
484+ To be used when a template is dynamically constructed, or want to
485+ use Velocity as a token replacer.
486+ </summary>
487+ <param name="context">context to use in rendering input string</param>
488+ <param name="writer"> Writer in which to render the output</param>
489+ <param name="logTag"> string to be used as the template name for log messages in case of error</param>
490+ <param name="reader">Reader containing the VTL to be rendered</param>
491+ <returns>true if successful, false otherwise. If false, see Velocity runtime log</returns>
492+ </member>
493+ <member name="M:NVelocity.App.Velocity.InvokeVelocimacro(System.String,System.String,System.String[],NVelocity.Context.IContext,System.IO.TextWriter)">
494+ <summary>
495+ Invokes a currently registered Velocimacro with the parameters provided
496+ and places the rendered stream into the writer.
497+
498+ Note : currently only accepts args to the VM if they are in the context.
499+ </summary>
500+ <param name="vmName">name of Velocimacro to call</param>
501+ <param name="logTag">string to be used for template name in case of error</param>
502+ <param name="parameters">args used to invoke Velocimacro. In context key format :
503+ eg "foo","bar" (rather than "$foo","$bar")
504+ </param>
505+ <param name="context">Context object containing data/objects used for rendering.</param>
506+ <param name="writer"> Writer for output stream</param>
507+ <returns>true if Velocimacro exists and successfully invoked, false otherwise.</returns>
508+ </member>
509+ <member name="M:NVelocity.App.Velocity.MergeTemplate(System.String,NVelocity.Context.IContext,System.IO.TextWriter)">
510+ <summary>
511+ merges a template and puts the rendered stream into the writer
512+ </summary>
513+ <param name="templateName">name of template to be used in merge</param>
514+ <param name="context"> filled context to be used in merge</param>
515+ <param name="writer"> writer to write template into</param>
516+ <returns>true if successful, false otherwise. Errors logged to velocity log.</returns>
517+ </member>
518+ <member name="M:NVelocity.App.Velocity.MergeTemplate(System.String,System.String,NVelocity.Context.IContext,System.IO.TextWriter)">
519+ <summary>
520+ merges a template and puts the rendered stream into the writer
521+ </summary>
522+ <param name="templateName">name of template to be used in merge</param>
523+ <param name="encoding">encoding used in template</param>
524+ <param name="context"> filled context to be used in merge</param>
525+ <param name="writer"> writer to write template into</param>
526+ <returns>true if successful, false otherwise. Errors logged to velocity log</returns>
527+ </member>
528+ <member name="M:NVelocity.App.Velocity.GetTemplate(System.String)">
529+ <summary>
530+ Returns a <code>Template</code> from the Velocity
531+ resource management system.
532+ </summary>
533+ <param name="name">The file name of the desired template.
534+ </param>
535+ <returns> The template.
536+ @throws ResourceNotFoundException if template not found
537+ from any available source.
538+ @throws ParseErrorException if template cannot be parsed due
539+ to syntax (or other) error.
540+ @throws Exception if an error occurs in template initialization
541+ </returns>
542+ </member>
543+ <member name="M:NVelocity.App.Velocity.GetTemplate(System.String,System.String)">
544+ <summary>
545+ Returns a <code>Template</code> from the Velocity
546+ resource management system.
547+ </summary>
548+ <param name="name">The file name of the desired template.</param>
549+ <param name="encoding">The character encoding to use for the template.</param>
550+ <returns>The <see cref="T:NVelocity.Template"/> instance.</returns>
551+ <exception cref="T:NVelocity.Exception.ResourceNotFoundException">
552+ If template is not found from any available source.
553+ </exception>
554+ <exception cref="T:NVelocity.Exception.ParseErrorException">
555+ If template cannot be parsed due to syntax (or other) error.
556+ </exception>
557+ <exception cref="T:System.Exception">
558+ If an error occurs in template initialization.
559+ </exception>
560+ </member>
561+ <member name="M:NVelocity.App.Velocity.ResourceExists(System.String)">
562+ <summary>
563+ <p>Determines whether a resource is accessible via the
564+ currently configured resource loaders. <see cref="T:NVelocity.Runtime.Resource.Resource"/>
565+ is the generic description of templates, static content, etc.</p>
566+
567+ <p>Note that the current implementation will <b>not</b> change
568+ the state of the system in any real way - so this cannot be
569+ used to pre-load the resource cache, as the previous
570+ implementation did as a side-effect.</p>
571+ </summary>
572+ <param name="templateName"> name of the template to search for</param>
573+ <returns>Whether the resource was located.</returns>
574+ </member>
575+ <member name="M:NVelocity.App.Velocity.Warn(System.Object)">
576+ <summary>
577+ Log a warning message.
578+ </summary>
579+ <param name="message">message to log
580+ </param>
581+ </member>
582+ <member name="M:NVelocity.App.Velocity.Info(System.Object)">
583+ <summary>
584+ Log an info message.
585+ </summary>
586+ <param name="message">message to log</param>
587+ </member>
588+ <member name="M:NVelocity.App.Velocity.Error(System.Object)">
589+ <summary>
590+ Log an error message.
591+ </summary>
592+ <param name="message">message to log</param>
593+ </member>
594+ <member name="M:NVelocity.App.Velocity.Debug(System.Object)">
595+ <summary>
596+ Log a debug message.
597+ </summary>
598+ <param name="message">message to log</param>
599+ </member>
600+ <member name="M:NVelocity.App.Velocity.SetApplicationAttribute(System.Object,System.Object)">
601+ <summary>
602+ <p>
603+ Set the an ApplicationAttribute, which is an Object
604+ set by the application which is accessible from
605+ any component of the system that gets a RuntimeServices.
606+ This allows communication between the application
607+ environment and custom pluggable components of the
608+ Velocity engine, such as loaders and loggers.
609+ </p>
610+ <p>
611+ Note that there is no enforcement or rules for the key
612+ used - it is up to the application developer. However, to
613+ help make the intermixing of components possible, using
614+ the target Class name (e.g. com.foo.bar ) as the key
615+ might help avoid collision.
616+ </p>
617+ </summary>
618+ <param name="key">object 'name' under which the object is stored
619+ </param>
620+ <param name="value">object to store under this key
621+ </param>
622+ </member>
623+ <member name="M:NVelocity.App.Velocity.TemplateExists(System.String)">
624+ <summary>
625+ <see>#ResourceExists(String)</see>
626+ </summary>
627+ </member>
628+ <member name="T:NVelocity.App.VelocityEngine">
629+ <summary>
630+ This class provides a separate new-able instance of the
631+ Velocity template engine. The alternative model for use
632+ is using the Velocity class which employs the singleton
633+ model.
634+
635+ Please ensure that you call one of the init() variants.
636+ This is critical for proper behavior.
637+
638+ Coming soon : Velocity will call
639+ the parameter-less init() at the first use of this class
640+ if the init() wasn't explicitly called. While this will
641+ ensure that Velocity functions, it almost certainly won't
642+ function in the way you intend, so please make sure to
643+ call init().
644+ </summary>
645+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a></author>
646+ </member>
647+ <member name="M:NVelocity.App.VelocityEngine.#ctor">
648+ <summary>
649+ Init-less CTOR
650+ </summary>
651+ </member>
652+ <member name="M:NVelocity.App.VelocityEngine.#ctor(System.String)">
653+ <summary>
654+ CTOR that invokes an init(String), initializing
655+ the engine using the properties file specified
656+ </summary>
657+ <exception cref="T:System.Exception"></exception>
658+ <param name="propsFilename">name of properties file to init with</param>
659+ </member>
660+ <member name="M:NVelocity.App.VelocityEngine.#ctor(Commons.Collections.ExtendedProperties)">
661+ <summary>
662+ CTOR that invokes an init(String), initializing
663+ the engine using the Properties specified
664+ </summary>
665+ <param name="p">name of properties to init with</param>
666+ </member>
667+ <member name="M:NVelocity.App.VelocityEngine.SetExtendedProperties(Commons.Collections.ExtendedProperties)">
668+ <summary>
669+ Set an entire configuration at once. This is
670+ useful in cases where the parent application uses
671+ the ExtendedProperties class and the velocity configuration
672+ is a subset of the parent application's configuration.
673+ </summary>
674+ </member>
675+ <member name="M:NVelocity.App.VelocityEngine.Init">
676+ <summary>
677+ initialize the Velocity runtime engine, using the default
678+ properties of the Velocity distribution
679+ </summary>
680+ </member>
681+ <member name="M:NVelocity.App.VelocityEngine.Init(System.String)">
682+ <summary>
683+ initialize the Velocity runtime engine, using default properties
684+ plus the properties in the properties file passed in as the arg
685+ </summary>
686+ <param name="propsFilename">file containing properties to use to initialize
687+ the Velocity runtime</param>
688+ </member>
689+ <member name="M:NVelocity.App.VelocityEngine.Init(Commons.Collections.ExtendedProperties)">
690+ <summary>
691+ initialize the Velocity runtime engine, using default properties
692+ plus the properties in the passed in java.util.Properties object
693+ </summary>
694+ <param name="p"> Properties object containing initialization properties</param>
695+ </member>
696+ <member name="M:NVelocity.App.VelocityEngine.SetProperty(System.String,System.Object)">
697+ <summary>
698+ Set a Velocity Runtime property.
699+ </summary>
700+ </member>
701+ <member name="M:NVelocity.App.VelocityEngine.AddProperty(System.String,System.Object)">
702+ <summary>
703+ Add a Velocity Runtime property.
704+ </summary>
705+ </member>
706+ <member name="M:NVelocity.App.VelocityEngine.ClearProperty(System.String)">
707+ <summary>
708+ Clear a Velocity Runtime property.
709+ </summary>
710+ <param name="key">key of property to clear</param>
711+ </member>
712+ <member name="M:NVelocity.App.VelocityEngine.GetProperty(System.String)">
713+ <summary>
714+ Get a Velocity Runtime property.
715+ </summary>
716+ <param name="key">property to retrieve</param>
717+ <returns>
718+ property value or null if the property not currently set
719+ </returns>
720+ </member>
721+ <member name="M:NVelocity.App.VelocityEngine.Evaluate(NVelocity.Context.IContext,System.IO.TextWriter,System.String,System.String)">
722+ <summary>
723+ renders the input string using the context into the output writer.
724+ To be used when a template is dynamically constructed, or want to use
725+ Velocity as a token replacer.
726+ </summary>
727+ <param name="context">context to use in rendering input string</param>
728+ <param name="writer"> Writer in which to render the output</param>
729+ <param name="logTag"> string to be used as the template name for log messages in case of error</param>
730+ <param name="inString">input string containing the VTL to be rendered</param>
731+ <returns>true if successful, false otherwise. If false, see Velocity runtime log</returns>
732+ </member>
733+ <member name="M:NVelocity.App.VelocityEngine.Evaluate(NVelocity.Context.IContext,System.IO.TextWriter,System.String,System.IO.Stream)">
734+ <summary>
735+ Renders the input stream using the context into the output writer.
736+ To be used when a template is dynamically constructed, or want to
737+ use Velocity as a token replacer.
738+ </summary>
739+ <param name="context">context to use in rendering input string</param>
740+ <param name="writer"> Writer in which to render the output</param>
741+ <param name="logTag"> string to be used as the template name for log messages in case of error</param>
742+ <param name="instream">input stream containing the VTL to be rendered</param>
743+ <returns>true if successful, false otherwise. If false, see Velocity runtime log</returns>
744+ </member>
745+ <member name="M:NVelocity.App.VelocityEngine.Evaluate(NVelocity.Context.IContext,System.IO.TextWriter,System.String,System.IO.TextReader)">
746+ <summary>
747+ Renders the input reader using the context into the output writer.
748+ To be used when a template is dynamically constructed, or want to
749+ use Velocity as a token replacer.
750+ </summary>
751+ <param name="context">context to use in rendering input string</param>
752+ <param name="writer"> Writer in which to render the output</param>
753+ <param name="logTag"> string to be used as the template name for log messages in case of error</param>
754+ <param name="reader">Reader containing the VTL to be rendered</param>
755+ <returns>true if successful, false otherwise. If false, see Velocity runtime log</returns>
756+ </member>
757+ <member name="M:NVelocity.App.VelocityEngine.InvokeVelocimacro(System.String,System.String,System.String[],NVelocity.Context.IContext,System.IO.TextWriter)">
758+ <summary>
759+ Invokes a currently registered Velocimacro with the parameters provided
760+ and places the rendered stream into the writer.
761+ Note : currently only accepts args to the VM if they are in the context.
762+ </summary>
763+ <param name="vmName">name of Velocimacro to call</param>
764+ <param name="logTag">string to be used for template name in case of error</param>
765+ <param name="parameters">args used to invoke Velocimacro. In context key format :
766+ eg "foo","bar" (rather than "$foo","$bar")
767+ </param>
768+ <param name="context">Context object containing data/objects used for rendering.</param>
769+ <param name="writer"> Writer for output stream</param>
770+ <returns>true if Velocimacro exists and successfully invoked, false otherwise.</returns>
771+ </member>
772+ <member name="M:NVelocity.App.VelocityEngine.MergeTemplate(System.String,NVelocity.Context.IContext,System.IO.TextWriter)">
773+ <summary>
774+ merges a template and puts the rendered stream into the writer
775+ </summary>
776+ <param name="templateName">name of template to be used in merge</param>
777+ <param name="context"> filled context to be used in merge</param>
778+ <param name="writer"> writer to write template into</param>
779+ <returns>true if successful, false otherwise. Errors logged to velocity log.</returns>
780+ </member>
781+ <member name="M:NVelocity.App.VelocityEngine.MergeTemplate(System.String,System.String,NVelocity.Context.IContext,System.IO.TextWriter)">
782+ <summary>
783+ merges a template and puts the rendered stream into the writer
784+ </summary>
785+ <param name="templateName">name of template to be used in merge</param>
786+ <param name="encoding">encoding used in template</param>
787+ <param name="context"> filled context to be used in merge</param>
788+ <param name="writer"> writer to write template into</param>
789+ <returns>true if successful, false otherwise. Errors logged to velocity log</returns>
790+ </member>
791+ <member name="M:NVelocity.App.VelocityEngine.GetTemplate(System.String)">
792+ <summary>
793+ Returns a <code>Template</code> from the Velocity
794+ resource management system.
795+ </summary>
796+ <param name="name">The file name of the desired template.</param>
797+ <returns>The template.</returns>
798+ <exception cref="T:NVelocity.Exception.ResourceNotFoundException">
799+ if template not found from any available source.
800+ </exception>
801+ <exception cref="T:NVelocity.Exception.ParseErrorException">
802+ if template cannot be parsed due
803+ to syntax (or other) error.
804+ </exception>
805+ <exception cref="T:System.Exception">
806+ if an error occurs in template initialization
807+ </exception>
808+ </member>
809+ <member name="M:NVelocity.App.VelocityEngine.GetTemplate(System.String,System.String)">
810+ <summary>
811+ Returns a <code>Template</code> from the Velocity
812+ resource management system.
813+ </summary>
814+ <param name="name">The file name of the desired template.</param>
815+ <param name="encoding">The character encoding to use for the template.</param>
816+ <returns>The template.</returns>
817+ <exception cref="T:NVelocity.Exception.ResourceNotFoundException">
818+ if template not found from any available source.
819+ </exception>
820+ <exception cref="T:NVelocity.Exception.ParseErrorException">
821+ if template cannot be parsed due
822+ to syntax (or other) error.
823+ </exception>
824+ <exception cref="T:System.Exception">
825+ if an error occurs in template initialization
826+ </exception>
827+ </member>
828+ <member name="M:NVelocity.App.VelocityEngine.TemplateExists(System.String)">
829+ <summary>
830+ Determines if a template is accessible via the currently
831+ configured resource loaders.
832+ <br/><br/>
833+ Note that the current implementation will <b>not</b>
834+ change the state of the system in any real way - so this
835+ cannot be used to pre-load the resource cache, as the
836+ previous implementation did as a side-effect.
837+ <br/><br/>
838+ The previous implementation exhibited extreme laziness and
839+ sloth, and the author has been flogged.
840+ </summary>
841+ <param name="templateName"> name of the template to search for
842+ </param>
843+ <returns>true if found, false otherwise
844+ </returns>
845+ </member>
846+ <member name="M:NVelocity.App.VelocityEngine.Warn(System.Object)">
847+ <summary>
848+ Log a warning message.
849+ </summary>
850+ <param name="message">message to log</param>
851+ </member>
852+ <member name="M:NVelocity.App.VelocityEngine.Info(System.Object)">
853+
854+ <summary>
855+ Log an info message.
856+ </summary>
857+ <param name="message">message to log</param>
858+ </member>
859+ <member name="M:NVelocity.App.VelocityEngine.Error(System.Object)">
860+ <summary>
861+ Log an error message.
862+ </summary>
863+ <param name="message">message to log</param>
864+ </member>
865+ <member name="M:NVelocity.App.VelocityEngine.Debug(System.Object)">
866+ <summary>
867+ Log a debug message.
868+ </summary>
869+ <param name="message">message to log</param>
870+ </member>
871+ <member name="M:NVelocity.App.VelocityEngine.SetApplicationAttribute(System.Object,System.Object)">
872+ <summary>
873+ <p>
874+ Set the an ApplicationAttribute, which is an Object
875+ set by the application which is accessible from
876+ any component of the system that gets a RuntimeServices.
877+ This allows communication between the application
878+ environment and custom pluggable components of the
879+ Velocity engine, such as loaders and loggers.
880+ </p>
881+ <p>
882+ Note that there is no enforcement or rules for the key
883+ used - it is up to the application developer. However, to
884+ help make the intermixing of components possible, using
885+ the target Class name (e.g. com.foo.bar ) as the key
886+ might help avoid collision.
887+ </p>
888+ </summary>
889+ <param name="key">object 'name' under which the object is stored</param>
890+ <param name="value">object to store under this key</param>
891+ </member>
892+ <member name="T:Commons.Collections.CollectionsUtil">
893+ <summary>
894+ Static utility methods for collections
895+ </summary>
896+ </member>
897+ <member name="T:Commons.Collections.ExtendedProperties">
898+ <summary>
899+ This class extends normal Java properties by adding the possibility
900+ to use the same key many times concatenating the value strings
901+ instead of overwriting them.
902+
903+ <para>The Extended Properties syntax is explained here:
904+
905+ <ul>
906+ <li>
907+ Each property has the syntax <code>key = value</code>
908+ </li>
909+ <li>
910+ The <i>key</i> may use any character but the equal sign '='.
911+ </li>
912+ <li>
913+ <i>value</i> may be separated on different lines if a backslash
914+ is placed at the end of the line that continues below.
915+ </li>
916+ <li>
917+ If <i>value</i> is a list of strings, each token is separated
918+ by a comma ','.
919+ </li>
920+ <li>
921+ Commas in each token are escaped placing a backslash right before
922+ the comma.
923+ </li>
924+ <li>
925+ If a <i>key</i> is used more than once, the values are appended
926+ like if they were on the same line separated with commas.
927+ </li>
928+ <li>
929+ Blank lines and lines starting with character '#' are skipped.
930+ </li>
931+ <li>
932+ If a property is named "include" (or whatever is defined by
933+ setInclude() and getInclude() and the value of that property is
934+ the full path to a file on disk, that file will be included into
935+ the ConfigurationsRepository. You can also pull in files relative
936+ to the parent configuration file. So if you have something
937+ like the following:
938+
939+ include = additional.properties
940+
941+ Then "additional.properties" is expected to be in the same
942+ directory as the parent configuration file.
943+
944+ Duplicate name values will be replaced, so be careful.
945+
946+ </li>
947+ </ul>
948+ </para>
949+ <para>Here is an example of a valid extended properties file:
950+ </para>
951+ <para><pre>
952+ # lines starting with # are comments
953+
954+ # This is the simplest property
955+ key = value
956+
957+ # A long property may be separated on multiple lines
958+ longvalue = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \
959+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
960+
961+ # This is a property with many tokens
962+ tokens_on_a_line = first token, second token
963+
964+ # This sequence generates exactly the same result
965+ tokens_on_multiple_lines = first token
966+ tokens_on_multiple_lines = second token
967+
968+ # commas may be escaped in tokens
969+ commas.excaped = Hi\, what'up?
970+ </pre>
971+ </para>
972+ <para><b>NOTE</b>: this class has <b>not</b> been written for
973+ performance nor low memory usage. In fact, it's way slower than it
974+ could be and generates too much memory garbage. But since
975+ performance is not an issue during intialization (and there is not
976+ much time to improve it), I wrote it this way. If you don't like
977+ it, go ahead and tune it up!</para>
978+ </summary>
979+ </member>
980+ <member name="F:Commons.Collections.ExtendedProperties.defaults">
981+ <summary> Default configurations repository.
982+ </summary>
983+ </member>
984+ <member name="F:Commons.Collections.ExtendedProperties.file">
985+ <summary>
986+ The file connected to this repository (holding comments and such).
987+ </summary>
988+ </member>
989+ <member name="F:Commons.Collections.ExtendedProperties.basePath">
990+ <summary>
991+ Base path of the configuration file used to create
992+ this ExtendedProperties object.
993+ </summary>
994+ </member>
995+ <member name="F:Commons.Collections.ExtendedProperties.fileSeparator">
996+ <summary>
997+ File separator.
998+ </summary>
999+ </member>
1000+ <member name="F:Commons.Collections.ExtendedProperties.isInitialized">
1001+ <summary>
1002+ Has this configuration been initialized.
1003+ </summary>
1004+ </member>
1005+ <member name="F:Commons.Collections.ExtendedProperties.include">
1006+ <summary>
1007+ This is the name of the property that can point to other
1008+ properties file for including other properties files.
1009+ </summary>
1010+ </member>
1011+ <member name="F:Commons.Collections.ExtendedProperties.keysAsListed">
1012+ <summary>
1013+ These are the keys in the order they listed
1014+ in the configuration file. This is useful when
1015+ you wish to perform operations with configuration
1016+ information in a particular order.
1017+ </summary>
1018+ </member>
1019+ <member name="M:Commons.Collections.ExtendedProperties.#ctor">
1020+ <summary>
1021+ Creates an empty extended properties object.
1022+ </summary>
1023+ </member>
1024+ <member name="M:Commons.Collections.ExtendedProperties.#ctor(System.String)">
1025+ <summary>
1026+ Creates and loads the extended properties from the specified
1027+ file.
1028+ </summary>
1029+ <param name="file">A String.</param>
1030+ <exception cref="T:System.IO.IOException"/>
1031+ </member>
1032+ <member name="M:Commons.Collections.ExtendedProperties.#ctor(System.String,System.String)">
1033+ <summary>
1034+ Creates and loads the extended properties from the specified
1035+ file.
1036+ </summary>
1037+ <param name="file">A String.</param>
1038+ <param name="defaultFile">File to load defaults from.</param>
1039+ <exception cref="T:System.IO.IOException"/>
1040+ </member>
1041+ <member name="M:Commons.Collections.ExtendedProperties.IsInitialized">
1042+ <summary>
1043+ Indicate to client code whether property
1044+ resources have been initialized or not.
1045+ </summary>
1046+ </member>
1047+ <member name="M:Commons.Collections.ExtendedProperties.Load(System.IO.Stream,System.String)">
1048+ <summary>
1049+ Load the properties from the given input stream
1050+ and using the specified encoding.
1051+ </summary>
1052+ <param name="input">An InputStream.
1053+ </param>
1054+ <param name="encoding">An encoding.
1055+ </param>
1056+ <exception cref="T:System.IO.IOException"/>
1057+ </member>
1058+ <member name="M:Commons.Collections.ExtendedProperties.GetProperty(System.String)">
1059+ <summary> Gets a property from the configuration.
1060+ *
1061+ </summary>
1062+ <param name="key">property to retrieve
1063+ </param>
1064+ <returns>value as object. Will return user value if exists,
1065+ if not then default value if exists, otherwise null
1066+
1067+ </returns>
1068+ </member>
1069+ <member name="M:Commons.Collections.ExtendedProperties.AddProperty(System.String,System.Object)">
1070+ <summary> Add a property to the configuration. If it already
1071+ exists then the value stated here will be added
1072+ to the configuration entry. For example, if
1073+ *
1074+ resource.loader = file
1075+ *
1076+ is already present in the configuration and you
1077+ *
1078+ addProperty("resource.loader", "classpath")
1079+ *
1080+ Then you will end up with a Vector like the
1081+ following:
1082+ *
1083+ ["file", "classpath"]
1084+ *
1085+ </summary>
1086+ <param name="key"></param>
1087+ <param name="token"></param>
1088+ </member>
1089+ <member name="M:Commons.Collections.ExtendedProperties.AddPropertyDirect(System.String,System.Object)">
1090+ <summary> Adds a key/value pair to the map. This routine does
1091+ no magic morphing. It ensures the keyList is maintained
1092+ *
1093+ </summary>
1094+ <param name="key">key to use for mapping
1095+ </param>
1096+ <param name="obj">object to store
1097+
1098+ </param>
1099+ </member>
1100+ <member name="M:Commons.Collections.ExtendedProperties.AddStringProperty(System.String,System.String)">
1101+ <summary> Sets a string property w/o checking for commas - used
1102+ internally when a property has been broken up into
1103+ strings that could contain escaped commas to prevent
1104+ the inadvertent vectorization.
1105+
1106+ Thanks to Leon Messerschmidt for this one.
1107+
1108+ </summary>
1109+ </member>
1110+ <member name="M:Commons.Collections.ExtendedProperties.SetProperty(System.String,System.Object)">
1111+ <summary> Set a property, this will replace any previously
1112+ set values. Set values is implicitly a call
1113+ to clearProperty(key), addProperty(key,value).
1114+ </summary>
1115+ <param name="key"></param>
1116+ <param name="value"></param>
1117+ </member>
1118+ <member name="M:Commons.Collections.ExtendedProperties.Save(System.IO.TextWriter,System.String)">
1119+ <summary> Save the properties to the given outputStream.
1120+ </summary>
1121+ <param name="output">An OutputStream.
1122+ </param>
1123+ <param name="Header">A String.
1124+ </param>
1125+ <exception cref="T:System.IO.IOException">
1126+ </exception>
1127+ </member>
1128+ <member name="M:Commons.Collections.ExtendedProperties.Combine(Commons.Collections.ExtendedProperties)">
1129+ <summary> Combines an existing Hashtable with this Hashtable.
1130+ *
1131+ Warning: It will overwrite previous entries without warning.
1132+ *
1133+ </summary>
1134+ <param name="c">ExtendedProperties
1135+
1136+ </param>
1137+ </member>
1138+ <member name="M:Commons.Collections.ExtendedProperties.ClearProperty(System.String)">
1139+ <summary> Clear a property in the configuration.
1140+ *
1141+ </summary>
1142+ <param name="key">key to remove along with corresponding value.
1143+
1144+ </param>
1145+ </member>
1146+ <member name="M:Commons.Collections.ExtendedProperties.GetKeys(System.String)">
1147+ <summary> Get the list of the keys contained in the configuration
1148+ repository.
1149+ *
1150+ </summary>
1151+ <returns>An Iterator.
1152+
1153+ </returns>
1154+ <summary> Get the list of the keys contained in the configuration
1155+ repository that match the specified prefix.
1156+ *
1157+ </summary>
1158+ <param name="prefix">The prefix to test against.
1159+ </param>
1160+ <returns>An Iterator of keys that match the prefix.
1161+
1162+ </returns>
1163+ </member>
1164+ <member name="M:Commons.Collections.ExtendedProperties.Subset(System.String)">
1165+ <summary> Create an ExtendedProperties object that is a subset
1166+ of this one. Take into account duplicate keys
1167+ by using the setProperty() in ExtendedProperties.
1168+ *
1169+ </summary>
1170+ <param name="prefix">prefix
1171+
1172+ </param>
1173+ </member>
1174+ <member name="M:Commons.Collections.ExtendedProperties.ToString">
1175+ <summary> Display the configuration for debugging
1176+ purposes.
1177+ </summary>
1178+ </member>
1179+ <member name="M:Commons.Collections.ExtendedProperties.GetString(System.String)">
1180+ <summary> Get a string associated with the given configuration key.
1181+ *
1182+ </summary>
1183+ <param name="key">The configuration key.
1184+ </param>
1185+ <returns>The associated string.
1186+ </returns>
1187+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1188+ object that is not a String.
1189+
1190+ </exception>
1191+ </member>
1192+ <member name="M:Commons.Collections.ExtendedProperties.GetString(System.String,System.String)">
1193+ <summary> Get a string associated with the given configuration key.
1194+ *
1195+ </summary>
1196+ <param name="key">The configuration key.
1197+ </param>
1198+ <param name="defaultValue">The default value.
1199+ </param>
1200+ <returns>The associated string if key is found,
1201+ default value otherwise.
1202+ </returns>
1203+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1204+ object that is not a String.
1205+
1206+ </exception>
1207+ </member>
1208+ <member name="M:Commons.Collections.ExtendedProperties.GetProperties(System.String)">
1209+ <summary> Get a list of properties associated with the given
1210+ configuration key.
1211+ *
1212+ </summary>
1213+ <param name="key">The configuration key.
1214+ </param>
1215+ <returns>The associated properties if key is found.
1216+ </returns>
1217+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1218+ object that is not a String/Vector.
1219+ </exception>
1220+ <exception cref="T:System.ArgumentException"> if one of the tokens is
1221+ malformed (does not contain an equals sign).
1222+
1223+ </exception>
1224+ </member>
1225+ <member name="M:Commons.Collections.ExtendedProperties.GetProperties(System.String,System.Collections.Hashtable)">
1226+ <summary> Get a list of properties associated with the given
1227+ configuration key.
1228+ *
1229+ </summary>
1230+ <param name="key">The configuration key.
1231+ </param>
1232+ <param name="defaultProps">Default property values.
1233+ </param>
1234+ <returns>The associated properties if key is found.
1235+ </returns>
1236+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1237+ object that is not a String/Vector.
1238+ </exception>
1239+ <exception cref="T:System.ArgumentException"> if one of the tokens is
1240+ malformed (does not contain an equals sign).
1241+
1242+ </exception>
1243+ </member>
1244+ <member name="M:Commons.Collections.ExtendedProperties.GetStringArray(System.String)">
1245+ <summary> Get an array of strings associated with the given configuration
1246+ key.
1247+ *
1248+ </summary>
1249+ <param name="key">The configuration key.
1250+ </param>
1251+ <returns>The associated string array if key is found.
1252+ </returns>
1253+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1254+ object that is not a String/Vector.
1255+
1256+ </exception>
1257+ </member>
1258+ <member name="M:Commons.Collections.ExtendedProperties.GetVector(System.String)">
1259+ <summary> Get a Vector of strings associated with the given configuration
1260+ key.
1261+ *
1262+ </summary>
1263+ <param name="key">The configuration key.
1264+ </param>
1265+ <returns>The associated Vector.
1266+ </returns>
1267+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1268+ object that is not a Vector.
1269+
1270+ </exception>
1271+ </member>
1272+ <member name="M:Commons.Collections.ExtendedProperties.GetStringList(System.String)">
1273+ <summary>
1274+ Gets the string list.
1275+ </summary>
1276+ <param name="key">The key.</param>
1277+ <returns></returns>
1278+ </member>
1279+ <member name="M:Commons.Collections.ExtendedProperties.GetVector(System.String,System.Collections.ArrayList)">
1280+ <summary> Get a Vector of strings associated with the given configuration
1281+ key.
1282+ *
1283+ </summary>
1284+ <param name="key">The configuration key.
1285+ </param>
1286+ <param name="defaultValue">The default value.
1287+ </param>
1288+ <returns>The associated Vector.
1289+ </returns>
1290+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1291+ object that is not a Vector.
1292+
1293+ </exception>
1294+ </member>
1295+ <member name="M:Commons.Collections.ExtendedProperties.GetBoolean(System.String)">
1296+ <summary> Get a boolean associated with the given configuration key.
1297+ *
1298+ </summary>
1299+ <param name="key">The configuration key.
1300+ </param>
1301+ <returns>The associated boolean.
1302+ </returns>
1303+ <exception cref="T:System.Exception"> is thrown if the key doesn't
1304+ map to an existing object.
1305+ </exception>
1306+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1307+ object that is not a Boolean.
1308+
1309+ </exception>
1310+ </member>
1311+ <member name="M:Commons.Collections.ExtendedProperties.GetBoolean(System.String,System.Boolean)">
1312+ <summary> Get a boolean associated with the given configuration key.
1313+ *
1314+ </summary>
1315+ <param name="key">The configuration key.
1316+ </param>
1317+ <param name="defaultValue">The default value.
1318+ </param>
1319+ <returns>The associated boolean if key is found and has valid
1320+ format, default value otherwise.
1321+ </returns>
1322+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1323+ object that is not a Boolean.
1324+
1325+ </exception>
1326+ </member>
1327+ <member name="M:Commons.Collections.ExtendedProperties.TestBoolean(System.String)">
1328+ <summary> Test whether the string represent by value maps to a boolean
1329+ value or not. We will allow <code>true</code>, <code>on</code>,
1330+ and <code>yes</code> for a <code>true</code> boolean value, and
1331+ <code>false</code>, <code>off</code>, and <code>no</code> for
1332+ <code>false</code> boolean values. Case of value to test for
1333+ boolean status is ignored.
1334+ *
1335+ </summary>
1336+ <param name="value">The value to test for boolean state.
1337+ </param>
1338+ <returns><code>true</code> or <code>false</code> if the supplied
1339+ text maps to a boolean value, or <code>null</code> otherwise.
1340+
1341+ </returns>
1342+ </member>
1343+ <member name="M:Commons.Collections.ExtendedProperties.GetByte(System.String)">
1344+ <summary> Get a byte associated with the given configuration key.
1345+ *
1346+ </summary>
1347+ <param name="key">The configuration key.
1348+ </param>
1349+ <returns>The associated byte if key is found and has valid
1350+ format, <see cref="F:Commons.Collections.ExtendedProperties.DEFAULT_BYTE"/> otherwise.
1351+ </returns>
1352+ <exception cref="T:System.Exception"> is thrown if the key doesn't
1353+ map to an existing object.
1354+ </exception>
1355+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1356+ object that is not a Byte.
1357+ </exception>
1358+ </member>
1359+ <member name="M:Commons.Collections.ExtendedProperties.GetByte(System.String,System.SByte)">
1360+ <summary> Get a byte associated with the given configuration key.
1361+ *
1362+ </summary>
1363+ <param name="key">The configuration key.
1364+ </param>
1365+ <param name="defaultValue">The default value.
1366+ </param>
1367+ <returns>The associated byte if key is found and has valid
1368+ format, default value otherwise.
1369+ </returns>
1370+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1371+ object that is not a Byte.
1372+ </exception>
1373+ </member>
1374+ <member name="M:Commons.Collections.ExtendedProperties.GetByte(System.String,System.Byte)">
1375+ <summary> Get a byte associated with the given configuration key.
1376+ *
1377+ </summary>
1378+ <param name="key">The configuration key.
1379+ </param>
1380+ <param name="defaultValue">The default value.
1381+ </param>
1382+ <returns>The associated byte if key is found and has valid
1383+ format, default value otherwise.
1384+ </returns>
1385+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1386+ object that is not a Byte.
1387+ </exception>
1388+ </member>
1389+ <member name="M:Commons.Collections.ExtendedProperties.GetInt(System.String)">
1390+ <summary> The purpose of this method is to get the configuration resource
1391+ with the given name as an integer.
1392+ *
1393+ </summary>
1394+ <param name="name">The resource name.
1395+ </param>
1396+ <returns>The value of the resource as an integer.
1397+
1398+ </returns>
1399+ </member>
1400+ <member name="M:Commons.Collections.ExtendedProperties.GetInt(System.String,System.Int32)">
1401+ <summary> The purpose of this method is to get the configuration resource
1402+ with the given name as an integer, or a default value.
1403+ *
1404+ </summary>
1405+ <param name="name">The resource name
1406+ </param>
1407+ <param name="def">The default value of the resource.
1408+ </param>
1409+ <returns>The value of the resource as an integer.
1410+
1411+ </returns>
1412+ </member>
1413+ <member name="M:Commons.Collections.ExtendedProperties.GetInteger(System.String)">
1414+ <summary> Get a int associated with the given configuration key.
1415+ *
1416+ </summary>
1417+ <param name="key">The configuration key.
1418+ </param>
1419+ <returns>The associated int if key is found and has valid
1420+ format, <see cref="F:Commons.Collections.ExtendedProperties.DEFAULT_INT32"/> otherwise.
1421+ </returns>
1422+ <exception cref="T:System.Exception"> is thrown if the key doesn't
1423+ map to an existing object.
1424+ </exception>
1425+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1426+ object that is not a Integer.
1427+ </exception>
1428+ </member>
1429+ <member name="M:Commons.Collections.ExtendedProperties.GetInteger(System.String,System.Int32)">
1430+ <summary> Get a int associated with the given configuration key.
1431+ *
1432+ </summary>
1433+ <param name="key">The configuration key.
1434+ </param>
1435+ <param name="defaultValue">The default value.
1436+ </param>
1437+ <returns>The associated int if key is found and has valid
1438+ format, <see cref="F:Commons.Collections.ExtendedProperties.DEFAULT_INT32"/> otherwise.
1439+ </returns>
1440+ <returns>The associated int if key is found and has valid
1441+ format, default value otherwise.
1442+ </returns>
1443+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1444+ object that is not a Integer.
1445+ </exception>
1446+ </member>
1447+ <member name="M:Commons.Collections.ExtendedProperties.GetLong(System.String)">
1448+ <summary> Get a long associated with the given configuration key.
1449+ *
1450+ </summary>
1451+ <param name="key">The configuration key.
1452+ </param>
1453+ <returns>The associated long if key is found and has valid
1454+ format, <see cref="F:Commons.Collections.ExtendedProperties.DEFAULT_INT64"/> otherwise.
1455+ </returns>
1456+ <exception cref="T:System.Exception"> is thrown if the key doesn't
1457+ map to an existing object.
1458+ </exception>
1459+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1460+ object that is not a Long.
1461+ </exception>
1462+ </member>
1463+ <member name="M:Commons.Collections.ExtendedProperties.GetLong(System.String,System.Int64)">
1464+ <summary> Get a long associated with the given configuration key.
1465+ *
1466+ </summary>
1467+ <param name="key">The configuration key.
1468+ </param>
1469+ <param name="defaultValue">The default value.
1470+ </param>
1471+ <returns>The associated long if key is found and has valid
1472+ format, <see cref="F:Commons.Collections.ExtendedProperties.DEFAULT_INT64"/> otherwise.
1473+ </returns>
1474+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1475+ object that is not a Long.
1476+ </exception>
1477+ </member>
1478+ <member name="M:Commons.Collections.ExtendedProperties.GetFloat(System.String)">
1479+ <summary> Get a float associated with the given configuration key.
1480+ *
1481+ </summary>
1482+ <param name="key">The configuration key.
1483+ </param>
1484+ <returns>The associated float if key is found and has valid
1485+ format, <see cref="F:Commons.Collections.ExtendedProperties.DEFAULT_SINGLE"/> otherwise.
1486+ </returns>
1487+ <exception cref="T:System.Exception"> is thrown if the key doesn't
1488+ map to an existing object.
1489+ </exception>
1490+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1491+ object that is not a Float.
1492+ </exception>
1493+ </member>
1494+ <member name="M:Commons.Collections.ExtendedProperties.GetFloat(System.String,System.Single)">
1495+ <summary> Get a float associated with the given configuration key.
1496+ *
1497+ </summary>
1498+ <param name="key">The configuration key.
1499+ </param>
1500+ <param name="defaultValue">The default value.
1501+ </param>
1502+ <returns>The associated float if key is found and has valid
1503+ format, <see cref="F:Commons.Collections.ExtendedProperties.DEFAULT_SINGLE"/> otherwise.
1504+ </returns>
1505+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1506+ object that is not a Float.
1507+ </exception>
1508+ </member>
1509+ <member name="M:Commons.Collections.ExtendedProperties.GetDouble(System.String)">
1510+ <summary> Get a double associated with the given configuration key.
1511+ *
1512+ </summary>
1513+ <param name="key">The configuration key.
1514+ </param>
1515+ <returns>The associated double if key is found and has valid
1516+ format, <see cref="F:Commons.Collections.ExtendedProperties.DEFAULT_DOUBLE"/> otherwise.
1517+ </returns>
1518+ <exception cref="T:System.Exception"> is thrown if the key doesn't
1519+ map to an existing object.
1520+ </exception>
1521+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1522+ object that is not a Double.
1523+ </exception>
1524+ </member>
1525+ <member name="M:Commons.Collections.ExtendedProperties.GetDouble(System.String,System.Double)">
1526+ <summary> Get a double associated with the given configuration key.
1527+ *
1528+ </summary>
1529+ <param name="key">The configuration key.
1530+ </param>
1531+ <param name="defaultValue">The default value.
1532+ </param>
1533+ <returns>The associated double if key is found and has valid
1534+ format, <see cref="F:Commons.Collections.ExtendedProperties.DEFAULT_DOUBLE"/> otherwise.
1535+ </returns>
1536+ <exception cref="T:System.InvalidCastException"> is thrown if the key maps to an
1537+ object that is not a Double.
1538+ </exception>
1539+ </member>
1540+ <member name="M:Commons.Collections.ExtendedProperties.ConvertProperties(Commons.Collections.ExtendedProperties)">
1541+ <summary>
1542+ Convert a standard properties class into a configuration class.
1543+ </summary>
1544+ <param name="p">properties object to convert into a ExtendedProperties object.</param>
1545+ <returns>ExtendedProperties configuration created from the properties object.</returns>
1546+ </member>
1547+ <member name="T:Commons.Collections.LRUMap">
1548+ <summary>
1549+ A keyed list with a fixed maximum size which removes
1550+ the least recently used entry if an entry is added when full.
1551+ </summary>
1552+ </member>
1553+ <member name="F:Commons.Collections.LRUMap.DEFAULT_MAX_SIZE">
1554+ <summary>
1555+ Default maximum size
1556+ </summary>
1557+ </member>
1558+ <member name="F:Commons.Collections.LRUMap.maxSize">
1559+ <summary>
1560+ Maximum size
1561+ </summary>
1562+ </member>
1563+ <member name="M:Commons.Collections.LRUMap.RemoveLRU">
1564+ <summary>
1565+ Remove the least recently used entry (the last one in the list)
1566+ </summary>
1567+ </member>
1568+ <member name="P:Commons.Collections.LRUMap.MaxSize">
1569+ <summary>
1570+ Gets the maximum size of the map (the bound).
1571+ </summary>
1572+ </member>
1573+ <member name="T:Commons.Collections.PropertiesReader">
1574+ <summary>
1575+ This class is used to read properties lines. These lines do
1576+ not terminate with new-line chars but rather when there is no
1577+ backslash sign a the end of the line. This is used to
1578+ concatenate multiple lines for readability.
1579+ </summary>
1580+ </member>
1581+ <member name="M:Commons.Collections.PropertiesReader.#ctor(System.IO.StreamReader)">
1582+ <summary>
1583+ Constructor.
1584+ </summary>
1585+ <param name="reader">A Reader.</param>
1586+ </member>
1587+ <member name="M:Commons.Collections.PropertiesReader.ReadProperty">
1588+ <summary>
1589+ Read a property.
1590+ </summary>
1591+ <returns>A String.</returns>
1592+ </member>
1593+ <member name="T:Commons.Collections.PropertiesTokenizer">
1594+ <summary>
1595+ This class divides into tokens a property value. Token
1596+ separator is "," but commas into the property value are escaped
1597+ using the backslash in front.
1598+ </summary>
1599+ </member>
1600+ <member name="F:Commons.Collections.PropertiesTokenizer.DELIMITER">
1601+ <summary>
1602+ The property delimiter used while parsing (a comma).
1603+ </summary>
1604+ </member>
1605+ <member name="M:Commons.Collections.PropertiesTokenizer.#ctor(System.String)">
1606+ <summary>
1607+ Constructor.
1608+ </summary>
1609+ <param name="str">A String</param>
1610+ </member>
1611+ <member name="M:Commons.Collections.PropertiesTokenizer.NextToken">
1612+ <summary>
1613+ Get next token.
1614+ </summary>
1615+ <returns>A String</returns>
1616+ </member>
1617+ <member name="T:NVelocity.Context.AbstractContext">
1618+ <summary> This class is the abstract base class for all conventional
1619+ Velocity Context implementations. Simply extend this class
1620+ and implement the abstract routines that access your preferred
1621+ storage method.
1622+ *
1623+ Takes care of context chaining.
1624+ *
1625+ Also handles / enforces policy on null keys and values :
1626+ *
1627+ <ul>
1628+ <li> Null keys and values are accepted and basically dropped.</li>
1629+ <li> If you place an object into the context with a null key, it
1630+ will be ignored and logged.</li>
1631+ <li> If you try to place a null into the context with any key, it
1632+ will be dropped and logged.</li>
1633+ </ul>
1634+ *
1635+ The default implementation of this for application use is
1636+ org.apache.velocity.VelocityContext.
1637+ *
1638+ All thanks to Fedor for the chaining idea.
1639+ *
1640+ </summary>
1641+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
1642+ </author>
1643+ <author> <a href="mailto:fedor.karpelevitch@home.com">Fedor Karpelevitch</a>
1644+ </author>
1645+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
1646+ </author>
1647+ <version> $Id: AbstractContext.cs,v 1.4 2003/10/27 13:54:08 corts Exp $
1648+
1649+ </version>
1650+ </member>
1651+ <member name="T:NVelocity.Context.InternalContextBase">
1652+ <summary> class to encapsulate the 'stuff' for internal operation of velocity.
1653+ We use the context as a thread-safe storage : we take advantage of the
1654+ fact that it's a visitor of sorts to all nodes (that matter) of the
1655+ AST during init() and render().
1656+ Currently, it carries the template name for namespace
1657+ support, as well as node-local context data introspection caching.
1658+ *
1659+ Note that this is not a public class. It is for package access only to
1660+ keep application code from accessing the internals, as AbstractContext
1661+ is derived from this.
1662+ *
1663+ </summary>
1664+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
1665+ </author>
1666+ <version> $Id: InternalContextBase.cs,v 1.4 2003/10/27 13:54:08 corts Exp $
1667+
1668+ </version>
1669+ </member>
1670+ <member name="T:NVelocity.Context.IInternalHousekeepingContext">
1671+ <summary>
1672+ interface to encapsulate the 'stuff' for internal operation of velocity.
1673+ We use the context as a thread-safe storage : we take advantage of the
1674+ fact that it's a visitor of sorts to all nodes (that matter) of the
1675+ AST during init() and render().
1676+
1677+ Currently, it carries the template name for namespace
1678+ support, as well as node-local context data introspection caching.
1679+ </summary>
1680+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a></author>
1681+ <author> <a href="mailto:Christoph.Reck@dlr.de">Christoph Reck</a></author>
1682+ <version> $Id: InternalHousekeepingContext.cs,v 1.4 2003/10/27 13:54:08 corts Exp $</version>
1683+ </member>
1684+ <member name="M:NVelocity.Context.IInternalHousekeepingContext.PushCurrentTemplateName(System.String)">
1685+ <summary>
1686+ set the current template name on top of stack
1687+ </summary>
1688+ <param name="s">current template name</param>
1689+ </member>
1690+ <member name="M:NVelocity.Context.IInternalHousekeepingContext.PopCurrentTemplateName">
1691+ <summary>
1692+ remove the current template name from stack
1693+ </summary>
1694+ </member>
1695+ <member name="M:NVelocity.Context.IInternalHousekeepingContext.ICacheGet(System.Object)">
1696+ <summary>
1697+ Gets the <see cref="T:NVelocity.Util.Introspection.IntrospectionCacheData"/> object if exists
1698+ for the key
1699+ </summary>
1700+ <param name="key">key to find in cache</param>
1701+ <returns>cache object</returns>
1702+ </member>
1703+ <member name="M:NVelocity.Context.IInternalHousekeepingContext.ICachePut(System.Object,NVelocity.Util.Introspection.IntrospectionCacheData)">
1704+ <summary>
1705+ Sets the <see cref="T:NVelocity.Util.Introspection.IntrospectionCacheData"/> object
1706+ for the key
1707+ </summary>
1708+ <param name="key"> key </param>
1709+ <param name="o"> IntrospectionCacheData object to place in cache</param>
1710+ </member>
1711+ <member name="P:NVelocity.Context.IInternalHousekeepingContext.CurrentTemplateName">
1712+ <summary>
1713+ get the current template name
1714+ </summary>
1715+ <returns>String current template name</returns>
1716+ </member>
1717+ <member name="P:NVelocity.Context.IInternalHousekeepingContext.TemplateNameStack">
1718+ <summary>
1719+ Returns the template name stack in form of an array.
1720+ </summary>
1721+ <returns>Object[] with the template name stack contents.</returns>
1722+ </member>
1723+ <member name="P:NVelocity.Context.IInternalHousekeepingContext.CurrentResource">
1724+ <summary>
1725+ temporary fix to enable #include() to figure out
1726+ current encoding.
1727+ </summary>
1728+ </member>
1729+ <member name="T:NVelocity.Context.IInternalEventContext">
1730+ <summary>
1731+ Interface for event support. Note that this is a public internal
1732+ interface, as it is something that will be accessed from outside
1733+ of the .context package.
1734+ </summary>
1735+ </member>
1736+ <member name="F:NVelocity.Context.InternalContextBase.introspectionCache">
1737+ <summary>
1738+ cache for node/context specific introspection information
1739+ </summary>
1740+ </member>
1741+ <member name="F:NVelocity.Context.InternalContextBase.templateNameStack">
1742+ <summary>
1743+ Template name stack. The stack top contains the current template name.
1744+ </summary>
1745+ </member>
1746+ <member name="F:NVelocity.Context.InternalContextBase.eventCartridge">
1747+ <summary>
1748+ EventCartridge we are to carry. Set by application
1749+ </summary>
1750+ </member>
1751+ <member name="F:NVelocity.Context.InternalContextBase.currentResource">
1752+ <summary>
1753+ Current resource - used for carrying encoding and other
1754+ information down into the rendering process
1755+ </summary>
1756+ </member>
1757+ <member name="M:NVelocity.Context.InternalContextBase.PushCurrentTemplateName(System.String)">
1758+ <summary>
1759+ set the current template name on top of stack
1760+ </summary>
1761+ <param name="s">current template name</param>
1762+ </member>
1763+ <member name="M:NVelocity.Context.InternalContextBase.PopCurrentTemplateName">
1764+ <summary>remove the current template name from stack</summary>
1765+ </member>
1766+ <member name="T:NVelocity.Context.IContext">
1767+ <summary>
1768+ Interface describing the application data context. This set of
1769+ routines is used by the application to set and remove 'named' data
1770+ object to pass them to the template engine to use when rendering
1771+ a template.
1772+
1773+ This is the same set of methods supported by the original Context
1774+ class
1775+ </summary>
1776+ <seealso cref="T:NVelocity.Context.AbstractContext"/>
1777+ <seealso cref="T:NVelocity.VelocityContext"/>
1778+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a></author>
1779+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a></author>
1780+ </member>
1781+ <member name="M:NVelocity.Context.IContext.Put(System.String,System.Object)">
1782+ <summary>
1783+ Adds a name/value pair to the context.
1784+ </summary>
1785+ <param name="key">The name to key the provided value with.</param>
1786+ <param name="value">The corresponding value.</param>
1787+ </member>
1788+ <member name="M:NVelocity.Context.IContext.Get(System.String)">
1789+ <summary>
1790+ Gets the value corresponding to the provided key from the context.
1791+ </summary>
1792+ <param name="key">The name of the desired value.</param>
1793+ <returns>The value corresponding to the provided key.</returns>
1794+ </member>
1795+ <member name="M:NVelocity.Context.IContext.ContainsKey(System.Object)">
1796+ <summary>
1797+ Indicates whether the specified key is in the context.
1798+ </summary>
1799+ <param name="key">The key to look for.</param>
1800+ <returns>Whether the key is in the context.</returns>
1801+ </member>
1802+ <member name="M:NVelocity.Context.IContext.Remove(System.Object)">
1803+ <summary>
1804+ Removes the value associated with the specified key from the context.
1805+ </summary>
1806+ <param name="key">The name of the value to remove.</param>
1807+ <returns>The value that the key was mapped to, or <code>null</code> if unmapped.</returns>
1808+ </member>
1809+ <member name="P:NVelocity.Context.IContext.Count">
1810+ <summary>
1811+ Returns the number of elements in this context
1812+ </summary>
1813+ <value>The count.</value>
1814+ </member>
1815+ <member name="P:NVelocity.Context.IContext.Keys">
1816+ <summary>
1817+ Get all the keys for the values in the context
1818+ </summary>
1819+ </member>
1820+ <member name="F:NVelocity.Context.AbstractContext.innerContext">
1821+ <summary> the chained Context if any
1822+ </summary>
1823+ </member>
1824+ <member name="M:NVelocity.Context.AbstractContext.#ctor">
1825+ <summary> default CTOR
1826+ </summary>
1827+ </member>
1828+ <member name="M:NVelocity.Context.AbstractContext.#ctor(NVelocity.Context.IContext)">
1829+ <summary> Chaining constructor accepts a Context argument.
1830+ It will relay get() operations into this Context
1831+ in the even the 'local' get() returns null.
1832+
1833+ </summary>
1834+ <param name="inner">context to be chained
1835+
1836+ </param>
1837+ </member>
1838+ <member name="M:NVelocity.Context.AbstractContext.InternalGet(System.String)">
1839+
1840+ <summary> Implement to return a value from the context storage.
1841+ <br/><br/>
1842+ The implementation of this method is required for proper
1843+ operation of a Context implementation in general
1844+ Velocity use.
1845+
1846+ </summary>
1847+ <param name="key">key whose associated value is to be returned
1848+ </param>
1849+ <returns>object stored in the context
1850+
1851+ </returns>
1852+ </member>
1853+ <member name="M:NVelocity.Context.AbstractContext.InternalPut(System.String,System.Object)">
1854+
1855+ <summary> Implement to put a value into the context storage.
1856+ <br/><br/>
1857+ The implementation of this method is required for
1858+ proper operation of a Context implementation in
1859+ general Velocity use.
1860+ *
1861+ </summary>
1862+ <param name="key">key with which to associate the value
1863+ </param>
1864+ <param name="value">value to be associated with the key
1865+ </param>
1866+ <returns>previously stored value if exists, or null
1867+
1868+ </returns>
1869+ </member>
1870+ <member name="M:NVelocity.Context.AbstractContext.InternalContainsKey(System.Object)">
1871+
1872+ <summary> Implement to determine if a key is in the storage.
1873+ <br/><br/>
1874+ Currently, this method is not used internally by
1875+ the Velocity core.
1876+ *
1877+ </summary>
1878+ <param name="key">key to test for existance
1879+ </param>
1880+ <returns>true if found, false if not
1881+
1882+ </returns>
1883+ </member>
1884+ <member name="M:NVelocity.Context.AbstractContext.InternalGetKeys">
1885+
1886+ <summary> Implement to return an object array of key
1887+ strings from your storage.
1888+ <br/><br/>
1889+ Currently, this method is not used internally by
1890+ the Velocity core.
1891+ *
1892+ </summary>
1893+ <returns>array of keys
1894+
1895+ </returns>
1896+ </member>
1897+ <member name="M:NVelocity.Context.AbstractContext.InternalRemove(System.Object)">
1898+
1899+ <summary> Implement to remove an item from your storage.
1900+ <br/><br/>
1901+ Currently, this method is not used internally by
1902+ the Velocity core.
1903+ *
1904+ </summary>
1905+ <param name="key">key to remove
1906+ </param>
1907+ <returns>object removed if exists, else null
1908+
1909+ </returns>
1910+ </member>
1911+ <member name="M:NVelocity.Context.AbstractContext.Put(System.String,System.Object)">
1912+ <summary> Adds a name/value pair to the context.
1913+
1914+ </summary>
1915+ <param name="key"> The name to key the provided value with.
1916+ </param>
1917+ <param name="value">The corresponding value.
1918+ </param>
1919+ <returns>Object that was replaced in the the Context if
1920+ applicable or null if not.
1921+
1922+ </returns>
1923+ </member>
1924+ <member name="M:NVelocity.Context.AbstractContext.Get(System.String)">
1925+ <summary> Gets the value corresponding to the provided key from the context.
1926+ *
1927+ Supports the chaining context mechanism. If the 'local' context
1928+ doesn't have the value, we try to get it from the chained context.
1929+ *
1930+ </summary>
1931+ <param name="key">The name of the desired value.
1932+ </param>
1933+ <returns> The value corresponding to the provided key or null if
1934+ the key param is null.
1935+
1936+ </returns>
1937+ </member>
1938+ <member name="M:NVelocity.Context.AbstractContext.ContainsKey(System.Object)">
1939+ <summary> Indicates whether the specified key is in the context. Provided for
1940+ debugging purposes.
1941+ *
1942+ </summary>
1943+ <param name="key">The key to look for.
1944+ </param>
1945+ <returns>true if the key is in the context, false if not.
1946+
1947+ </returns>
1948+ </member>
1949+ <member name="M:NVelocity.Context.AbstractContext.Remove(System.Object)">
1950+ <summary> Get all the keys for the values in the context
1951+ </summary>
1952+ <returns>Object[] of keys in the Context. Does not return
1953+ keys in chained context.
1954+
1955+ </returns>
1956+ <summary> Removes the value associated with the specified key from the context.
1957+ *
1958+ </summary>
1959+ <param name="key">The name of the value to remove.
1960+ </param>
1961+ <returns> The value that the key was mapped to, or <code>null</code>
1962+ if unmapped.
1963+
1964+ </returns>
1965+ </member>
1966+ <member name="T:NVelocity.Context.IInternalContextAdapter">
1967+ <summary> interface to bring all necessary internal and user contexts together.
1968+ this is what the AST expects to deal with. If anything new comes
1969+ along, add it here.
1970+ *
1971+ I will rename soon :)
1972+ *
1973+ </summary>
1974+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
1975+ </author>
1976+ <version> $Id: InternalContextAdapter.cs,v 1.3 2003/10/27 13:54:08 corts Exp $
1977+
1978+ </version>
1979+ </member>
1980+ <member name="T:NVelocity.Context.IInternalWrapperContext">
1981+ <summary>
1982+ interface for internal context wrapping functionality
1983+ </summary>
1984+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a></author>
1985+ <version> $Id: InternalWrapperContext.cs,v 1.4 2003/10/27 13:54:08 corts Exp $ </version>
1986+ </member>
1987+ <member name="P:NVelocity.Context.IInternalWrapperContext.InternalUserContext">
1988+ <summary>
1989+ returns the wrapped user context
1990+ </summary>
1991+ </member>
1992+ <member name="P:NVelocity.Context.IInternalWrapperContext.BaseContext">
1993+ <summary>
1994+ returns the base full context impl
1995+ </summary>
1996+ </member>
1997+ <member name="M:NVelocity.Context.IInternalContextAdapter.Remove(System.Object)">
1998+ <summary>
1999+ Need to define this method here otherwise since both <see cref="T:System.Collections.IDictionary"/> and <see cref="T:NVelocity.Context.IContext"/>
2000+ contains a Remove(Object key) method we will need to cast the object to either interface
2001+ before calling this method, for backward compatibility we make the IContext.Remove the default
2002+ </summary>
2003+ <param name="key"></param>
2004+ <returns></returns>
2005+ </member>
2006+ <member name="T:NVelocity.Context.InternalContextAdapterImpl">
2007+ <summary> This adapter class is the container for all context types for internal
2008+ use. The AST now uses this class rather than the app-level Context
2009+ interface to allow flexibility in the future.
2010+ *
2011+ Currently, we have two context interfaces which must be supported :
2012+ <ul>
2013+ <li> Context : used for application/template data access</li>
2014+ <li> InternalHousekeepingContext : used for internal housekeeping and caching</li>
2015+ <li> InternalWrapperContext : used for getting root cache context and other
2016+ such.</li>
2017+ <li> InternalEventContext : for event handling.</li>
2018+ </ul>
2019+ *
2020+ This class implements the two interfaces to ensure that all methods are
2021+ supported. When adding to the interfaces, or adding more context
2022+ functionality, the interface is the primary definition, so alter that first
2023+ and then all classes as necessary. As of this writing, this would be
2024+ the only class affected by changes to InternalContext
2025+ *
2026+ This class ensures that an InternalContextBase is available for internal
2027+ use. If an application constructs their own Context-implementing
2028+ object w/o sub-classing AbstractContext, it may be that support for
2029+ InternalContext is not available. Therefore, InternalContextAdapter will
2030+ create an InternalContextBase if necessary for this support. Note that
2031+ if this is necessary, internal information such as node-cache data will be
2032+ lost from use to use of the context. This may or may not be important,
2033+ depending upon application.
2034+
2035+ *
2036+ </summary>
2037+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
2038+ </author>
2039+ <version> $Id: InternalContextAdapterImpl.cs,v 1.4 2003/10/27 13:54:08 corts Exp $
2040+
2041+ </version>
2042+ </member>
2043+ <member name="F:NVelocity.Context.InternalContextAdapterImpl.context">
2044+
2045+ <summary> the user data Context that we are wrapping
2046+ </summary>
2047+ </member>
2048+ <member name="F:NVelocity.Context.InternalContextAdapterImpl.internalHousekeepingContext">
2049+
2050+ <summary> the ICB we are wrapping. We may need to make one
2051+ if the user data context implementation doesn't
2052+ support one. The default AbstractContext-derived
2053+ VelocityContext does, and it's recommended that
2054+ people derive new contexts from AbstractContext
2055+ rather than piecing things together
2056+ </summary>
2057+ </member>
2058+ <member name="F:NVelocity.Context.InternalContextAdapterImpl.internalEventContext">
2059+ <summary> The InternalEventContext that we are wrapping. If
2060+ the context passed to us doesn't support it, no
2061+ biggie. We don't make it for them - since its a
2062+ user context thing, nothing gained by making one
2063+ for them now
2064+ </summary>
2065+ </member>
2066+ <member name="M:NVelocity.Context.InternalContextAdapterImpl.#ctor(NVelocity.Context.IContext)">
2067+ <summary> CTOR takes a Context and wraps it, delegating all 'data' calls
2068+ to it.
2069+
2070+ For support of internal contexts, it will create an InternalContextBase
2071+ if need be.
2072+ </summary>
2073+ </member>
2074+ <member name="M:NVelocity.Context.InternalContextAdapterImpl.AttachEventCartridge(NVelocity.App.Events.EventCartridge)">
2075+ <summary> returns the user data context that
2076+ we are wrapping
2077+ </summary>
2078+ <summary> Returns the base context that we are
2079+ wrapping. Here, its this, but for other thing
2080+ like VM related context contortions, it can
2081+ be something else
2082+ </summary>
2083+ </member>
2084+ <member name="T:NVelocity.Context.VMContext">
2085+ <summary> This is a special, internal-use-only context implementation to be
2086+ used for the new Velocimacro implementation.
2087+ *
2088+ The main distinguishing feature is the management of the VMProxyArg objects
2089+ in the put() and get() methods.
2090+ *
2091+ Further, this context also supports the 'VM local context' mode, where
2092+ any get() or put() of references that aren't args to the VM are considered
2093+ local to the vm, protecting the global context.
2094+
2095+ </summary>
2096+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
2097+ </author>
2098+ <version> $Id: VMContext.cs,v 1.4 2003/10/27 13:54:08 corts Exp $
2099+
2100+ </version>
2101+ </member>
2102+ <member name="F:NVelocity.Context.VMContext.vmProxyHash">
2103+ <summary>container for our VMProxy Objects
2104+ </summary>
2105+ </member>
2106+ <member name="F:NVelocity.Context.VMContext.localContext">
2107+ <summary>container for any local or constant VMProxy items
2108+ </summary>
2109+ </member>
2110+ <member name="F:NVelocity.Context.VMContext.innerContext">
2111+ <summary>the base context store. This is the 'global' context
2112+ </summary>
2113+ </member>
2114+ <member name="F:NVelocity.Context.VMContext.wrappedContext">
2115+ <summary>context that we are wrapping
2116+ </summary>
2117+ </member>
2118+ <member name="F:NVelocity.Context.VMContext.localContextScope">
2119+ <summary>support for local context scope feature, where all references are local
2120+ </summary>
2121+ </member>
2122+ <member name="M:NVelocity.Context.VMContext.#ctor(NVelocity.Context.IInternalContextAdapter,NVelocity.Runtime.IRuntimeServices)">
2123+ <summary> CTOR, wraps an ICA
2124+ </summary>
2125+ </member>
2126+ <member name="M:NVelocity.Context.VMContext.AddVMProxyArg(NVelocity.Runtime.Directive.VMProxyArg)">
2127+ <summary> return the inner / user context
2128+ </summary>
2129+ <summary> Used to put VMProxyArgs into this context. It separates
2130+ the VMProxyArgs into constant and non-constant types
2131+ pulling out the value of the constant types so they can
2132+ be modified w/o damaging the VMProxyArg, and leaving the
2133+ dynamic ones, as they modify context rather than their own
2134+ state
2135+ </summary>
2136+ <param name="vmpa">VMProxyArg to add
2137+
2138+ </param>
2139+ </member>
2140+ <member name="M:NVelocity.Context.VMContext.Put(System.String,System.Object)">
2141+ <summary> Impl of the Context.put() method.
2142+ *
2143+ </summary>
2144+ <param name="key">name of item to set
2145+ </param>
2146+ <param name="value">object to set to key
2147+ </param>
2148+ <returns>old stored object
2149+
2150+ </returns>
2151+ </member>
2152+ <member name="M:NVelocity.Context.VMContext.Get(System.String)">
2153+ <summary> Impl of the Context.gut() method.
2154+ *
2155+ </summary>
2156+ <param name="key">name of item to get
2157+ </param>
2158+ <returns> stored object or null
2159+
2160+ </returns>
2161+ </member>
2162+ <member name="M:NVelocity.Context.VMContext.ContainsKey(System.Object)">
2163+ <summary> not yet impl
2164+ </summary>
2165+ </member>
2166+ <member name="M:NVelocity.Context.VMContext.Remove(System.Object)">
2167+ <summary> impl badly
2168+ </summary>
2169+ <summary> impl badly
2170+ </summary>
2171+ </member>
2172+ <member name="T:NVelocity.Exception.MethodInvocationException">
2173+ <summary>
2174+ Application-level exception thrown when a reference method is
2175+ invoked and an exception is thrown.
2176+ <br/>
2177+ When this exception is thrown, a best effort will be made to have
2178+ useful information in the exception's message. For complete
2179+ information, consult the runtime log.
2180+ </summary>
2181+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a> </author>
2182+ <version> $Id: MethodInvocationException.cs,v 1.3 2003/10/27 13:54:08 corts Exp $ </version>
2183+ </member>
2184+ <member name="T:NVelocity.Exception.VelocityException">
2185+ <summary>
2186+ Base class for Velocity exceptions thrown to the
2187+ application layer.
2188+ </summary>
2189+ </member>
2190+ <member name="M:NVelocity.Exception.MethodInvocationException.#ctor(System.String,System.Exception,System.String)">
2191+ <summary>
2192+ Wraps the passed in exception for examination later
2193+ </summary>
2194+ </member>
2195+ <member name="T:NVelocity.Exception.ParseErrorException">
2196+ <summary> Application-level exception thrown when a resource of any type
2197+ has a syntax or other error which prevents it from being parsed.
2198+ <br/>
2199+ When this resource is thrown, a best effort will be made to have
2200+ useful information in the exception's message. For complete
2201+ information, consult the runtime log.
2202+ *
2203+ </summary>
2204+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
2205+ </author>
2206+ <version> $Id: ParseErrorException.cs,v 1.3 2003/10/27 13:54:08 corts Exp $
2207+
2208+ </version>
2209+ </member>
2210+ <member name="T:NVelocity.Exception.ResourceNotFoundException">
2211+ <summary>
2212+ Application-level exception thrown when a resource of any type
2213+ isn't found by the Velocity engine.
2214+ <br/>
2215+ When this exception is thrown, a best effort will be made to have
2216+ useful information in the exception's message. For complete
2217+ information, consult the runtime log.
2218+ </summary>
2219+ </member>
2220+ <member name="T:NVelocity.IDuck">
2221+ <summary>
2222+
2223+ </summary>
2224+ </member>
2225+ <member name="M:NVelocity.IDuck.GetInvoke(System.String)">
2226+ <summary>
2227+ Defines the behavior when a property is read
2228+ </summary>
2229+ <param name="propName">Property name.</param>
2230+ <returns>value back to the template</returns>
2231+ </member>
2232+ <member name="M:NVelocity.IDuck.SetInvoke(System.String,System.Object)">
2233+ <summary>
2234+ Defines the behavior when a property is written
2235+ </summary>
2236+ <param name="propName">Property name.</param>
2237+ <param name="value">The value to assign.</param>
2238+ </member>
2239+ <member name="M:NVelocity.IDuck.Invoke(System.String,System.Object[])">
2240+ <summary>
2241+ Invokes the specified method.
2242+ </summary>
2243+ <param name="method">The method name.</param>
2244+ <param name="args">The method arguments.</param>
2245+ <returns>value back to the template</returns>
2246+ </member>
2247+ <member name="T:NVelocity.Runtime.Directive.Directive">
2248+ <summary> Base class for all directives used in Velocity.</summary>
2249+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a> </author>
2250+ <version> $Id: Directive.cs,v 1.3 2003/10/27 13:54:10 corts Exp $ </version>
2251+ </member>
2252+ <member name="M:NVelocity.Runtime.Directive.Directive.Init(NVelocity.Runtime.IRuntimeServices,NVelocity.Context.IInternalContextAdapter,NVelocity.Runtime.Parser.Node.INode)">
2253+ <summary>
2254+ How this directive is to be initialized.
2255+ </summary>
2256+ </member>
2257+ <member name="M:NVelocity.Runtime.Directive.Directive.SetLocation(System.Int32,System.Int32)">
2258+ <summary>
2259+ Allows the template location to be set
2260+ </summary>
2261+ </member>
2262+ <member name="M:NVelocity.Runtime.Directive.Directive.Render(NVelocity.Context.IInternalContextAdapter,System.IO.TextWriter,NVelocity.Runtime.Parser.Node.INode)">
2263+ <summary>
2264+ How this directive is to be rendered
2265+ </summary>
2266+ </member>
2267+ <member name="P:NVelocity.Runtime.Directive.Directive.Name">
2268+ <summary>
2269+ Return the name of this directive
2270+ </summary>
2271+ </member>
2272+ <member name="P:NVelocity.Runtime.Directive.Directive.Type">
2273+ <summary>
2274+ Get the directive type BLOCK/LINE
2275+ </summary>
2276+ </member>
2277+ <member name="P:NVelocity.Runtime.Directive.Directive.Line">
2278+ <summary>
2279+ for log msg purposes
2280+ </summary>
2281+ </member>
2282+ <member name="P:NVelocity.Runtime.Directive.Directive.Column">
2283+ <summary>
2284+ for log msg purposes
2285+ </summary>
2286+ </member>
2287+ <member name="T:NVelocity.Runtime.Directive.DirectiveType">
2288+ <summary>
2289+ Directive Types
2290+ </summary>
2291+ </member>
2292+ <member name="T:NVelocity.Runtime.Directive.Foreach">
2293+ <summary>
2294+ Foreach directive used for moving through arrays,
2295+ or objects that provide an Iterator.
2296+ </summary>
2297+ </member>
2298+ <member name="F:NVelocity.Runtime.Directive.Foreach.counterName">
2299+ <summary>
2300+ The name of the variable to use when placing
2301+ the counter value into the context. Right
2302+ now the default is $velocityCount.
2303+ </summary>
2304+ </member>
2305+ <member name="F:NVelocity.Runtime.Directive.Foreach.counterInitialValue">
2306+ <summary>
2307+ What value to start the loop counter at.
2308+ </summary>
2309+ </member>
2310+ <member name="F:NVelocity.Runtime.Directive.Foreach.elementKey">
2311+ <summary>
2312+ The reference name used to access each
2313+ of the elements in the list object. It
2314+ is the $item in the following:
2315+
2316+ #foreach ($item in $list)
2317+
2318+ This can be used class wide because
2319+ it is immutable.
2320+ </summary>
2321+ </member>
2322+ <member name="M:NVelocity.Runtime.Directive.Foreach.Init(NVelocity.Runtime.IRuntimeServices,NVelocity.Context.IInternalContextAdapter,NVelocity.Runtime.Parser.Node.INode)">
2323+ <summary>
2324+ simple init - init the tree and get the elementKey from
2325+ the AST
2326+ </summary>
2327+ </member>
2328+ <member name="M:NVelocity.Runtime.Directive.Foreach.GetIterator(NVelocity.Context.IInternalContextAdapter,NVelocity.Runtime.Parser.Node.INode)">
2329+ <summary>
2330+ returns an Iterator to the collection in the #foreach()
2331+ </summary>
2332+ <param name="context"> current context </param>
2333+ <param name="node"> AST node </param>
2334+ <returns>Iterator to do the dataset </returns>
2335+ </member>
2336+ <member name="M:NVelocity.Runtime.Directive.Foreach.Render(NVelocity.Context.IInternalContextAdapter,System.IO.TextWriter,NVelocity.Runtime.Parser.Node.INode)">
2337+ <summary>
2338+ renders the #foreach() block
2339+ </summary>
2340+ </member>
2341+ <member name="P:NVelocity.Runtime.Directive.Foreach.Name">
2342+ <summary>
2343+ Return name of this directive.
2344+ </summary>
2345+ </member>
2346+ <member name="P:NVelocity.Runtime.Directive.Foreach.Type">
2347+ <summary>
2348+ Return type of this directive.
2349+ </summary>
2350+ </member>
2351+ <member name="T:NVelocity.Runtime.Directive.Include">
2352+ <summary>
2353+ Pluggable directive that handles the #include() statement in VTL.
2354+ This #include() can take multiple arguments of either
2355+ StringLiteral or Reference.
2356+
2357+ Notes:
2358+ -----
2359+ 1) The included source material can only come from somewhere in
2360+ the TemplateRoot tree for security reasons. There is no way
2361+ around this. If you want to include content from elsewhere on
2362+ your disk, use a link from somewhere under Template Root to that
2363+ content.
2364+
2365+ 2) By default, there is no output to the render stream in the event of
2366+ a problem. You can override this behavior with two property values :
2367+ include.output.errormsg.start
2368+ include.output.errormsg.end
2369+ If both are defined in velocity.properties, they will be used to
2370+ in the render output to bracket the arg string that caused the
2371+ problem.
2372+ Ex. : if you are working in html then
2373+ include.output.errormsg.start=<!-- #include error :
2374+ include.output.errormsg.end= -->
2375+ might be an excellent way to start...
2376+
2377+ 3) As noted above, #include() can take multiple arguments.
2378+ Ex : #include( "foo.vm" "bar.vm" $foo )
2379+ will simply include all three if valid to output w/o any
2380+ special separator.
2381+
2382+ </summary>
2383+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
2384+ </author>
2385+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
2386+ </author>
2387+ <author> <a href="mailto:kav@kav.dk">Kasper Nielsen</a>
2388+ </author>
2389+ <version> $Id: Include.cs,v 1.3 2003/10/27 13:54:10 corts Exp $
2390+
2391+ </version>
2392+ </member>
2393+ <member name="M:NVelocity.Runtime.Directive.Include.Init(NVelocity.Runtime.IRuntimeServices,NVelocity.Context.IInternalContextAdapter,NVelocity.Runtime.Parser.Node.INode)">
2394+ <summary>
2395+ simple init - init the tree and get the elementKey from
2396+ the AST
2397+ </summary>
2398+ </member>
2399+ <member name="M:NVelocity.Runtime.Directive.Include.Render(NVelocity.Context.IInternalContextAdapter,System.IO.TextWriter,NVelocity.Runtime.Parser.Node.INode)">
2400+ <summary>
2401+ iterates through the argument list and renders every
2402+ argument that is appropriate. Any non appropriate
2403+ arguments are logged, but render() continues.
2404+ </summary>
2405+ </member>
2406+ <member name="M:NVelocity.Runtime.Directive.Include.RenderOutput(NVelocity.Runtime.Parser.Node.INode,NVelocity.Context.IInternalContextAdapter,System.IO.TextWriter)">
2407+ <summary>
2408+ does the actual rendering of the included file
2409+ </summary>
2410+ <param name="node">AST argument of type StringLiteral or Reference</param>
2411+ <param name="context">valid context so we can render References</param>
2412+ <param name="writer">output Writer</param>
2413+ <returns>boolean success or failure. failures are logged</returns>
2414+ </member>
2415+ <member name="M:NVelocity.Runtime.Directive.Include.OutputErrorToStream(System.IO.TextWriter,System.String)">
2416+ <summary>
2417+ Puts a message to the render output stream if ERRORMSG_START / END
2418+ are valid property strings. Mainly used for end-user template
2419+ debugging.
2420+ </summary>
2421+ </member>
2422+ <member name="P:NVelocity.Runtime.Directive.Include.Name">
2423+ <summary>
2424+ Return name of this directive.
2425+ </summary>
2426+ </member>
2427+ <member name="P:NVelocity.Runtime.Directive.Include.Type">
2428+ <summary> Return type of this directive.</summary>
2429+ </member>
2430+ <member name="T:NVelocity.Runtime.Directive.Literal">
2431+ <summary>
2432+ A very simple directive that leverages the Node.literal()
2433+ to grab the literal rendition of a node. We basically
2434+ grab the literal value on init(), then repeatedly use
2435+ that during render().
2436+ </summary>
2437+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a> </author>
2438+ <version> $Id: Literal.cs,v 1.3 2003/10/27 13:54:10 corts Exp $ </version>
2439+ </member>
2440+ <member name="M:NVelocity.Runtime.Directive.Literal.Init(NVelocity.Runtime.IRuntimeServices,NVelocity.Context.IInternalContextAdapter,NVelocity.Runtime.Parser.Node.INode)">
2441+ <summary>
2442+ Store the literal rendition of a node using
2443+ the Node.literal().
2444+ </summary>
2445+ </member>
2446+ <member name="M:NVelocity.Runtime.Directive.Literal.Render(NVelocity.Context.IInternalContextAdapter,System.IO.TextWriter,NVelocity.Runtime.Parser.Node.INode)">
2447+ <summary> Throw the literal rendition of the block between
2448+ #literal()/#end into the writer.
2449+ </summary>
2450+ </member>
2451+ <member name="P:NVelocity.Runtime.Directive.Literal.Name">
2452+ <summary>Return name of this directive.</summary>
2453+ </member>
2454+ <member name="P:NVelocity.Runtime.Directive.Literal.Type">
2455+ <summary> Return type of this directive. </summary>
2456+ </member>
2457+ <member name="T:NVelocity.Runtime.Directive.Macro">
2458+ <summary>
2459+ Macro implements the macro definition directive of VTL.
2460+
2461+ example :
2462+
2463+ #macro( isnull $i )
2464+ #if( $i )
2465+ $i
2466+ #end
2467+ #end
2468+
2469+ This object is used at parse time to mainly process and register the
2470+ macro. It is used inline in the parser when processing a directive.
2471+
2472+ </summary>
2473+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a></author>
2474+ <version> $Id: Macro.cs,v 1.3 2003/10/27 13:54:10 corts Exp $</version>
2475+ </member>
2476+ <member name="M:NVelocity.Runtime.Directive.Macro.Render(NVelocity.Context.IInternalContextAdapter,System.IO.TextWriter,NVelocity.Runtime.Parser.Node.INode)">
2477+ <summary> Return name of this directive.
2478+ </summary>
2479+ <summary> Return type of this directive.
2480+ </summary>
2481+ <summary> render() doesn't do anything in the final output rendering.
2482+ There is no output from a #macro() directive.
2483+ </summary>
2484+ </member>
2485+ <member name="M:NVelocity.Runtime.Directive.Macro.processAndRegister(NVelocity.Runtime.IRuntimeServices,NVelocity.Runtime.Parser.Node.INode,System.String)">
2486+ <summary>
2487+ Used by Parser.java to process VMs within the parsing process
2488+
2489+ processAndRegister() doesn't actually render the macro to the output
2490+ Processes the macro body into the internal representation used by the
2491+ VelocimacroProxy objects, and if not currently used, adds it
2492+ to the macro Factory
2493+ </summary>
2494+ </member>
2495+ <member name="M:NVelocity.Runtime.Directive.Macro.getArgArray(NVelocity.Runtime.Parser.Node.INode)">
2496+ <summary> creates an array containing the literal
2497+ strings in the macro argument
2498+ </summary>
2499+ </member>
2500+ <member name="M:NVelocity.Runtime.Directive.Macro.getASTAsStringArray(NVelocity.Runtime.Parser.Node.INode)">
2501+ <summary> Returns an array of the literal rep of the AST
2502+ </summary>
2503+ </member>
2504+ <member name="T:NVelocity.Runtime.Directive.Parse">
2505+ <summary>
2506+ Pluggable directive that handles the #parse() statement in VTL.
2507+
2508+ Notes:
2509+ -----
2510+ 1) The parsed source material can only come from somewhere in
2511+ the TemplateRoot tree for security reasons. There is no way
2512+ around this. If you want to include content from elsewhere on
2513+ your disk, use a link from somewhere under Template Root to that
2514+ content.
2515+
2516+ 2) There is a limited parse depth. It is set as a property
2517+ "parse_directive.maxdepth = 10" for example. There is a 20 iteration
2518+ safety in the event that the parameter isn't set.
2519+
2520+ </summary>
2521+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a> </author>
2522+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a> </author>
2523+ <author> <a href="mailto:Christoph.Reck@dlr.de">Christoph Reck</a> </author>
2524+ <version> $Id: Parse.cs,v 1.4 2003/10/27 13:54:10 corts Exp $ </version>
2525+ </member>
2526+ <member name="M:NVelocity.Runtime.Directive.Parse.Render(NVelocity.Context.IInternalContextAdapter,System.IO.TextWriter,NVelocity.Runtime.Parser.Node.INode)">
2527+ <summary>
2528+ iterates through the argument list and renders every
2529+ argument that is appropriate. Any non appropriate
2530+ arguments are logged, but render() continues.
2531+ </summary>
2532+ </member>
2533+ <member name="M:NVelocity.Runtime.Directive.Parse.AssertTemplateStack(NVelocity.Context.IInternalContextAdapter)">
2534+ <summary>
2535+ See if we have exceeded the configured depth.
2536+ If it isn't configured, put a stop at 20 just in case.
2537+ </summary>
2538+ </member>
2539+ <member name="P:NVelocity.Runtime.Directive.Parse.Name">
2540+ <summary>
2541+ Return name of this directive.
2542+ </summary>
2543+ </member>
2544+ <member name="P:NVelocity.Runtime.Directive.Parse.Type">
2545+ <summary> Return type of this directive. </summary>
2546+ </member>
2547+ <member name="T:NVelocity.Runtime.Directive.ParseDirectiveException">
2548+ <summary> Exception for #parse() problems
2549+ *
2550+ </summary>
2551+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
2552+ </author>
2553+ <version> $Id: ParseDirectiveException.cs,v 1.3 2003/10/27 13:54:10 corts Exp $
2554+
2555+ </version>
2556+ </member>
2557+ <member name="M:NVelocity.Runtime.Directive.ParseDirectiveException.#ctor(System.String,System.Int32)">
2558+ <summary> Constructor
2559+ </summary>
2560+ </member>
2561+ <member name="M:NVelocity.Runtime.Directive.ParseDirectiveException.addFile(System.String)">
2562+ <summary> Get a message.
2563+ </summary>
2564+ <summary> Add a file to the filename stack
2565+ </summary>
2566+ </member>
2567+ <member name="T:NVelocity.Runtime.Directive.VelocimacroProxy">
2568+ <summary>
2569+ VelocimacroProxy
2570+ a proxy Directive-derived object to fit with the current directive system
2571+ </summary>
2572+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a></author>
2573+ <version> $Id: VelocimacroProxy.cs,v 1.4 2003/10/27 13:54:10 corts Exp $ </version>
2574+ </member>
2575+ <member name="M:NVelocity.Runtime.Directive.VelocimacroProxy.Init(NVelocity.Runtime.IRuntimeServices,NVelocity.Context.IInternalContextAdapter,NVelocity.Runtime.Parser.Node.INode)">
2576+ <summary>
2577+ The major meat of VelocimacroProxy, init() checks the # of arguments,
2578+ patches the macro body, renders the macro into an AST, and then initiates
2579+ the AST, so it is ready for quick rendering. Note that this is only
2580+ AST dependant stuff. Not context.
2581+ </summary>
2582+ </member>
2583+ <member name="M:NVelocity.Runtime.Directive.VelocimacroProxy.Render(NVelocity.Context.IInternalContextAdapter,System.IO.TextWriter,NVelocity.Runtime.Parser.Node.INode)">
2584+ <summary>
2585+ Renders the macro using the context
2586+ </summary>
2587+ </member>
2588+ <member name="M:NVelocity.Runtime.Directive.VelocimacroProxy.setupMacro(System.String[],System.Int32[])">
2589+ <summary>
2590+ basic VM setup. Sets up the proxy args for this
2591+ use, and parses the tree
2592+ </summary>
2593+ </member>
2594+ <member name="M:NVelocity.Runtime.Directive.VelocimacroProxy.parseTree(System.String[])">
2595+ <summary>
2596+ parses the macro. We need to do this here, at init time, or else
2597+ the local-scope template feature is hard to get to work :)
2598+ </summary>
2599+ </member>
2600+ <member name="M:NVelocity.Runtime.Directive.VelocimacroProxy.getArgArray(NVelocity.Runtime.Parser.Node.INode)">
2601+ <summary>
2602+ Gets the args to the VM from the instance-use AST
2603+ </summary>
2604+ </member>
2605+ <member name="P:NVelocity.Runtime.Directive.VelocimacroProxy.Name">
2606+ <summary>
2607+ The name of this Velocimacro.
2608+ </summary>
2609+ </member>
2610+ <member name="P:NVelocity.Runtime.Directive.VelocimacroProxy.Type">
2611+ <summary>
2612+ Velocimacros are always LINE
2613+ type directives.
2614+ </summary>
2615+ </member>
2616+ <member name="P:NVelocity.Runtime.Directive.VelocimacroProxy.ArgArray">
2617+ <summary>
2618+ Sets the array of arguments specified in the macro definition
2619+ </summary>
2620+ </member>
2621+ <member name="P:NVelocity.Runtime.Directive.VelocimacroProxy.NumArgs">
2622+ <summary>
2623+ Returns the number of arguments needed for this VM
2624+ </summary>
2625+ </member>
2626+ <member name="P:NVelocity.Runtime.Directive.VelocimacroProxy.MacroBody">
2627+ <summary>
2628+ Sets the original macro body. This is simply the cat of the
2629+ macroArray, but the Macro object creates this once during parsing,
2630+ and everyone shares it.
2631+
2632+ Note : it must not be modified.
2633+ </summary>
2634+ </member>
2635+ <member name="T:NVelocity.Runtime.Directive.VMProxyArg">
2636+ <summary>
2637+ The function of this class is to proxy for the calling parameter to the VM.
2638+ *
2639+ This class is designed to be used in conjunction with the VMContext class
2640+ which knows how to get and set values via it, rather than a simple get()
2641+ or put() from a hashtable-like object.
2642+ *
2643+ There is probably a lot of undocumented subtlety here, so step lightly.
2644+ *
2645+ We rely on the observation that an instance of this object has a constant
2646+ state throughout its lifetime as it's bound to the use-instance of a VM.
2647+ In other words, it's created by the VelocimacroProxy class, to represent
2648+ one of the arguments to a VM in a specific template. Since the template
2649+ is fixed (it's a file...), we don't have to worry that the args to the VM
2650+ will change. Yes, the VM will be called in other templates, or in other
2651+ places on the same template, bit those are different use-instances.
2652+ *
2653+ These arguments can be, in the lingo of
2654+ the parser, one of :
2655+ <ul>
2656+ <li> Reference() : anything that starts with '$'</li>
2657+ <li> StringLiteral() : something like "$foo" or "hello geir"</li>
2658+ <li> NumberLiteral() : 1, 2 etc</li>
2659+ <li> IntegerRange() : [ 1..2] or [$foo .. $bar]</li>
2660+ <li> ObjectArray() : [ "a", "b", "c"]</li>
2661+ <li> True() : true</li>
2662+ <li> False() : false</li>
2663+ <li>Word() : not likely - this is simply allowed by the parser so we can have
2664+ syntactical sugar like #foreach($a in $b) where 'in' is the Word</li>
2665+ </ul>
2666+ Now, Reference(), StringLit, NumberLit, IntRange, ObjArr are all dynamic things, so
2667+ their value is gotten with the use of a context. The others are constants. The trick
2668+ we rely on is that the context rather than this class really represents the
2669+ state of the argument. We are simply proxying for the thing, returning the proper value
2670+ when asked, and storing the proper value in the appropriate context when asked.
2671+ *
2672+ So, the hope here, so an instance of this can be shared across threads, is to
2673+ keep any dynamic stuff out of it, relying on trick of having the appropriate
2674+ context handed to us, and when a constant argument, letting VMContext punch that
2675+ into a local context.
2676+
2677+ </summary>
2678+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
2679+ </author>
2680+ <version> $Id: VMProxyArg.cs,v 1.4 2003/10/27 13:54:10 corts Exp $
2681+
2682+ </version>
2683+ </member>
2684+ <member name="F:NVelocity.Runtime.Directive.VMProxyArg.GENERALSTATIC">
2685+ <summary>in the event our type is switched - we don't care really what it is
2686+ </summary>
2687+ </member>
2688+ <member name="F:NVelocity.Runtime.Directive.VMProxyArg.type">
2689+ <summary>type of arg I will have
2690+ </summary>
2691+ </member>
2692+ <member name="F:NVelocity.Runtime.Directive.VMProxyArg.nodeTree">
2693+ <summary>the AST if the type is such that it's dynamic (ex. JJTREFERENCE )
2694+ </summary>
2695+ </member>
2696+ <member name="F:NVelocity.Runtime.Directive.VMProxyArg.staticObject">
2697+ <summary>reference for the object if we proxy for a static arg like an NumberLiteral
2698+ </summary>
2699+ </member>
2700+ <member name="F:NVelocity.Runtime.Directive.VMProxyArg.userContext">
2701+ <summary>not used in this impl : carries the appropriate user context
2702+ </summary>
2703+ </member>
2704+ <member name="F:NVelocity.Runtime.Directive.VMProxyArg.numTreeChildren">
2705+ <summary>number of children in our tree if a reference
2706+ </summary>
2707+ </member>
2708+ <member name="F:NVelocity.Runtime.Directive.VMProxyArg.contextReference">
2709+ <summary>our identity in the current context
2710+ </summary>
2711+ </member>
2712+ <member name="F:NVelocity.Runtime.Directive.VMProxyArg.callerReference">
2713+ <summary>the reference we are proxying for
2714+ </summary>
2715+ </member>
2716+ <member name="F:NVelocity.Runtime.Directive.VMProxyArg.singleLevelRef">
2717+ <summary>the 'de-dollared' reference if we are a ref but don't have a method attached
2718+ </summary>
2719+ </member>
2720+ <member name="F:NVelocity.Runtime.Directive.VMProxyArg.constant">
2721+ <summary>by default, we are dynamic. safest
2722+ </summary>
2723+ </member>
2724+ <member name="M:NVelocity.Runtime.Directive.VMProxyArg.#ctor(NVelocity.Runtime.IRuntimeServices,System.String,System.String,System.Int32)">
2725+ <summary> ctor for current impl
2726+ *
2727+ takes the reference literal we are proxying for, the literal
2728+ the VM we are for is called with...
2729+ *
2730+ </summary>
2731+ <param name="rs">
2732+ </param>
2733+ <param name="contextRef">reference arg in the definition of the VM, used in the VM
2734+ </param>
2735+ <param name="callerRef"> reference used by the caller as an arg to the VM
2736+ </param>
2737+ <param name="t"> type of arg : JJTREFERENCE, JJTTRUE, etc
2738+
2739+ </param>
2740+ </member>
2741+ <member name="M:NVelocity.Runtime.Directive.VMProxyArg.isConstant">
2742+ <summary> tells if arg we are proxying for is
2743+ dynamic or constant.
2744+ *
2745+ </summary>
2746+ <returns>true of constant, false otherwise
2747+
2748+ </returns>
2749+ </member>
2750+ <member name="M:NVelocity.Runtime.Directive.VMProxyArg.setObject(NVelocity.Context.IInternalContextAdapter,System.Object)">
2751+ <summary> Invoked by VMContext when Context.put() is called for a proxied reference.
2752+ *
2753+ </summary>
2754+ <param name="context">context to modify via direct placement, or AST.setValue()
2755+ </param>
2756+ <param name="o"> new value of reference
2757+ </param>
2758+ <returns>Object currently null
2759+
2760+ </returns>
2761+ </member>
2762+ <member name="M:NVelocity.Runtime.Directive.VMProxyArg.getObject(NVelocity.Context.IInternalContextAdapter)">
2763+ <summary> returns the value of the reference. Generally, this is only
2764+ called for dynamic proxies, as the static ones should have
2765+ been stored in the VMContext's localContext store
2766+ *
2767+ </summary>
2768+ <param name="context">Context to use for getting current value
2769+ </param>
2770+ <returns>Object value
2771+ *
2772+
2773+ </returns>
2774+ </member>
2775+ <member name="M:NVelocity.Runtime.Directive.VMProxyArg.setup">
2776+ <summary> does the housekeeping upon creating. If a dynamic type
2777+ it needs to make an AST for further get()/set() operations
2778+ Anything else is constant.
2779+ </summary>
2780+ </member>
2781+ <member name="M:NVelocity.Runtime.Directive.VMProxyArg.#ctor(NVelocity.Runtime.Directive.VMProxyArg,NVelocity.Context.IInternalContextAdapter)">
2782+ <summary> not used in current impl
2783+ *
2784+ Constructor for alternate impl where VelProxy class would make new
2785+ VMProxyArg objects, and use this constructor to avoid re-parsing the
2786+ reference args
2787+ *
2788+ that impl also had the VMProxyArg carry it's context
2789+ </summary>
2790+ </member>
2791+ <member name="T:NVelocity.Runtime.Exception.ReferenceException">
2792+ <summary> Exception thrown when a bad reference is found.
2793+ *
2794+ </summary>
2795+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
2796+ </author>
2797+ <version> $Id: ReferenceException.cs,v 1.3 2003/10/27 13:54:10 corts Exp $
2798+
2799+ </version>
2800+ </member>
2801+ <member name="T:NVelocity.Runtime.IRuntimeLogger">
2802+ <summary>
2803+ Interface for internal runtime logging services that are needed by the
2804+ </summary>
2805+ <author><a href="mailto:geirm@apache.org">Geir Magusson Jr.</a></author>
2806+ <version>$Id: RuntimeLogger.cs,v 1.1 2004/01/02 00:04:50 corts Exp $</version>
2807+ </member>
2808+ <member name="M:NVelocity.Runtime.IRuntimeLogger.Warn(System.Object)">
2809+ <summary>
2810+ Log a warning message.
2811+ </summary>
2812+ <param name="message">message to log</param>
2813+ </member>
2814+ <member name="M:NVelocity.Runtime.IRuntimeLogger.Info(System.Object)">
2815+ <summary>
2816+ Log an info message.
2817+ </summary>
2818+ <param name="message">message to log</param>
2819+ </member>
2820+ <member name="M:NVelocity.Runtime.IRuntimeLogger.Error(System.Object)">
2821+ <summary>
2822+ Log an error message.
2823+ </summary>
2824+ <param name="message">message to log</param>
2825+ </member>
2826+ <member name="M:NVelocity.Runtime.IRuntimeLogger.Debug(System.Object)">
2827+ <summary>
2828+ Log a debug message.
2829+ </summary>
2830+ <param name="message">message to log</param>
2831+ </member>
2832+ <member name="T:NVelocity.Runtime.IRuntimeServices">
2833+ <summary> Interface for internal runtime services that are needed by the
2834+ various components w/in Velocity. This was taken from the old
2835+ Runtime singleton, and anything not necessary was removed.
2836+
2837+ Currently implemented by RuntimeInstance.
2838+ </summary>
2839+ </member>
2840+ <member name="M:NVelocity.Runtime.IRuntimeServices.SetProperty(System.String,System.Object)">
2841+ <summary>
2842+ Allows an external system to set a property in
2843+ the Velocity Runtime.
2844+ </summary>
2845+ <param name="key">property key</param>
2846+ <param name="value">property value</param>
2847+ </member>
2848+ <member name="M:NVelocity.Runtime.IRuntimeServices.AddProperty(System.String,System.Object)">
2849+ <summary> Add a property to the configuration. If it already
2850+ exists then the value stated here will be added
2851+ to the configuration entry. For example, if
2852+ *
2853+ resource.loader = file
2854+ *
2855+ is already present in the configuration and you
2856+ *
2857+ addProperty("resource.loader", "classpath")
2858+ *
2859+ Then you will end up with a Vector like the
2860+ following:
2861+ *
2862+ ["file", "classpath"]
2863+ *
2864+ </summary>
2865+ <param name="key">key</param>
2866+ <param name="value">value</param>
2867+ </member>
2868+ <member name="M:NVelocity.Runtime.IRuntimeServices.ClearProperty(System.String)">
2869+ <summary>
2870+ Clear the values pertaining to a particular property.
2871+ </summary>
2872+ <param name="key">key of property to clear</param>
2873+ </member>
2874+ <member name="M:NVelocity.Runtime.IRuntimeServices.GetProperty(System.String)">
2875+ <summary> Allows an external caller to get a property. The calling
2876+ routine is required to know the type, as this routine
2877+ will return an Object, as that is what properties can be.
2878+ *
2879+ </summary>
2880+ <param name="key">property to return
2881+
2882+ </param>
2883+ </member>
2884+ <member name="M:NVelocity.Runtime.IRuntimeServices.Init(System.String)">
2885+ <summary>
2886+ Initialize the Velocity Runtime with the name of
2887+ ExtendedProperties object.
2888+ </summary>
2889+ <param name="configurationFile">Properties</param>
2890+ </member>
2891+ <member name="M:NVelocity.Runtime.IRuntimeServices.Parse(System.IO.TextReader,System.String)">
2892+ <summary>
2893+ Parse the input and return the root of
2894+ AST node structure.
2895+ </summary>
2896+ <remarks>
2897+ In the event that it runs out of parsers in the
2898+ pool, it will create and let them be GC'd
2899+ dynamically, logging that it has to do that. This
2900+ is considered an exceptional condition. It is
2901+ expected that the user will set the
2902+ PARSER_POOL_SIZE property appropriately for their
2903+ application. We will revisit this.
2904+ </remarks>
2905+ <param name="reader">inputStream retrieved by a resource loader</param>
2906+ <param name="templateName">name of the template being parsed</param>
2907+ </member>
2908+ <member name="M:NVelocity.Runtime.IRuntimeServices.Parse(System.IO.TextReader,System.String,System.Boolean)">
2909+ <summary>
2910+ Parse the input and return the root of the AST node structure.
2911+ </summary>
2912+ <param name="reader">inputStream retrieved by a resource loader</param>
2913+ <param name="templateName">name of the template being parsed</param>
2914+ <param name="dumpNamespace">flag to dump the Velocimacro namespace for this template</param>
2915+ </member>
2916+ <member name="M:NVelocity.Runtime.IRuntimeServices.GetTemplate(System.String)">
2917+ <summary> Returns a <code>Template</code> from the resource manager.
2918+ This method assumes that the character encoding of the
2919+ template is set by the <code>input.encoding</code>
2920+ property. The default is "ISO-8859-1"
2921+ *
2922+ </summary>
2923+ <param name="name">The file name of the desired template.
2924+ </param>
2925+ <returns> The template.
2926+ @throws ResourceNotFoundException if template not found
2927+ from any available source.
2928+ @throws ParseErrorException if template cannot be parsed due
2929+ to syntax (or other) error.
2930+ @throws Exception if an error occurs in template initialization
2931+
2932+ </returns>
2933+ </member>
2934+ <member name="M:NVelocity.Runtime.IRuntimeServices.GetTemplate(System.String,System.String)">
2935+ <summary> Returns a <code>Template</code> from the resource manager
2936+ *
2937+ </summary>
2938+ <param name="name">The name of the desired template.
2939+ </param>
2940+ <param name="encoding">Character encoding of the template
2941+ </param>
2942+ <returns> The template.
2943+ @throws ResourceNotFoundException if template not found
2944+ from any available source.
2945+ @throws ParseErrorException if template cannot be parsed due
2946+ to syntax (or other) error.
2947+ @throws Exception if an error occurs in template initialization
2948+
2949+ </returns>
2950+ </member>
2951+ <member name="M:NVelocity.Runtime.IRuntimeServices.GetContent(System.String)">
2952+ <summary> Returns a static content resource from the
2953+ resource manager. Uses the current value
2954+ if INPUT_ENCODING as the character encoding.
2955+ *
2956+ </summary>
2957+ <param name="name">Name of content resource to get
2958+ </param>
2959+ <returns>parsed ContentResource object ready for use
2960+ @throws ResourceNotFoundException if template not found
2961+ from any available source.
2962+
2963+ </returns>
2964+ </member>
2965+ <member name="M:NVelocity.Runtime.IRuntimeServices.GetContent(System.String,System.String)">
2966+ <summary> Returns a static content resource from the
2967+ resource manager.
2968+ *
2969+ </summary>
2970+ <param name="name">Name of content resource to get
2971+ </param>
2972+ <param name="encoding">Character encoding to use
2973+ </param>
2974+ <returns>parsed ContentResource object ready for use
2975+ @throws ResourceNotFoundException if template not found
2976+ from any available source.
2977+
2978+ </returns>
2979+ </member>
2980+ <member name="M:NVelocity.Runtime.IRuntimeServices.GetLoaderNameForResource(System.String)">
2981+ <summary> Determines is a template exists, and returns name of the loader that
2982+ provides it. This is a slightly less hokey way to support
2983+ the Velocity.templateExists() utility method, which was broken
2984+ when per-template encoding was introduced. We can revisit this.
2985+ *
2986+ </summary>
2987+ <param name="resourceName">Name of template or content resource
2988+ </param>
2989+ <returns>class name of loader than can provide it
2990+
2991+ </returns>
2992+ </member>
2993+ <member name="M:NVelocity.Runtime.IRuntimeServices.GetString(System.String,System.String)">
2994+ <summary>
2995+ String property accessor method with default to hide the
2996+ configuration implementation.
2997+ </summary>
2998+ <param name="key">key property key</param>
2999+ <param name="defaultValue">default value to return if key not
3000+ found in resource manager.
3001+ </param>
3002+ <returns>value of key or default</returns>
3003+ </member>
3004+ <member name="M:NVelocity.Runtime.IRuntimeServices.GetVelocimacro(System.String,System.String)">
3005+ <summary>
3006+ Returns the appropriate VelocimacroProxy object if vmName
3007+ is a valid current Velocimacro.
3008+ </summary>
3009+ <param name="vmName">Name of velocimacro requested</param>
3010+ <param name="templateName">Template Name</param>
3011+ <returns>VelocimacroProxy</returns>
3012+ </member>
3013+ <member name="M:NVelocity.Runtime.IRuntimeServices.AddVelocimacro(System.String,System.String,System.String[],System.String)">
3014+ <summary>
3015+ Adds a new Velocimacro. Usually called by Macro only while parsing.
3016+ </summary>
3017+ <param name="name">name Name of velocimacro</param>
3018+ <param name="macro">macro String form of macro body</param>
3019+ <param name="argArray">argArray Array of strings, containing the
3020+ <c>#macro()</c> arguments. the 0th is the name.</param>
3021+ <param name="sourceTemplate">Source Template</param>
3022+ <returns>
3023+ True if added, false if rejected for some
3024+ reason (either parameters or permission settings)
3025+ </returns>
3026+ </member>
3027+ <member name="M:NVelocity.Runtime.IRuntimeServices.IsVelocimacro(System.String,System.String)">
3028+ <summary>
3029+ Checks to see if a VM exists
3030+ </summary>
3031+ <param name="vmName">Name of velocimacro</param>
3032+ <param name="templateName">Template Name</param>
3033+ <returns>True if VM by that name exists, false if not</returns>
3034+ </member>
3035+ <member name="M:NVelocity.Runtime.IRuntimeServices.DumpVMNamespace(System.String)">
3036+ <summary> tells the vmFactory to dump the specified namespace. This is to support
3037+ clearing the VM list when in inline-VM-local-scope mode
3038+ </summary>
3039+ </member>
3040+ <member name="M:NVelocity.Runtime.IRuntimeServices.GetString(System.String)">
3041+ <summary>
3042+ String property accessor method to hide the configuration implementation.
3043+ </summary>
3044+ <param name="key">property key</param>
3045+ <returns>value</returns>
3046+ </member>
3047+ <member name="M:NVelocity.Runtime.IRuntimeServices.GetInt(System.String)">
3048+ <summary>
3049+ Int property accessor method to hide the configuration implementation.
3050+ </summary>
3051+ <param name="key">property key</param>
3052+ <returns>value</returns>
3053+ </member>
3054+ <member name="M:NVelocity.Runtime.IRuntimeServices.GetInt(System.String,System.Int32)">
3055+ <summary>
3056+ Int property accessor method to hide the configuration implementation.
3057+ </summary>
3058+ <param name="key">property key</param>
3059+ <param name="defaultValue">default value</param>
3060+ <returns>value</returns>
3061+ </member>
3062+ <member name="M:NVelocity.Runtime.IRuntimeServices.GetBoolean(System.String,System.Boolean)">
3063+ <summary>
3064+ Boolean property accessor method to hide the configuration implementation.
3065+ </summary>
3066+ <param name="key">property key</param>
3067+ <param name="def">default value</param>
3068+ <returns>value</returns>
3069+ </member>
3070+ <member name="M:NVelocity.Runtime.IRuntimeServices.GetApplicationAttribute(System.Object)">
3071+ <summary>
3072+ Return the specified application attribute
3073+ </summary>
3074+ <param name="key"></param>
3075+ <returns></returns>
3076+ </member>
3077+ <member name="M:NVelocity.Runtime.IRuntimeServices.SetApplicationAttribute(System.Object,System.Object)">
3078+ <summary>
3079+ Sets the specified application attribute.
3080+ </summary>
3081+ <param name="key"></param>
3082+ <param name="value"></param>
3083+ </member>
3084+ <member name="P:NVelocity.Runtime.IRuntimeServices.Configuration">
3085+ Return the velocity runtime configuration object.
3086+
3087+ @return ExtendedProperties configuration object which houses
3088+ the velocity runtime properties.
3089+ </member>
3090+ <member name="P:NVelocity.Runtime.IRuntimeServices.Uberspect">
3091+ Returns the configured class introspection/reflection
3092+ implementation.
3093+ </member>
3094+ <member name="P:NVelocity.Runtime.IRuntimeServices.Introspector">
3095+ Returns the configured method introspection/reflection
3096+ implementation.
3097+ </member>
3098+ <member name="F:NVelocity.Runtime.Log.LogLevel.Debug">
3099+ <summary>
3100+ Prefix for debug messages.
3101+ </summary>
3102+ </member>
3103+ <member name="F:NVelocity.Runtime.Log.LogLevel.Info">
3104+ <summary>
3105+ Prefix for info messages.
3106+ </summary>
3107+ </member>
3108+ <member name="F:NVelocity.Runtime.Log.LogLevel.Warn">
3109+ <summary>
3110+ Prefix for warning messages.
3111+ </summary>
3112+ </member>
3113+ <member name="F:NVelocity.Runtime.Log.LogLevel.Error">
3114+ <summary>
3115+ Prefix for error messages.
3116+ </summary>
3117+ </member>
3118+ <member name="T:NVelocity.Runtime.Log.ILogSystem">
3119+ <summary>
3120+ Base interface that Logging systems need to implement.
3121+ </summary>
3122+ <author> <a href="mailto:jon@latchkey.com">Jon S. Stevens</a></author>
3123+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a></author>
3124+ </member>
3125+ <member name="M:NVelocity.Runtime.Log.ILogSystem.Init(NVelocity.Runtime.IRuntimeServices)">
3126+ <summary>
3127+ init()
3128+ </summary>
3129+ </member>
3130+ <member name="M:NVelocity.Runtime.Log.ILogSystem.LogVelocityMessage(NVelocity.Runtime.Log.LogLevel,System.String)">
3131+ <summary>
3132+ Send a log message from Velocity.
3133+ </summary>
3134+ </member>
3135+ <member name="T:NVelocity.Runtime.Log.LogManager">
3136+ <summary>
3137+ <p>
3138+ This class is responsible for instantiating the correct LoggingSystem
3139+ </p>
3140+ <p>
3141+ The approach is :
3142+ </p>
3143+ <ul>
3144+ <li>
3145+ First try to see if the user is passing in a living object
3146+ that is a LogSystem, allowing the app to give is living
3147+ custom loggers.
3148+ </li>
3149+ <li>
3150+ Next, run through the (possible) list of classes specified
3151+ specified as loggers, taking the first one that appears to
3152+ work. This is how we support finding either log4j or
3153+ logkit, whichever is in the classpath, as both are
3154+ listed as defaults.
3155+ </li>
3156+ <li>
3157+ Finally, we turn to 'faith-based' logging, and hope that
3158+ logkit is in the classpath, and try for an AvalonLogSystem
3159+ as a final gasp. After that, there is nothing we can do.
3160+ </li>
3161+ </ul>
3162+ </summary>
3163+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a></author>
3164+ <author> <a href="mailto:jon@latchkey.com">Jon S. Stevens</a></author>
3165+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a></author>
3166+ </member>
3167+ <member name="M:NVelocity.Runtime.Log.LogManager.CreateLogSystem(NVelocity.Runtime.IRuntimeServices)">
3168+ <summary> Creates a new logging system or returns an existing one
3169+ specified by the application.
3170+ </summary>
3171+ </member>
3172+ <member name="T:NVelocity.Runtime.Log.NullLogSystem">
3173+ <summary> Logger used in case of failure. Does nothing.
3174+ *
3175+ </summary>
3176+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
3177+ </author>
3178+ <version> $Id: NullLogSystem.cs,v 1.4 2003/10/27 13:54:10 corts Exp $
3179+
3180+ </version>
3181+ </member>
3182+ <member name="M:NVelocity.Runtime.Log.NullLogSystem.LogVelocityMessage(NVelocity.Runtime.Log.LogLevel,System.String)">
3183+ <summary>
3184+ logs messages to the great Garbage Collector in the sky
3185+ </summary>
3186+ <param name="level">severity level</param>
3187+ <param name="message">complete error message</param>
3188+ </member>
3189+ <member name="T:NVelocity.Runtime.Parser.ICharStream">
3190+ <summary>
3191+ This interface describes a character stream that maintains line and
3192+ column number positions of the characters. It also has the capability
3193+ to backup the stream to some extent. An implementation of this
3194+ interface is used in the TokenManager implementation generated by
3195+ JavaCCParser.
3196+
3197+ All the methods except backup can be implemented in any fashion. backup
3198+ needs to be implemented correctly for the correct operation of the lexer.
3199+ Rest of the methods are all used to get information like line number,
3200+ column number and the String that constitutes a token and are not used
3201+ by the lexer. Hence their implementation won't affect the generated lexer's
3202+ operation.
3203+ </summary>
3204+ </member>
3205+ <member name="M:NVelocity.Runtime.Parser.ICharStream.ReadChar">
3206+ <summary> Returns the next character from the selected input. The method
3207+ of selecting the input is the responsibility of the class
3208+ implementing this interface. Can throw any java.io.IOException.
3209+ </summary>
3210+ </member>
3211+ <member name="M:NVelocity.Runtime.Parser.ICharStream.Backup(System.Int32)">
3212+ <summary> Backs up the input stream by amount steps. Lexer calls this method if it
3213+ had already read some characters, but could not use them to match a
3214+ (longer) token. So, they will be used again as the prefix of the next
3215+ token and it is the implemetation's responsibility to do this right.
3216+ </summary>
3217+ </member>
3218+ <member name="M:NVelocity.Runtime.Parser.ICharStream.BeginToken">
3219+ <summary> Returns the next character that marks the beginning of the next token.
3220+ All characters must remain in the buffer between two successive calls
3221+ to this method to implement backup correctly.
3222+ </summary>
3223+ </member>
3224+ <member name="M:NVelocity.Runtime.Parser.ICharStream.GetImage">
3225+ <summary> Returns a string made up of characters from the marked token beginning
3226+ to the current buffer position. Implementations have the choice of returning
3227+ anything that they want to. For example, for efficiency, one might decide
3228+ to just return null, which is a valid implementation.
3229+ </summary>
3230+ </member>
3231+ <member name="M:NVelocity.Runtime.Parser.ICharStream.GetSuffix(System.Int32)">
3232+ <summary>
3233+ Returns an array of characters that make up the suffix of length 'len' for
3234+ the currently matched token. This is used to build up the matched string
3235+ for use in actions in the case of MORE. A simple and inefficient
3236+ implementation of this is as follows :
3237+
3238+ {
3239+ String t = GetImage();
3240+ return t.substring(t.length() - len, t.length()).toCharArray();
3241+ }
3242+ </summary>
3243+ </member>
3244+ <member name="M:NVelocity.Runtime.Parser.ICharStream.Done">
3245+ <summary> The lexer calls this function to indicate that it is done with the stream
3246+ and hence implementations can free any resources held by this class.
3247+ Again, the body of this function can be just empty and it will not
3248+ affect the lexer's operation.
3249+ </summary>
3250+ </member>
3251+ <member name="P:NVelocity.Runtime.Parser.ICharStream.CurrentCharacter">
3252+ <summary>
3253+ The currenct character.
3254+ </summary>
3255+ </member>
3256+ <member name="P:NVelocity.Runtime.Parser.ICharStream.Column">
3257+ <summary>
3258+ Gets the column.
3259+ </summary>
3260+ <value>The column.</value>
3261+ </member>
3262+ <member name="P:NVelocity.Runtime.Parser.ICharStream.Line">
3263+ <summary>
3264+ Gets the line.
3265+ </summary>
3266+ <value>The line.</value>
3267+ </member>
3268+ <member name="P:NVelocity.Runtime.Parser.ICharStream.EndColumn">
3269+ <summary>
3270+ Gets the end column.
3271+ </summary>
3272+ <value>The end column.</value>
3273+ </member>
3274+ <member name="P:NVelocity.Runtime.Parser.ICharStream.EndLine">
3275+ <summary>
3276+ Gets the end line.
3277+ </summary>
3278+ <value>The end line.</value>
3279+ </member>
3280+ <member name="P:NVelocity.Runtime.Parser.ICharStream.BeginColumn">
3281+ <summary>
3282+ Gets the begin column.
3283+ </summary>
3284+ <value>The begin column.</value>
3285+ </member>
3286+ <member name="P:NVelocity.Runtime.Parser.ICharStream.BeginLine">
3287+ <summary>
3288+ Gets the begin line.
3289+ </summary>
3290+ <value>The begin line.</value>
3291+ </member>
3292+ <member name="T:NVelocity.Runtime.Parser.Node.AbstractExecutor">
3293+ <summary>
3294+ Abstract class that is used to execute an arbitrary
3295+ method that is in introspected. This is the superclass
3296+ for the GetExecutor and PropertyExecutor.
3297+ </summary>
3298+ </member>
3299+ <member name="F:NVelocity.Runtime.Parser.Node.AbstractExecutor.method">
3300+ <summary>
3301+ Method to be executed.
3302+ </summary>
3303+ </member>
3304+ <member name="F:NVelocity.Runtime.Parser.Node.AbstractExecutor.value">
3305+ <summary>
3306+ Value (probably from enum).
3307+ </summary>
3308+ </member>
3309+ <member name="M:NVelocity.Runtime.Parser.Node.AbstractExecutor.Execute(System.Object)">
3310+ <summary>
3311+ Execute method against context.
3312+ </summary>
3313+ </member>
3314+ <member name="T:NVelocity.Runtime.Parser.Node.ASTAddNode">
3315+ <summary>
3316+ Handles integer addition of nodes
3317+
3318+ Please look at the Parser.jjt file which is
3319+ what controls the generation of this class.
3320+ </summary>
3321+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a> </author>
3322+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a> </author>
3323+ <version> $Id: ASTAddNode.cs,v 1.3 2003/10/27 13:54:10 corts Exp $ </version>
3324+ </member>
3325+ <member name="T:NVelocity.Runtime.Parser.Node.INode">
3326+ <summary> All AST nodes must implement this interface. It provides basic
3327+ machinery for constructing the parent and child relationships
3328+ between nodes.
3329+ </summary>
3330+ </member>
3331+ <member name="M:NVelocity.Runtime.Parser.Node.INode.Open">
3332+ <summary>
3333+ This method is called after the node has been made the current
3334+ node. It indicates that child nodes can now be added to it.
3335+ </summary>
3336+ </member>
3337+ <member name="M:NVelocity.Runtime.Parser.Node.INode.Close">
3338+ <summary>
3339+ This method is called after all the child nodes have been added.
3340+ </summary>
3341+ </member>
3342+ <member name="M:NVelocity.Runtime.Parser.Node.INode.AddChild(NVelocity.Runtime.Parser.Node.INode,System.Int32)">
3343+ <summary>
3344+ This method tells the node to add its argument to the node's
3345+ list of children.
3346+ </summary>
3347+ </member>
3348+ <member name="M:NVelocity.Runtime.Parser.Node.INode.GetChild(System.Int32)">
3349+ <summary>
3350+ This method returns a child node. The children are numbered
3351+ from zero, left to right.
3352+ </summary>
3353+ </member>
3354+ <member name="M:NVelocity.Runtime.Parser.Node.INode.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3355+ <summary>
3356+ Accept the visitor.
3357+ </summary>
3358+ </member>
3359+ <member name="M:NVelocity.Runtime.Parser.Node.SimpleNode.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3360+ <summary>Accept the visitor. *
3361+ </summary>
3362+ </member>
3363+ <member name="M:NVelocity.Runtime.Parser.Node.SimpleNode.ChildrenAccept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3364+ <summary>Accept the visitor. *
3365+ </summary>
3366+ </member>
3367+ <member name="M:NVelocity.Runtime.Parser.Node.ASTAddNode.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3368+ <summary>
3369+ Accept the visitor.
3370+ </summary>
3371+ </member>
3372+ <member name="M:NVelocity.Runtime.Parser.Node.ASTAddNode.Value(NVelocity.Context.IInternalContextAdapter)">
3373+ <summary>
3374+ Computes the sum of the two nodes.
3375+ Currently only integer operations are supported.
3376+ </summary>
3377+ <returns>Integer object with value, or null</returns>
3378+ </member>
3379+ <member name="T:NVelocity.Runtime.Parser.Node.ASTAndNode">
3380+ <summary>
3381+ Please look at the Parser.jjt file which is
3382+ what controls the generation of this class.
3383+ </summary>
3384+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a> </author>
3385+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a> </author>
3386+ <version> $Id: ASTAndNode.cs,v 1.3 2003/10/27 13:54:10 corts Exp $ </version>
3387+ </member>
3388+ <member name="M:NVelocity.Runtime.Parser.Node.ASTAndNode.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3389+ <summary>
3390+ Accept the visitor.
3391+ </summary>
3392+ </member>
3393+ <member name="M:NVelocity.Runtime.Parser.Node.ASTAndNode.Value(NVelocity.Context.IInternalContextAdapter)">
3394+ <summary> Returns the value of the expression.
3395+ Since the value of the expression is simply the boolean
3396+ result of evaluate(), lets return that.
3397+ </summary>
3398+ </member>
3399+ <member name="M:NVelocity.Runtime.Parser.Node.ASTAndNode.Evaluate(NVelocity.Context.IInternalContextAdapter)">
3400+ <summary>
3401+ logical and :
3402+ null &amp;&amp; right = false
3403+ left &amp;&amp; null = false
3404+ null &amp;&amp; null = false
3405+ </summary>
3406+ </member>
3407+ <member name="M:NVelocity.Runtime.Parser.Node.ASTAssignment.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3408+ <summary>
3409+ Accept the visitor.
3410+ </summary>
3411+ </member>
3412+ <member name="M:NVelocity.Runtime.Parser.Node.ASTBlock.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3413+ <summary>
3414+ Accept the visitor.
3415+ </summary>
3416+ </member>
3417+ <member name="M:NVelocity.Runtime.Parser.Node.ASTComment.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3418+ <summary>
3419+ Accept the visitor.
3420+ </summary>
3421+ </member>
3422+ <member name="T:NVelocity.Runtime.Parser.Node.ASTDirective">
3423+ <summary>
3424+ This class is responsible for handling the pluggable
3425+ directives in VTL. ex. #foreach()
3426+
3427+ Please look at the Parser.jjt file which is
3428+ what controls the generation of this class.
3429+ </summary>
3430+ </member>
3431+ <member name="M:NVelocity.Runtime.Parser.Node.ASTDirective.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3432+ <summary>
3433+ Accept the visitor.
3434+ </summary>
3435+ </member>
3436+ <member name="P:NVelocity.Runtime.Parser.Node.ASTDirective.DirectiveName">
3437+ <summary>
3438+ Gets or sets the directive name.
3439+ Used by the parser.
3440+ This keeps us from having to
3441+ dig it out of the token stream and gives the parse
3442+ the change to override.
3443+ </summary>
3444+ </member>
3445+ <member name="T:NVelocity.Runtime.Parser.Node.ASTDivNode">
3446+ <summary>
3447+ Handles integer division of nodes
3448+
3449+ Please look at the Parser.jjt file which is
3450+ what controls the generation of this class.
3451+ </summary>
3452+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a> </author>
3453+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a> </author>
3454+ <version> $Id: ASTDivNode.cs,v 1.3 2003/10/27 13:54:10 corts Exp $ </version>
3455+ </member>
3456+ <member name="M:NVelocity.Runtime.Parser.Node.ASTDivNode.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3457+ <summary>
3458+ Accept the visitor.
3459+ </summary>
3460+ </member>
3461+ <member name="M:NVelocity.Runtime.Parser.Node.ASTDivNode.Value(NVelocity.Context.IInternalContextAdapter)">
3462+ <summary>
3463+ Computes the result of the division. Currently limited to Integers.
3464+ </summary>
3465+ <returns>Integer(value) or null</returns>
3466+ </member>
3467+ <member name="T:NVelocity.Runtime.Parser.Node.ASTElseIfStatement">
3468+ <summary> This class is responsible for handling the ElseIf VTL control statement.
3469+
3470+ Please look at the Parser.jjt file which is
3471+ what controls the generation of this class.
3472+ *
3473+ </summary>
3474+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
3475+ </author>
3476+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
3477+ </author>
3478+ <version> $Id: ASTElseIfStatement.cs,v 1.3 2003/10/27 13:54:10 corts Exp $
3479+ </version>
3480+ </member>
3481+ <member name="M:NVelocity.Runtime.Parser.Node.ASTElseIfStatement.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3482+ <summary>
3483+ Accept the visitor.
3484+ </summary>
3485+ </member>
3486+ <member name="M:NVelocity.Runtime.Parser.Node.ASTElseIfStatement.Evaluate(NVelocity.Context.IInternalContextAdapter)">
3487+ <summary>
3488+ An ASTElseStatement is true if the expression
3489+ it contains evaluates to true. Expressions know
3490+ how to evaluate themselves, so we do that
3491+ here and return the value back to ASTIfStatement
3492+ where this node was originally asked to evaluate
3493+ itself.
3494+ </summary>
3495+ </member>
3496+ <member name="M:NVelocity.Runtime.Parser.Node.ASTElseIfStatement.Render(NVelocity.Context.IInternalContextAdapter,System.IO.TextWriter)">
3497+ <summary>
3498+ renders the block
3499+ </summary>
3500+ </member>
3501+ <member name="T:NVelocity.Runtime.Parser.Node.ASTElseStatement">
3502+ <summary>
3503+ This class is responsible for handling the Else VTL control statement.
3504+
3505+ Please look at the Parser.jjt file which is
3506+ what controls the generation of this class.
3507+ </summary>
3508+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a> </author>
3509+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a> </author>
3510+ <version> $Id: ASTElseStatement.cs,v 1.3 2003/10/27 13:54:10 corts Exp $ </version>
3511+ </member>
3512+ <member name="M:NVelocity.Runtime.Parser.Node.ASTElseStatement.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3513+ <summary>
3514+ Accept the visitor.
3515+ </summary>
3516+ </member>
3517+ <member name="M:NVelocity.Runtime.Parser.Node.ASTElseStatement.Evaluate(NVelocity.Context.IInternalContextAdapter)">
3518+ <summary>
3519+ An ASTElseStatement always evaluates to
3520+ true. Basically behaves like an #if(true).
3521+ </summary>
3522+ </member>
3523+ <member name="T:NVelocity.Runtime.Parser.Node.ASTEQNode">
3524+ <summary>
3525+ Handles the equivalence operator
3526+
3527+ &lt;arg1&gt; == &lt;arg2&gt;
3528+
3529+ This operator requires that the LHS and RHS are both of the
3530+ same Class.
3531+ </summary>
3532+ <version> $Id: ASTEQNode.cs,v 1.3 2003/10/27 13:54:10 corts Exp $ </version>
3533+ </member>
3534+ <member name="M:NVelocity.Runtime.Parser.Node.ASTEQNode.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3535+ <summary>Accept the visitor. *
3536+ </summary>
3537+ </member>
3538+ <member name="M:NVelocity.Runtime.Parser.Node.ASTEQNode.Evaluate(NVelocity.Context.IInternalContextAdapter)">
3539+ <summary>
3540+ Calculates the value of the logical expression
3541+
3542+ arg1 == arg2
3543+
3544+ All class types are supported. Uses equals() to
3545+ determine equivalence. This should work as we represent
3546+ with the types we already support, and anything else that
3547+ implements equals() to mean more than identical references.
3548+ </summary>
3549+ <param name="context"> internal context used to evaluate the LHS and RHS </param>
3550+ <returns>
3551+ true if equivalent, false if not equivalent,
3552+ false if not compatible arguments, or false
3553+ if either LHS or RHS is null
3554+ </returns>
3555+ </member>
3556+ <member name="T:NVelocity.Runtime.Parser.Node.ASTEscape">
3557+ <summary> This class is responsible for handling Escapes
3558+ in VTL.
3559+
3560+ Please look at the Parser.jjt file which is
3561+ what controls the generation of this class.
3562+ *
3563+ </summary>
3564+ </member>
3565+ <member name="M:NVelocity.Runtime.Parser.Node.ASTEscape.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3566+ <summary>Accept the visitor. *
3567+ </summary>
3568+ </member>
3569+ <member name="T:NVelocity.Runtime.Parser.Node.ASTEscapedDirective">
3570+ <summary>
3571+ This class is responsible for handling EscapedDirectives
3572+ in VTL.
3573+
3574+ Please look at the Parser.jjt file which is
3575+ what controls the generation of this class.
3576+ </summary>
3577+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a> </author>
3578+ <version> $Id: ASTEscapedDirective.cs,v 1.3 2003/10/27 13:54:10 corts Exp $ </version>
3579+ </member>
3580+ <member name="M:NVelocity.Runtime.Parser.Node.ASTEscapedDirective.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3581+ <summary>
3582+ Accept the visitor.
3583+ </summary>
3584+ </member>
3585+ <member name="M:NVelocity.Runtime.Parser.Node.ASTExpression.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3586+ <summary>
3587+ Accept the visitor.
3588+ </summary>
3589+ </member>
3590+ <member name="M:NVelocity.Runtime.Parser.Node.ASTFalse.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3591+ <summary>
3592+ Accept the visitor.
3593+ </summary>
3594+ </member>
3595+ <member name="M:NVelocity.Runtime.Parser.Node.ASTGENode.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3596+ <summary>
3597+ Accept the visitor.
3598+ </summary>
3599+ </member>
3600+ <member name="M:NVelocity.Runtime.Parser.Node.ASTGTNode.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3601+ <summary>
3602+ Accept the visitor.
3603+ </summary>
3604+ </member>
3605+ <member name="T:NVelocity.Runtime.Parser.Node.ASTIdentifier">
3606+ <summary>
3607+ ASTIdentifier.java
3608+
3609+ Method support for identifiers : $foo
3610+
3611+ mainly used by ASTReference
3612+
3613+ Introspection is now moved to 'just in time' or at render / execution
3614+ time. There are many reasons why this has to be done, but the
3615+ primary two are thread safety, to remove any context-derived
3616+ information from class member variables.
3617+ </summary>
3618+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a> </author>
3619+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a> </author>
3620+ <version> $Id: ASTIdentifier.cs,v 1.5 2004/12/27 05:55:30 corts Exp $ </version>
3621+ </member>
3622+ <member name="M:NVelocity.Runtime.Parser.Node.ASTIdentifier.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3623+ <summary>
3624+ Accept the visitor.
3625+ </summary>
3626+ </member>
3627+ <member name="M:NVelocity.Runtime.Parser.Node.ASTIdentifier.Init(NVelocity.Context.IInternalContextAdapter,System.Object)">
3628+ <summary>
3629+ simple init - don't do anything that is context specific.
3630+ just get what we need from the AST, which is static.
3631+ </summary>
3632+ </member>
3633+ <member name="M:NVelocity.Runtime.Parser.Node.ASTIdentifier.Execute(System.Object,NVelocity.Context.IInternalContextAdapter)">
3634+ <summary>
3635+ invokes the method on the object passed in
3636+ </summary>
3637+ </member>
3638+ <member name="M:NVelocity.Runtime.Parser.Node.ASTIfStatement.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3639+ <summary>
3640+ Accept the visitor.
3641+ </summary>
3642+ </member>
3643+ <member name="M:NVelocity.Runtime.Parser.Node.ASTIncludeStatement.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3644+ <summary>Accept the visitor.
3645+ </summary>
3646+ </member>
3647+ <member name="M:NVelocity.Runtime.Parser.Node.ASTIntegerRange.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3648+ <summary>
3649+ Accept the visitor.
3650+ </summary>
3651+ </member>
3652+ <member name="M:NVelocity.Runtime.Parser.Node.ASTIntegerRange.Value(NVelocity.Context.IInternalContextAdapter)">
3653+ <summary>
3654+ does the real work. Creates an Vector of Integers with the
3655+ right value range
3656+ </summary>
3657+ <param name="context">app context used if Left or Right of .. is a ref</param>
3658+ <returns>Object array of Integers</returns>
3659+ </member>
3660+ <member name="M:NVelocity.Runtime.Parser.Node.ASTLENode.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3661+ <summary>Accept the visitor. *
3662+ </summary>
3663+ </member>
3664+ <member name="M:NVelocity.Runtime.Parser.Node.ASTLTNode.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3665+ <summary>
3666+ Accept the visitor.
3667+ </summary>
3668+ </member>
3669+ <member name="T:NVelocity.Runtime.Parser.Node.ASTMap">
3670+ <summary>
3671+ AST Node for creating a map / dictionary.
3672+ This class was originally generated from Parset.jjt.
3673+ </summary>
3674+ <version>$Id: ASTMap.cs,v 1.2 2004/12/27 05:50:11 corts Exp $</version>
3675+ </member>
3676+ <member name="M:NVelocity.Runtime.Parser.Node.ASTMap.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3677+ <summary>
3678+ Accept the visitor.
3679+ </summary>
3680+ </member>
3681+ <member name="M:NVelocity.Runtime.Parser.Node.ASTMap.Value(NVelocity.Context.IInternalContextAdapter)">
3682+ <summary>
3683+ Evaluate the node.
3684+ </summary>
3685+ </member>
3686+ <member name="T:NVelocity.Runtime.Parser.Node.ASTMethod">
3687+ <summary>
3688+ Method support for references : $foo.method()
3689+
3690+ NOTE :
3691+
3692+ introspection is now done at render time.
3693+
3694+ Please look at the Parser.jjt file which is
3695+ what controls the generation of this class.
3696+ </summary>
3697+ </member>
3698+ <member name="M:NVelocity.Runtime.Parser.Node.ASTMethod.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3699+ <summary>
3700+ Accept the visitor.
3701+ </summary>
3702+ </member>
3703+ <member name="M:NVelocity.Runtime.Parser.Node.ASTMethod.Init(NVelocity.Context.IInternalContextAdapter,System.Object)">
3704+ <summary>
3705+ simple init - init our subtree and get what we can from
3706+ the AST
3707+ </summary>
3708+ </member>
3709+ <member name="M:NVelocity.Runtime.Parser.Node.ASTMethod.Execute(System.Object,NVelocity.Context.IInternalContextAdapter)">
3710+ <summary>
3711+ invokes the method. Returns null if a problem, the
3712+ actual return if the method returns something, or
3713+ an empty string "" if the method returns void
3714+ </summary>
3715+ </member>
3716+ <member name="M:NVelocity.Runtime.Parser.Node.ASTMethod.PerformIntrospection(NVelocity.Context.IInternalContextAdapter,System.Type,System.Object[])">
3717+ <summary>
3718+ does the introspection of the class for the method needed.
3719+
3720+ NOTE: this will try to flip the case of the first character for
3721+ convince (compatibility with Java version). If there are no arguments,
3722+ it will also try to find a property with the same name (also flipping first character).
3723+ </summary>
3724+ </member>
3725+ <member name="M:NVelocity.Runtime.Parser.Node.ASTModNode.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3726+ <summary>
3727+ Accept the visitor.
3728+ </summary>
3729+ </member>
3730+ <member name="T:NVelocity.Runtime.Parser.Node.ASTMulNode">
3731+ <summary>
3732+ Handles integer multiplication
3733+
3734+ Please look at the Parser.jjt file which is
3735+ what controls the generation of this class.
3736+ </summary>
3737+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a> </author>
3738+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a> </author>
3739+ <version> $Id: ASTMulNode.cs,v 1.3 2003/10/27 13:54:10 corts Exp $ </version>
3740+ </member>
3741+ <member name="M:NVelocity.Runtime.Parser.Node.ASTMulNode.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3742+ <summary>Accept the visitor. *
3743+ </summary>
3744+ </member>
3745+ <member name="M:NVelocity.Runtime.Parser.Node.ASTMulNode.Value(NVelocity.Context.IInternalContextAdapter)">
3746+ <summary>
3747+ Computes the product of the two args.
3748+ Returns null if either arg is null
3749+ or if either arg is not an integer
3750+ </summary>
3751+ </member>
3752+ <member name="M:NVelocity.Runtime.Parser.Node.ASTNENode.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3753+ <summary>
3754+ Accept the visitor.
3755+ </summary>
3756+ </member>
3757+ <member name="M:NVelocity.Runtime.Parser.Node.ASTNotNode.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3758+ <summary>
3759+ Accept the visitor.
3760+ </summary>
3761+ </member>
3762+ <member name="M:NVelocity.Runtime.Parser.Node.ASTNumberLiteral.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3763+ <summary>Accept the visitor. *
3764+ </summary>
3765+ </member>
3766+ <member name="M:NVelocity.Runtime.Parser.Node.ASTNumberLiteral.Init(NVelocity.Context.IInternalContextAdapter,System.Object)">
3767+ <summary> Initialization method - doesn't do much but do the object
3768+ creation. We only need to do it once.
3769+ </summary>
3770+ </member>
3771+ <member name="M:NVelocity.Runtime.Parser.Node.ASTObjectArray.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3772+ <summary>
3773+ Accept the visitor.
3774+ </summary>
3775+ </member>
3776+ <member name="T:NVelocity.Runtime.Parser.Node.ASTOrNode">
3777+ <summary>
3778+ Please look at the Parser.jjt file which is what controls
3779+ the generation of this class.
3780+ </summary>
3781+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a> </author>
3782+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a> </author>
3783+ <version> $Id: ASTOrNode.cs,v 1.3 2003/10/27 13:54:10 corts Exp $ </version>
3784+ </member>
3785+ <member name="M:NVelocity.Runtime.Parser.Node.ASTOrNode.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3786+ <summary>Accept the visitor. *
3787+ </summary>
3788+ </member>
3789+ <member name="M:NVelocity.Runtime.Parser.Node.ASTOrNode.Value(NVelocity.Context.IInternalContextAdapter)">
3790+ <summary> Returns the value of the expression.
3791+ Since the value of the expression is simply the boolean
3792+ result of evaluate(), lets return that.
3793+ </summary>
3794+ </member>
3795+ <member name="M:NVelocity.Runtime.Parser.Node.ASTOrNode.Evaluate(NVelocity.Context.IInternalContextAdapter)">
3796+ <summary>
3797+ the logical or :
3798+ the rule :
3799+ left || null -> left
3800+ null || right -> right
3801+ null || null -> false
3802+ left || right -> left || right
3803+ </summary>
3804+ </member>
3805+ <member name="M:NVelocity.Runtime.Parser.Node.ASTParameters.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3806+ <summary>
3807+ Accept the visitor.
3808+ </summary>
3809+ </member>
3810+ <member name="M:NVelocity.Runtime.Parser.Node.ASTprocess.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3811+ <summary>Accept the visitor. *
3812+ </summary>
3813+ </member>
3814+ <member name="T:NVelocity.Runtime.Parser.Node.ReferenceType">
3815+ <summary>
3816+ Reference types
3817+ </summary>
3818+ </member>
3819+ <member name="T:NVelocity.Runtime.Parser.Node.ASTReference">
3820+ <summary>
3821+ This class is responsible for handling the references in
3822+ VTL ($foo).
3823+
3824+ Please look at the Parser.jjt file which is
3825+ what controls the generation of this class.
3826+ </summary>
3827+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a></author>
3828+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a></author>
3829+ <author> <a href="mailto:Christoph.Reck@dlr.de">Christoph Reck</a></author>
3830+ <author> <a href="mailto:kjohnson@transparent.com">Kent Johnson</a></author>
3831+ <version> $Id: ASTReference.cs,v 1.4 2003/10/27 13:54:10 corts Exp $ </version>
3832+ </member>
3833+ <member name="M:NVelocity.Runtime.Parser.Node.ASTReference.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3834+ <summary>Accept the visitor.</summary>
3835+ </member>
3836+ <member name="M:NVelocity.Runtime.Parser.Node.ASTReference.Execute(System.Object,NVelocity.Context.IInternalContextAdapter)">
3837+ <summary>
3838+ gets an Object that 'is' the value of the reference
3839+ </summary>
3840+ </member>
3841+ <member name="M:NVelocity.Runtime.Parser.Node.ASTReference.Render(NVelocity.Context.IInternalContextAdapter,System.IO.TextWriter)">
3842+ <summary>
3843+ gets the value of the reference and outputs it to the
3844+ writer.
3845+ </summary>
3846+ <param name="context"> context of data to use in getting value </param>
3847+ <param name="writer"> writer to render to </param>
3848+ </member>
3849+ <member name="M:NVelocity.Runtime.Parser.Node.ASTReference.Evaluate(NVelocity.Context.IInternalContextAdapter)">
3850+ <summary>
3851+ Computes boolean value of this reference
3852+ Returns the actual value of reference return type
3853+ boolean, and 'true' if value is not null
3854+ </summary>
3855+ <param name="context">context to compute value with</param>
3856+ </member>
3857+ <member name="M:NVelocity.Runtime.Parser.Node.ASTReference.SetValue(NVelocity.Context.IInternalContextAdapter,System.Object)">
3858+ <summary>
3859+ Sets the value of a complex reference (something like $foo.bar)
3860+ Currently used by ASTSetReference()
3861+ </summary>
3862+ <seealso cref="T:NVelocity.Runtime.Parser.Node.ASTSetDirective"/>
3863+ <param name="context">context object containing this reference</param>
3864+ <param name="value">Object to set as value</param>
3865+ <returns>true if successful, false otherwise</returns>
3866+ </member>
3867+ <member name="P:NVelocity.Runtime.Parser.Node.ASTReference.RootString">
3868+ <summary>
3869+ Returns the 'root string', the reference key
3870+ </summary>
3871+ </member>
3872+ <member name="T:NVelocity.Runtime.Parser.Node.ASTSetDirective">
3873+ <summary>
3874+ Node for the #set directive
3875+ </summary>
3876+ </member>
3877+ <member name="M:NVelocity.Runtime.Parser.Node.ASTSetDirective.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3878+ <summary>Accept the visitor. *
3879+ </summary>
3880+ </member>
3881+ <member name="M:NVelocity.Runtime.Parser.Node.ASTSetDirective.Init(NVelocity.Context.IInternalContextAdapter,System.Object)">
3882+ <summary> simple init. We can get the RHS and LHS as the the tree structure is static
3883+ </summary>
3884+ </member>
3885+ <member name="M:NVelocity.Runtime.Parser.Node.ASTSetDirective.Render(NVelocity.Context.IInternalContextAdapter,System.IO.TextWriter)">
3886+ <summary> puts the value of the RHS into the context under the key of the LHS
3887+ </summary>
3888+ </member>
3889+ <member name="T:NVelocity.Runtime.Parser.Node.ASTStringLiteral">
3890+ <summary>
3891+ ASTStringLiteral support.
3892+ </summary>
3893+ </member>
3894+ <member name="M:NVelocity.Runtime.Parser.Node.ASTStringLiteral.#ctor(System.Int32)">
3895+ <summary>
3896+ Initializes a new instance of the <see cref="T:NVelocity.Runtime.Parser.Node.ASTStringLiteral"/> class.
3897+ </summary>
3898+ <param name="id">The id.</param>
3899+ </member>
3900+ <member name="M:NVelocity.Runtime.Parser.Node.ASTStringLiteral.#ctor(NVelocity.Runtime.Parser.Parser,System.Int32)">
3901+ <summary>
3902+ Initializes a new instance of the <see cref="T:NVelocity.Runtime.Parser.Node.ASTStringLiteral"/> class.
3903+ </summary>
3904+ <param name="p">The p.</param>
3905+ <param name="id">The id.</param>
3906+ </member>
3907+ <member name="M:NVelocity.Runtime.Parser.Node.ASTStringLiteral.Init(NVelocity.Context.IInternalContextAdapter,System.Object)">
3908+ <summary> init : we don't have to do much. Init the tree (there
3909+ shouldn't be one) and then see if interpolation is turned on.
3910+ </summary>
3911+ </member>
3912+ <member name="M:NVelocity.Runtime.Parser.Node.ASTStringLiteral.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3913+ <summary>Accept the visitor. *
3914+ </summary>
3915+ </member>
3916+ <member name="M:NVelocity.Runtime.Parser.Node.ASTStringLiteral.Value(NVelocity.Context.IInternalContextAdapter)">
3917+ <summary> renders the value of the string literal
3918+ If the properties allow, and the string literal contains a $ or a #
3919+ the literal is rendered against the context
3920+ Otherwise, the stringlit is returned.
3921+ </summary>
3922+ </member>
3923+ <member name="M:NVelocity.Runtime.Parser.Node.ASTStringLiteral.InterpolateDictionaryString(System.String,NVelocity.Context.IInternalContextAdapter)">
3924+ <summary>
3925+ Interpolates the dictionary string.
3926+ dictionary string is any string in the format
3927+ "%{ key='value' [,key2='value2' }"
3928+ "%{ key='value' [,key2='value2'] }"
3929+ </summary>
3930+ <param name="str">If valid input a HybridDictionary with zero or more items,
3931+ otherwise the input string</param>
3932+ <param name="context">NVelocity runtime context</param>
3933+ </member>
3934+ <member name="T:NVelocity.Runtime.Parser.Node.ASTSubtractNode">
3935+ <summary>
3936+ Handles integer subtraction of nodes (in #set() )
3937+
3938+ Please look at the Parser.jjt file which is
3939+ what controls the generation of this class.
3940+ </summary>
3941+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a> </author>
3942+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a> </author>
3943+ <version> $Id: ASTSubtractNode.cs,v 1.3 2003/10/27 13:54:10 corts Exp $ </version>
3944+ </member>
3945+ <member name="M:NVelocity.Runtime.Parser.Node.ASTSubtractNode.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3946+ <summary>
3947+ Accept the visitor.
3948+ </summary>
3949+ </member>
3950+ <member name="M:NVelocity.Runtime.Parser.Node.ASTSubtractNode.Value(NVelocity.Context.IInternalContextAdapter)">
3951+ <summary>
3952+ Computes the value of the subtraction.
3953+ Currently limited to integers.
3954+ </summary>
3955+ <returns>Integer(value) or null</returns>
3956+ </member>
3957+ <member name="M:NVelocity.Runtime.Parser.Node.ASTText.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3958+ <summary>
3959+ Accept the visitor.
3960+ </summary>
3961+ </member>
3962+ <member name="M:NVelocity.Runtime.Parser.Node.ASTTrue.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3963+ <summary>
3964+ Accept the visitor.
3965+ </summary>
3966+ </member>
3967+ <member name="M:NVelocity.Runtime.Parser.Node.ASTVariable.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3968+ <summary>
3969+ Accept the visitor.
3970+ </summary>
3971+ </member>
3972+ <member name="M:NVelocity.Runtime.Parser.Node.ASTWord.Accept(NVelocity.Runtime.Parser.Node.IParserVisitor,System.Object)">
3973+ <summary>
3974+ Accept the visitor.
3975+ </summary>
3976+ </member>
3977+ <member name="T:NVelocity.Runtime.Parser.Node.BooleanPropertyExecutor">
3978+ <summary> Handles discovery and valuation of a
3979+ boolean object property, of the
3980+ form public boolean is&lt;property&gt; when executed.
3981+
3982+ We do this separately as to preserve the current
3983+ quasi-broken semantics of get&lt;as is property&gt;
3984+ get&lt; flip 1st char&gt; get("property") and now followed
3985+ by is&lt;Property&gt;
3986+ </summary>
3987+ </member>
3988+ <member name="T:NVelocity.Runtime.Parser.Node.PropertyExecutor">
3989+ <summary>
3990+ Returned the value of object property when executed.
3991+ </summary>
3992+ </member>
3993+ <member name="M:NVelocity.Runtime.Parser.Node.PropertyExecutor.Execute(System.Object)">
3994+ <summary>
3995+ Execute property against context.
3996+ </summary>
3997+ </member>
3998+ <member name="T:NVelocity.Runtime.Parser.Node.EnumValueExecutor">
3999+ <summary>
4000+ Returned the value of object property when executed.
4001+ </summary>
4002+ </member>
4003+ <member name="M:NVelocity.Runtime.Parser.Node.EnumValueExecutor.Execute(System.Object)">
4004+ <summary>
4005+ Execute property against context.
4006+ </summary>
4007+ </member>
4008+ <member name="T:NVelocity.Runtime.Parser.Node.GetExecutor">
4009+ <summary>
4010+ Executor that simply tries to execute a get(key)
4011+ operation. This will try to find a get(key) method
4012+ for any type of object, not just objects that
4013+ implement the Map interface as was previously
4014+ the case.
4015+ </summary>
4016+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a></author>
4017+ <remarks>
4018+ Add discovery for .NET default property, using
4019+ <see cref="M:System.Type.GetDefaultMembers"/>.
4020+ </remarks>
4021+ </member>
4022+ <member name="F:NVelocity.Runtime.Parser.Node.GetExecutor.arguments">
4023+ <summary>
4024+ Container to hold the 'key' part of get(key).
4025+ </summary>
4026+ </member>
4027+ <member name="M:NVelocity.Runtime.Parser.Node.GetExecutor.#ctor(NVelocity.Runtime.IRuntimeLogger,NVelocity.Util.Introspection.Introspector,System.Type,System.String)">
4028+ <summary>
4029+ Default constructor.
4030+ </summary>
4031+ </member>
4032+ <member name="M:NVelocity.Runtime.Parser.Node.GetExecutor.Execute(System.Object)">
4033+ <summary>
4034+ Execute method against context.
4035+ </summary>
4036+ </member>
4037+ <member name="T:NVelocity.Runtime.Parser.Node.NodeUtils">
4038+ <summary> Utilities for dealing with the AST node structure.
4039+ *
4040+ </summary>
4041+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
4042+ </author>
4043+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
4044+ </author>
4045+ <version> $Id: NodeUtils.cs,v 1.4 2003/10/27 13:54:10 corts Exp $
4046+
4047+ </version>
4048+ </member>
4049+ <member name="M:NVelocity.Runtime.Parser.Node.NodeUtils.specialText(NVelocity.Runtime.Parser.Token)">
4050+ <summary> Collect all the &lt;SPECIAL_TOKEN&gt;s that
4051+ are carried along with a token. Special
4052+ tokens do not participate in parsing but
4053+ can still trigger certain lexical actions.
4054+ In some cases you may want to retrieve these
4055+ special tokens, this is simply a way to
4056+ extract them.
4057+ </summary>
4058+ </member>
4059+ <member name="M:NVelocity.Runtime.Parser.Node.NodeUtils.tokenLiteral(NVelocity.Runtime.Parser.Token)">
4060+ <summary> complete node literal
4061+ *
4062+ </summary>
4063+ </member>
4064+ <member name="M:NVelocity.Runtime.Parser.Node.NodeUtils.interpolate(System.String,NVelocity.Context.IContext)">
4065+ <summary> Utility method to interpolate context variables
4066+ into string literals. So that the following will
4067+ work:
4068+ *
4069+ #set $name = "candy"
4070+ $image.getURI("${name}.jpg")
4071+ *
4072+ And the string literal argument will
4073+ be transformed into "candy.jpg" before
4074+ the method is executed.
4075+ </summary>
4076+ </member>
4077+ <member name="T:NVelocity.Runtime.Parser.Node.ObjectComparer">
4078+ <summary>
4079+ ObjectComparer allows you to compare primitive types and some others
4080+ using IComparable interface whenever possible, and performing type
4081+ conversions to get the best possible result.
4082+ </summary>
4083+ </member>
4084+ <member name="M:NVelocity.Runtime.Parser.Node.ObjectComparer.CompareObjects(System.Object,System.Object)">
4085+ <summary>
4086+ Tries to compare two random objects. -1 is returned
4087+ if x is smaller than y, 1 the other way around, or 0
4088+ if they are equal.
4089+ </summary>
4090+ </member>
4091+ <member name="T:NVelocity.Runtime.Parser.ParseException">
4092+ <summary> This exception is thrown when parse errors are encountered.
4093+ You can explicitly create objects of this exception type by
4094+ calling the method generateParseException in the generated
4095+ parser.
4096+ *
4097+ You can modify this class to customize your error reporting
4098+ mechanisms so long as you retain the public fields.
4099+ </summary>
4100+ </member>
4101+ <member name="F:NVelocity.Runtime.Parser.ParseException.eol">
4102+ <summary> The end of line string for this machine.
4103+ </summary>
4104+ </member>
4105+ <member name="M:NVelocity.Runtime.Parser.ParseException.#ctor(NVelocity.Runtime.Parser.Token,System.Int32[][],System.String[])">
4106+ <summary> This constructor is used by the method "generateParseException"
4107+ in the generated parser. Calling this constructor generates
4108+ a new object of this type with the fields "currentToken",
4109+ "expectedTokenSequences", and "tokenImage" set. The boolean
4110+ flag "specialConstructor" is also set to true to indicate that
4111+ this constructor was used to create this object.
4112+ This constructor calls its super class with the empty string
4113+ to force the "toString" method of parent class "Throwable" to
4114+ print the error message in the form:
4115+ ParseException: &lt;result of getMessage&gt;
4116+ </summary>
4117+ </member>
4118+ <member name="M:NVelocity.Runtime.Parser.ParseException.#ctor">
4119+ <summary> The following constructors are for use by you for whatever
4120+ purpose you can think of. Constructing the exception in this
4121+ manner makes the exception behave in the normal way - i.e., as
4122+ documented in the class "Throwable". The fields "errorToken",
4123+ "expectedTokenSequences", and "tokenImage" do not contain
4124+ relevant information. The JavaCC generated code does not use
4125+ these constructors.
4126+ </summary>
4127+ </member>
4128+ <member name="F:NVelocity.Runtime.Parser.ParseException.specialConstructor">
4129+ <summary> This variable determines which constructor was used to create
4130+ this object and thereby affects the semantics of the
4131+ "getMessage" method (see below).
4132+ </summary>
4133+ </member>
4134+ <member name="F:NVelocity.Runtime.Parser.ParseException.currentToken">
4135+ <summary> This is the last token that has been consumed successfully. If
4136+ this object has been created due to a parse error, the token
4137+ following this token will (therefore) be the first error token.
4138+ </summary>
4139+ </member>
4140+ <member name="F:NVelocity.Runtime.Parser.ParseException.expectedTokenSequences">
4141+ <summary> Each entry in this array is an array of integers. Each array
4142+ of integers represents a sequence of tokens (by their ordinal
4143+ values) that is expected at this point of the parse.
4144+ </summary>
4145+ </member>
4146+ <member name="F:NVelocity.Runtime.Parser.ParseException.tokenImage">
4147+ <summary> This is a reference to the "tokenImage" array of the generated
4148+ parser within which the parse error occurred. This array is
4149+ defined in the generated ...Constants interface.
4150+ </summary>
4151+ </member>
4152+ <member name="M:NVelocity.Runtime.Parser.ParseException.AddEscapes(System.String)">
4153+ <summary> This method has the standard behavior when this object has been
4154+ created using the standard constructors. Otherwise, it uses
4155+ "currentToken" and "expectedTokenSequences" to generate a parse
4156+ error message and returns it. If this object has been created
4157+ due to a parse error, and you do not catch it (it gets thrown
4158+ from the parser), then this method is called during the printing
4159+ of the final stack trace, and hence the correct error message
4160+ gets displayed.
4161+ </summary>
4162+ <summary> Used to convert raw characters to their escaped version
4163+ when these raw version cannot be used as part of an ASCII
4164+ string literal.
4165+ </summary>
4166+ </member>
4167+ <member name="T:NVelocity.Runtime.Parser.Parser">
4168+ <summary> This class is responsible for parsing a Velocity
4169+ template. This class was generated by JavaCC using
4170+ the JJTree extension to produce an Abstract
4171+ Syntax Tree (AST) of the template.
4172+
4173+ Please look at the Parser.jjt file which is
4174+ what controls the generation of this class.
4175+ </summary>
4176+ </member>
4177+ <member name="F:NVelocity.Runtime.Parser.Parser.directives">
4178+ <summary> This Hashtable contains a list of all of the dynamic directives.
4179+ </summary>
4180+ </member>
4181+ <member name="F:NVelocity.Runtime.Parser.Parser.currentTemplateName">
4182+ <summary> Name of current template we are parsing. Passed to us in parse()
4183+ </summary>
4184+ </member>
4185+ <member name="M:NVelocity.Runtime.Parser.Parser.#ctor(NVelocity.Runtime.IRuntimeServices)">
4186+ <summary>
4187+ This constructor was added to allow the re-use of parsers.
4188+ The normal constructor takes a single argument which
4189+ an InputStream. This simply creates a re-usable parser
4190+ object, we satisfy the requirement of an InputStream
4191+ by using a newline character as an input stream.
4192+ </summary>
4193+ </member>
4194+ <member name="M:NVelocity.Runtime.Parser.Parser.Parse(System.IO.TextReader,System.String)">
4195+
4196+ <summary> This was also added to allow parsers to be
4197+ re-usable. Normal JavaCC use entails passing an
4198+ input stream to the constructor and the parsing
4199+ process is carried out once. We want to be able
4200+ to re-use parsers: we do this by adding this
4201+ method and re-initializing the lexer with
4202+ the new stream that we want parsed.
4203+ </summary>
4204+ </member>
4205+ <member name="M:NVelocity.Runtime.Parser.Parser.IsDirective(System.String)">
4206+ <summary> This method finds out of the directive exists in the directives
4207+ Hashtable.
4208+ </summary>
4209+ </member>
4210+ <member name="M:NVelocity.Runtime.Parser.Parser.EscapedDirective(System.String)">
4211+ <summary> Produces a processed output for an escaped control or
4212+ pluggable directive
4213+ </summary>
4214+ </member>
4215+ <member name="M:NVelocity.Runtime.Parser.Parser.Process">
4216+ <summary> This method is what starts the whole parsing
4217+ process. After the parsing is complete and
4218+ the template has been turned into an AST,
4219+ this method returns the root of AST which
4220+ can subsequently be traversed by a visitor
4221+ which implements the ParserVisitor interface
4222+ which is generated automatically by JavaCC
4223+ </summary>
4224+ </member>
4225+ <member name="M:NVelocity.Runtime.Parser.Parser.Statement">
4226+ <summary> These are the types of statements that
4227+ are acceptable in Velocity templates.
4228+ </summary>
4229+ </member>
4230+ <member name="M:NVelocity.Runtime.Parser.Parser.EscapedDirective">
4231+ <summary> used to separate the notion of a valid directive that has been
4232+ escaped, versus something that looks like a directive and
4233+ is just schmoo. This is important to do as a separate production
4234+ that creates a node, because we want this, in either case, to stop
4235+ the further parsing of the Directive() tree.
4236+ </summary>
4237+ </member>
4238+ <member name="M:NVelocity.Runtime.Parser.Parser.Escape">
4239+ <summary> Used to catch and process escape sequences in grammatical constructs
4240+ as escapes outside of VTL are just characters. Right now we have both
4241+ this and the EscapeDirective() construction because in the EscapeDirective()
4242+ case, we want to suck in the #&lt;directive&gt; and here we don't. We just want
4243+ the escapes to render correctly
4244+ </summary>
4245+ </member>
4246+ <member name="M:NVelocity.Runtime.Parser.Parser.Identifier">
4247+ <summary> This method corresponds to variable
4248+ references in Velocity templates.
4249+ The following are examples of variable
4250+ references that may be found in a
4251+ template:
4252+ *
4253+ $foo
4254+ $bar
4255+ *
4256+ </summary>
4257+ </member>
4258+ <member name="M:NVelocity.Runtime.Parser.Parser.DirectiveArg">
4259+ <summary> Supports the arguments for the Pluggable Directives
4260+ We add whitespace in here as a token so the VMs can
4261+ easily reconstruct a macro body from the token stream
4262+ See Directive()
4263+ </summary>
4264+ </member>
4265+ <member name="M:NVelocity.Runtime.Parser.Parser.Directive">
4266+ <summary> Supports the Pluggable Directives
4267+ #foo( arg+ )
4268+ </summary>
4269+ </member>
4270+ <member name="M:NVelocity.Runtime.Parser.Parser.IntegerRange">
4271+ <summary> supports the [n..m] vector generator for use in
4272+ the #foreach() to generate measured ranges w/o
4273+ needing explicit support from the app/servlet
4274+ </summary>
4275+ </member>
4276+ <member name="M:NVelocity.Runtime.Parser.Parser.Parameter">
4277+ <summary> This method has yet to be fully implemented
4278+ but will allow arbitrarily nested method
4279+ calls
4280+ </summary>
4281+ </member>
4282+ <member name="M:NVelocity.Runtime.Parser.Parser.Method">
4283+ <summary> This method has yet to be fully implemented
4284+ but will allow arbitrarily nested method
4285+ calls
4286+ </summary>
4287+ </member>
4288+ <member name="M:NVelocity.Runtime.Parser.Parser.Text">
4289+ <summary> This method is responsible for allowing
4290+ all non-grammar text to pass through
4291+ unscathed.
4292+ </summary>
4293+ </member>
4294+ <member name="M:NVelocity.Runtime.Parser.Parser.SetDirective">
4295+ <summary> Currently support both types of set :
4296+ #set( expr )
4297+ #set expr
4298+ </summary>
4299+ </member>
4300+ <member name="M:NVelocity.Runtime.Parser.Parser.StopStatement">
4301+ <summary> This method corresponds to the #stop
4302+ directive which just simulates and EOF
4303+ so that parsing stops. The #stop directive
4304+ is useful for end-user debugging
4305+ purposes.
4306+ </summary>
4307+ </member>
4308+ <member name="M:NVelocity.Runtime.Parser.ParserState.NodeCreated">
4309+ <summary>
4310+ Determines whether the current node was actually closed and
4311+ pushed. This should only be called in the final user action of a
4312+ node scope.
4313+ </summary>
4314+ <returns></returns>
4315+ </member>
4316+ <member name="M:NVelocity.Runtime.Parser.ParserState.Reset">
4317+ <summary>
4318+ Call this to reinitialize the node stack. It is called automatically by the parser's ReInit() method.
4319+ </summary>
4320+ </member>
4321+ <member name="M:NVelocity.Runtime.Parser.ParserState.PushNode(NVelocity.Runtime.Parser.Node.INode)">
4322+ <summary>
4323+ Pushes a node on to the stack.
4324+ </summary>
4325+ </member>
4326+ <member name="M:NVelocity.Runtime.Parser.ParserState.PopNode">
4327+ <summary>
4328+ Returns the node on the top of the stack, and remove it from the stack.
4329+ </summary>
4330+ </member>
4331+ <member name="M:NVelocity.Runtime.Parser.ParserState.PeekNode">
4332+ <summary>
4333+ Returns the node currently on the top of the stack.
4334+ </summary>
4335+ </member>
4336+ <member name="M:NVelocity.Runtime.Parser.ParserState.NodeArity">
4337+ <summary>
4338+ Returns the number of children on the stack in the current node scope.
4339+ </summary>
4340+ </member>
4341+ <member name="M:NVelocity.Runtime.Parser.ParserState.CloseNodeScope(NVelocity.Runtime.Parser.Node.INode,System.Int32)">
4342+ <summary>
4343+ A definite node is constructed from a specified number of
4344+ children. That number of nodes are popped from the stack and
4345+ made the children of the definite node. Then the definite node
4346+ is pushed on to the stack.
4347+ </summary>
4348+ </member>
4349+ <member name="M:NVelocity.Runtime.Parser.ParserState.CloseNodeScope(NVelocity.Runtime.Parser.Node.INode,System.Boolean)">
4350+ <summary>
4351+ A conditional node is constructed if its condition is true. All
4352+ the nodes that have been pushed since the node was opened are
4353+ made children of the the conditional node, which is then pushed
4354+ on to the stack. If the condition is false the node is not
4355+ constructed and they are left on the stack.
4356+ </summary>
4357+ </member>
4358+ <member name="P:NVelocity.Runtime.Parser.ParserState.RootNode">
4359+ <summary>
4360+ Returns the root node of the AST. It only makes sense to call this after a successful parse.
4361+ </summary>
4362+ </member>
4363+ <member name="M:NVelocity.Runtime.Parser.ParserTokenManager.StateStackPop">
4364+ pushes the current state onto the 'state stack',
4365+ and maintains the parens counts
4366+ public because we need it in PD &amp; VM handling
4367+
4368+ @return bool : success. It can fail if the state machine
4369+ gets messed up (do don't mess it up :)
4370+ </member>
4371+ <member name="M:NVelocity.Runtime.Parser.ParserTokenManager.StateStackPush">
4372+ pops a state off the stack, and restores paren counts
4373+
4374+ @return bool : success of operation
4375+ </member>
4376+ <member name="M:NVelocity.Runtime.Parser.ParserTokenManager.ClearStateVars">
4377+ Clears all state variables, resets to
4378+ start values, clears stateStack. Call
4379+ before parsing.
4380+ @return void
4381+ </member>
4382+ <member name="M:NVelocity.Runtime.Parser.ParserTokenManager.RPARENHandler">
4383+ handles the dropdown logic when encountering a RPAREN
4384+ </member>
4385+ <member name="M:NVelocity.Runtime.Parser.ParserTreeConstants.#ctor">
4386+ <summary>
4387+ private constructor as class is meant to hold constants only.
4388+ Class was originally an interface in Java, but as C# does not support Fields in an interface and
4389+ the jjtNodeName field, I converted it to a class with no constructor.
4390+ </summary>
4391+ </member>
4392+ <member name="T:NVelocity.Runtime.Parser.Token">
4393+ <summary>
4394+ Describes the input token stream.
4395+ </summary>
4396+ </member>
4397+ <member name="F:NVelocity.Runtime.Parser.Token.Kind">
4398+ <summary>
4399+ An integer that describes the kind of this token. This numbering
4400+ system is determined by JavaCCParser, and a table of these numbers is
4401+ stored in the file ...Constants.java.
4402+ </summary>
4403+ </member>
4404+ <member name="F:NVelocity.Runtime.Parser.Token.BeginLine">
4405+ <summary>
4406+ beginLine and beginColumn describe the position of the first character
4407+ of this token; endLine and endColumn describe the position of the
4408+ last character of this token.
4409+ </summary>
4410+ </member>
4411+ <member name="F:NVelocity.Runtime.Parser.Token.BeginColumn">
4412+ <summary>
4413+ beginLine and beginColumn describe the position of the first character
4414+ of this token; endLine and endColumn describe the position of the
4415+ last character of this token.
4416+ </summary>
4417+ </member>
4418+ <member name="F:NVelocity.Runtime.Parser.Token.EndLine">
4419+ <summary>
4420+ beginLine and beginColumn describe the position of the first character
4421+ of this token; endLine and endColumn describe the position of the
4422+ last character of this token.
4423+ </summary>
4424+ </member>
4425+ <member name="F:NVelocity.Runtime.Parser.Token.EndColumn">
4426+ <summary>
4427+ beginLine and beginColumn describe the position of the first character
4428+ of this token; endLine and endColumn describe the position of the
4429+ last character of this token.
4430+ </summary>
4431+ </member>
4432+ <member name="F:NVelocity.Runtime.Parser.Token.Image">
4433+ <summary> The string image of the token. </summary>
4434+ </member>
4435+ <member name="F:NVelocity.Runtime.Parser.Token.Next">
4436+ <summary>
4437+ A reference to the next regular (non-special) token from the input
4438+ stream. If this is the last token from the input stream, or if the
4439+ token manager has not read tokens beyond this one, this field is
4440+ set to null. This is true only if this token is also a regular
4441+ token. Otherwise, see below for a description of the contents of
4442+ this field.
4443+ </summary>
4444+ </member>
4445+ <member name="F:NVelocity.Runtime.Parser.Token.SpecialToken">
4446+ <summary>
4447+ This field is used to access special tokens that occur prior to this
4448+ token, but after the immediately preceding regular (non-special) token.
4449+ If there are no such special tokens, this field is set to null.
4450+ When there are more than one such special token, this field refers
4451+ to the last of these special tokens, which in turn refers to the next
4452+ previous special token through its specialToken field, and so on
4453+ until the first special token (whose specialToken field is null).
4454+ The next fields of special tokens refer to other special tokens that
4455+ immediately follow it (without an intervening regular token). If there
4456+ is no such token, this field is null.
4457+ </summary>
4458+ </member>
4459+ <member name="M:NVelocity.Runtime.Parser.Token.ToString">
4460+ <summary>
4461+ Returns the image.
4462+ </summary>
4463+ </member>
4464+ <member name="M:NVelocity.Runtime.Parser.Token.NewToken(System.Int32)">
4465+ <summary>
4466+ Returns a new Token object, by default. However, if you want, you
4467+ can create and return subclass objects based on the value of ofKind.
4468+ Simply add the cases to the switch for all those special cases.
4469+ For example, if you have a subclass of Token called IDToken that
4470+ you want to create if ofKind is ID, simply add something like :
4471+
4472+ <c>case MyParserConstants.ID : return new IDToken();</c>
4473+
4474+ to the following switch statement. Then you can cast matchedToken
4475+ variable to the appropriate type and use it in your lexical actions.
4476+ </summary>
4477+ </member>
4478+ <member name="F:NVelocity.Runtime.Parser.TokenMgrError.LEXICAL_ERROR">
4479+ <summary> Lexical error occurred.
4480+ </summary>
4481+ </member>
4482+ <member name="F:NVelocity.Runtime.Parser.TokenMgrError.STATIC_LEXER_ERROR">
4483+ <summary> An attempt was made to create a second instance of a static token manager.
4484+ </summary>
4485+ </member>
4486+ <member name="F:NVelocity.Runtime.Parser.TokenMgrError.INVALID_LEXICAL_STATE">
4487+ <summary> Tried to change to an invalid lexical state.
4488+ </summary>
4489+ </member>
4490+ <member name="F:NVelocity.Runtime.Parser.TokenMgrError.LOOP_DETECTED">
4491+ <summary> Detected (and bailed out of) an infinite loop in the token manager.
4492+ </summary>
4493+ </member>
4494+ <member name="F:NVelocity.Runtime.Parser.TokenMgrError.errorCode">
4495+ <summary> Indicates the reason why the exception is thrown. It will have
4496+ one of the above 4 values.
4497+ </summary>
4498+ </member>
4499+ <member name="M:NVelocity.Runtime.Parser.TokenMgrError.AddEscapes(System.String)">
4500+ <summary> Replaces unprintable characters by their escaped (or unicode escaped)
4501+ equivalents in the given string
4502+ </summary>
4503+ </member>
4504+ <member name="M:NVelocity.Runtime.Parser.TokenMgrError.LexicalError(System.Boolean,System.Int32,System.Int32,System.String,System.Char)">
4505+ <summary> Returns a detailed message for the Error when it is thrown by the
4506+ token manager to indicate a lexical error.
4507+ Parameters :
4508+ EOFSeen : indicates if EOF caused the lexical error
4509+ curLexState : lexical state in which this error occurred
4510+ errorLine : line number when the error occurred
4511+ errorColumn : column number when the error occurred
4512+ errorAfter : prefix that was seen before this error occurred
4513+ currentCharacter : the offending character
4514+ Note: You can customize the lexical error message by modifying this method.
4515+ </summary>
4516+ </member>
4517+ <member name="M:NVelocity.Runtime.Parser.TokenMgrError.#ctor">
4518+ <summary> You can also modify the body of this method to customize your error messages.
4519+ For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not
4520+ of end-users concern, so you can return something like :
4521+ *
4522+ "Internal Error : Please file a bug report .... "
4523+ *
4524+ from this method for such cases in the release version of your parser.
4525+ </summary>
4526+ </member>
4527+ <member name="T:NVelocity.Runtime.Parser.VelocityCharStream">
4528+ <summary> NOTE : This class was originally an ASCII_CharStream autogenerated
4529+ by Javacc. It was then modified via changing class name with appropriate
4530+ fixes for CTORS, and mods to readChar().
4531+
4532+ This is safe because we *always* use Reader with this class, and never a
4533+ InputStream. This guarantees that we have a correct stream of 16-bit
4534+ chars - all encoding transformations have been done elsewhere, so we
4535+ believe that there is no risk in doing this. Time will tell :)
4536+ </summary>
4537+ <summary> An implementation of interface CharStream, where the stream is assumed to
4538+ contain only ASCII characters (without unicode processing).
4539+ </summary>
4540+ </member>
4541+ <member name="M:NVelocity.Runtime.Parser.VelocityCharStream.AdjustBeginLineColumn(System.Int32,System.Int32)">
4542+ <summary> Method to adjust line and column numbers for the start of a token.<br/>
4543+ </summary>
4544+ </member>
4545+ <member name="T:NVelocity.Runtime.Resource.ContentResource">
4546+ <summary>
4547+ This class represent a general text resource that
4548+ may have been retrieved from any number of possible
4549+ sources.
4550+
4551+ Also of interest is Velocity's {@link org.apache.velocity.Template}
4552+ <code>Resource</code>.
4553+ </summary>
4554+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
4555+ </author>
4556+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
4557+ </author>
4558+ <version> $Id: ContentResource.cs,v 1.5 2004/01/02 00:09:23 corts Exp $
4559+
4560+ </version>
4561+ </member>
4562+ <member name="T:NVelocity.Runtime.Resource.Resource">
4563+ <summary>
4564+ This class represent a general text resource that
4565+ may have been retrieved from any number of possible
4566+ sources.
4567+ </summary>
4568+ <author><a href="mailto:jvanzyl@apache.org">Jason van Zyl</a></author>
4569+ <author><a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a></author>
4570+ <version> $Id: Resource.cs,v 1.5 2004/01/02 00:13:51 corts Exp $</version>
4571+ </member>
4572+ <member name="F:NVelocity.Runtime.Resource.Resource.MILLIS_PER_SECOND">
4573+ <summary>
4574+ The number of milliseconds in a minute, used to calculate the
4575+ check interval.
4576+ </summary>
4577+ </member>
4578+ <member name="F:NVelocity.Runtime.Resource.Resource.data">
4579+ <summary>
4580+ Resource might require ancillary storage of some kind
4581+ </summary>
4582+ </member>
4583+ <member name="F:NVelocity.Runtime.Resource.Resource.encoding">
4584+ <summary>
4585+ Character encoding of this resource
4586+ </summary>
4587+ </member>
4588+ <member name="F:NVelocity.Runtime.Resource.Resource.lastModified">
4589+ <summary>
4590+ The file modification time (in milliseconds) for the cached template.
4591+ </summary>
4592+ </member>
4593+ <member name="F:NVelocity.Runtime.Resource.Resource.modificationCheckInterval">
4594+ <summary>
4595+ How often the file modification time is checked (in milliseconds).
4596+ </summary>
4597+ </member>
4598+ <member name="F:NVelocity.Runtime.Resource.Resource.name">
4599+ <summary>
4600+ Name of the resource
4601+ </summary>
4602+ </member>
4603+ <member name="F:NVelocity.Runtime.Resource.Resource.nextCheck">
4604+ <summary>
4605+ The next time the file modification time will be checked (in milliseconds).
4606+ </summary>
4607+ </member>
4608+ <member name="F:NVelocity.Runtime.Resource.Resource.resourceLoader">
4609+ <summary>
4610+ The template loader that initially loaded the input
4611+ stream for this template, and knows how to check the
4612+ source of the input stream for modification.
4613+ </summary>
4614+ </member>
4615+ <member name="M:NVelocity.Runtime.Resource.Resource.Process">
4616+ <summary>
4617+ Perform any subsequent processing that might need
4618+ to be done by a resource. In the case of a template
4619+ the actual parsing of the input stream needs to be
4620+ performed.
4621+ </summary>
4622+ <returns>
4623+ Whether the resource could be processed successfully.
4624+ For a {@link org.apache.velocity.Template} or {@link
4625+ org.apache.velocity.runtime.resource.ContentResource}, this
4626+ indicates whether the resource could be read.
4627+ @exception ResourceNotFoundException Similar in semantics as
4628+ returning <code>false</code>.
4629+ </returns>
4630+ </member>
4631+ <member name="M:NVelocity.Runtime.Resource.Resource.RequiresChecking">
4632+ <summary> Set the modification check interval.
4633+ </summary>
4634+ <summary> Is it time to check to see if the resource
4635+ source has been updated?
4636+ </summary>
4637+ </member>
4638+ <member name="M:NVelocity.Runtime.Resource.Resource.Touch">
4639+ <summary>
4640+ 'Touch' this template and thereby resetting the nextCheck field.
4641+ </summary>
4642+ </member>
4643+ <member name="P:NVelocity.Runtime.Resource.Resource.Data">
4644+ <summary>
4645+ Set arbitrary data object that might be used
4646+ by the resource.
4647+
4648+ Get arbitrary data object that might be used
4649+ by the resource.
4650+ </summary>
4651+ </member>
4652+ <member name="P:NVelocity.Runtime.Resource.Resource.Encoding">
4653+ <summary>
4654+ set the encoding of this resource
4655+ for example, "ISO-8859-1"
4656+
4657+ get the encoding of this resource
4658+ for example, "ISO-8859-1"
4659+ </summary>
4660+ </member>
4661+ <member name="P:NVelocity.Runtime.Resource.Resource.LastModified">
4662+ <summary>
4663+ Return the lastModified time of this
4664+ template.
4665+
4666+ Set the last modified time for this
4667+ template.
4668+ </summary>
4669+ </member>
4670+ <member name="P:NVelocity.Runtime.Resource.Resource.Name">
4671+ <summary>
4672+ Set the name of this resource, for example test.vm.
4673+
4674+ Get the name of this template.
4675+ </summary>
4676+ </member>
4677+ <member name="P:NVelocity.Runtime.Resource.Resource.ResourceLoader">
4678+ <summary>
4679+ Return the template loader that pulled
4680+ in the template stream
4681+
4682+ Set the template loader for this template. Set
4683+ when the Runtime determines where this template
4684+ came from the list of possible sources.
4685+ </summary>
4686+ </member>
4687+ <member name="M:NVelocity.Runtime.Resource.ContentResource.#ctor">
4688+ <summary>Default empty constructor
4689+ </summary>
4690+ </member>
4691+ <member name="M:NVelocity.Runtime.Resource.ContentResource.Process">
4692+ <summary>
4693+ Pull in static content and store it.
4694+
4695+ @exception ResourceNotFoundException Resource could not be
4696+ found.
4697+ </summary>
4698+ </member>
4699+ <member name="T:NVelocity.Runtime.Resource.Loader.ResourceLoader">
4700+ <summary>
4701+ This is abstract class the all text resource loaders should extend.
4702+ </summary>
4703+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a></author>
4704+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a></author>
4705+ <version> $Id: ResourceLoader.cs,v 1.3 2003/10/27 13:54:11 corts Exp $</version>
4706+ </member>
4707+ <member name="F:NVelocity.Runtime.Resource.Loader.ResourceLoader.isCachingOn">
4708+ <summary>
4709+ Does this loader want templates produced with it
4710+ cached in the Runtime.
4711+ </summary>
4712+ </member>
4713+ <member name="F:NVelocity.Runtime.Resource.Loader.ResourceLoader.modificationCheckInterval">
4714+ <summary>
4715+ This property will be passed on to the templates
4716+ that are created with this loader.
4717+ </summary>
4718+ </member>
4719+ <member name="F:NVelocity.Runtime.Resource.Loader.ResourceLoader.className">
4720+ <summary>
4721+ Class name for this loader, for logging/debugging
4722+ purposes.
4723+ </summary>
4724+ </member>
4725+ <member name="M:NVelocity.Runtime.Resource.Loader.ResourceLoader.CommonInit(NVelocity.Runtime.IRuntimeServices,Commons.Collections.ExtendedProperties)">
4726+ <summary>
4727+ This initialization is used by all resource
4728+ loaders and must be called to set up common
4729+ properties shared by all resource loaders
4730+ </summary>
4731+ </member>
4732+ <member name="M:NVelocity.Runtime.Resource.Loader.ResourceLoader.Init(Commons.Collections.ExtendedProperties)">
4733+ <summary>
4734+ Initialize the template loader with a
4735+ a resources class.
4736+ </summary>
4737+ </member>
4738+ <member name="M:NVelocity.Runtime.Resource.Loader.ResourceLoader.GetResourceStream(System.String)">
4739+ <summary>
4740+ Get the InputStream that the Runtime will parse
4741+ to create a template.
4742+ </summary>
4743+ </member>
4744+ <member name="M:NVelocity.Runtime.Resource.Loader.ResourceLoader.IsSourceModified(NVelocity.Runtime.Resource.Resource)">
4745+ <summary>
4746+ Given a template, check to see if the source of InputStream
4747+ has been modified.
4748+ </summary>
4749+ </member>
4750+ <member name="M:NVelocity.Runtime.Resource.Loader.ResourceLoader.GetLastModified(NVelocity.Runtime.Resource.Resource)">
4751+ <summary>
4752+ Get the last modified time of the InputStream source
4753+ that was used to create the template. We need the template
4754+ here because we have to extract the name of the template
4755+ in order to locate the InputStream source.
4756+ </summary>
4757+ </member>
4758+ <member name="P:NVelocity.Runtime.Resource.Loader.ResourceLoader.ClassName">
4759+ <summary>
4760+ Return the class name of this resource Loader
4761+ </summary>
4762+ </member>
4763+ <member name="P:NVelocity.Runtime.Resource.Loader.ResourceLoader.CachingOn">
4764+ <summary>
4765+ Set the caching state. If true, then this loader
4766+ would like the Runtime to cache templates that
4767+ have been created with InputStreams provided
4768+ by this loader.
4769+ </summary>
4770+ </member>
4771+ <member name="M:NVelocity.Runtime.Resource.Loader.AssemblyRelativeResourceLoader.Init(Commons.Collections.ExtendedProperties)">
4772+ <summary>
4773+ Initialize the template loader with a
4774+ a resources class.
4775+ </summary>
4776+ </member>
4777+ <member name="M:NVelocity.Runtime.Resource.Loader.AssemblyRelativeResourceLoader.GetResourceStream(System.String)">
4778+
4779+ <summary> Get the InputStream that the Runtime will parse
4780+ to create a template.
4781+ </summary>
4782+ </member>
4783+ <member name="M:NVelocity.Runtime.Resource.Loader.AssemblyRelativeResourceLoader.IsSourceModified(NVelocity.Runtime.Resource.Resource)">
4784+ <summary> Given a template, check to see if the source of InputStream
4785+ has been modified.
4786+ </summary>
4787+ </member>
4788+ <member name="M:NVelocity.Runtime.Resource.Loader.AssemblyRelativeResourceLoader.GetLastModified(NVelocity.Runtime.Resource.Resource)">
4789+ <summary> Get the last modified time of the InputStream source
4790+ that was used to create the template. We need the template
4791+ here because we have to extract the name of the template
4792+ in order to locate the InputStream source.
4793+ </summary>
4794+ </member>
4795+ <member name="M:NVelocity.Runtime.Resource.Loader.AssemblyResourceLoader.Init(Commons.Collections.ExtendedProperties)">
4796+ <summary>
4797+ Initialize the template loader with a resources class.
4798+ </summary>
4799+ </member>
4800+ <member name="M:NVelocity.Runtime.Resource.Loader.AssemblyResourceLoader.GetResourceStream(System.String)">
4801+ <summary> Get the InputStream that the Runtime will parse
4802+ to create a template.
4803+ </summary>
4804+ </member>
4805+ <member name="M:NVelocity.Runtime.Resource.Loader.AssemblyResourceLoader.IsSourceModified(NVelocity.Runtime.Resource.Resource)">
4806+ <summary> Given a template, check to see if the source of InputStream
4807+ has been modified.
4808+ </summary>
4809+ </member>
4810+ <member name="M:NVelocity.Runtime.Resource.Loader.AssemblyResourceLoader.GetLastModified(NVelocity.Runtime.Resource.Resource)">
4811+ <summary> Get the last modified time of the InputStream source
4812+ that was used to create the template. We need the template
4813+ here because we have to extract the name of the template
4814+ in order to locate the InputStream source.
4815+ </summary>
4816+ </member>
4817+ <member name="T:NVelocity.Runtime.Resource.Loader.FileResourceLoader">
4818+ <summary>
4819+ A loader for templates stored on the file system.
4820+ </summary>
4821+ </member>
4822+ <member name="F:NVelocity.Runtime.Resource.Loader.FileResourceLoader.paths">
4823+ <summary>
4824+ The paths to search for templates.
4825+ </summary>
4826+ </member>
4827+ <member name="F:NVelocity.Runtime.Resource.Loader.FileResourceLoader.templatePaths">
4828+ <summary>
4829+ Used to map the path that a template was found on
4830+ so that we can properly check the modification
4831+ times of the files.
4832+ </summary>
4833+ </member>
4834+ <member name="M:NVelocity.Runtime.Resource.Loader.FileResourceLoader.GetResourceStream(System.String)">
4835+ <summary>
4836+ Get an InputStream so that the Runtime can build a
4837+ template with it.
4838+ </summary>
4839+ <param name="templateName">name of template to get</param>
4840+ <returns>InputStream containing the template
4841+ @throws ResourceNotFoundException if template not found
4842+ in the file template path.
4843+ </returns>
4844+ </member>
4845+ <member name="M:NVelocity.Runtime.Resource.Loader.FileResourceLoader.FindTemplate(System.String,System.String)">
4846+ <summary>
4847+ Try to find a template given a normalized path.
4848+ </summary>
4849+ <param name="path">a normalized path</param>
4850+ <param name="template">filename of template to get</param>
4851+ <returns>InputStream input stream that will be parsed</returns>
4852+ </member>
4853+ <member name="M:NVelocity.Runtime.Resource.Loader.FileResourceLoader.IsSourceModified(NVelocity.Runtime.Resource.Resource)">
4854+ <summary>
4855+ How to keep track of all the modified times
4856+ across the paths.
4857+ </summary>
4858+ </member>
4859+ <member name="T:NVelocity.Runtime.Resource.Loader.ResourceLoaderFactory">
4860+ <summary>
4861+ Factory to grab a template loader.
4862+ </summary>
4863+ <author><a href="mailto:jvanzyl@apache.org">Jason van Zyl</a></author>
4864+ </member>
4865+ <member name="M:NVelocity.Runtime.Resource.Loader.ResourceLoaderFactory.getLoader(NVelocity.Runtime.IRuntimeServices,System.String)">
4866+ <summary>
4867+ Gets the loader specified in the configuration file.
4868+ </summary>
4869+ <returns>TemplateLoader</returns>
4870+ </member>
4871+ <member name="T:NVelocity.Runtime.Resource.ResourceCache">
4872+ <summary> Interface that defines the shape of a pluggable resource cache
4873+ for the included ResourceManager
4874+ *
4875+ </summary>
4876+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
4877+ </author>
4878+ <version> $Id: ResourceCache.cs,v 1.3 2003/10/27 13:54:11 corts Exp $
4879+
4880+ </version>
4881+ </member>
4882+ <member name="M:NVelocity.Runtime.Resource.ResourceCache.initialize(NVelocity.Runtime.IRuntimeServices)">
4883+ <summary> initializes the ResourceCache. Will be
4884+ called before any utilization
4885+ *
4886+ </summary>
4887+ <param name="rs">RuntimeServices to use for logging, etc
4888+
4889+ </param>
4890+ </member>
4891+ <member name="M:NVelocity.Runtime.Resource.ResourceCache.get(System.Object)">
4892+ <summary> retrieves a Resource from the
4893+ cache
4894+ *
4895+ </summary>
4896+ <param name="resourceKey">key for Resource to be retrieved
4897+ </param>
4898+ <returns>Resource specified or null if not found
4899+
4900+ </returns>
4901+ </member>
4902+ <member name="M:NVelocity.Runtime.Resource.ResourceCache.put(System.Object,NVelocity.Runtime.Resource.Resource)">
4903+ <summary> stores a Resource in the cache
4904+ *
4905+ </summary>
4906+ <param name="resourceKey">key to associate with the Resource
4907+ </param>
4908+ <param name="resource">Resource to be stored
4909+ </param>
4910+ <returns>existing Resource stored under this key, or null if none
4911+
4912+ </returns>
4913+ </member>
4914+ <member name="M:NVelocity.Runtime.Resource.ResourceCache.remove(System.Object)">
4915+ <summary> removes a Resource from the cache
4916+ *
4917+ </summary>
4918+ <param name="resourceKey">resource to be removed
4919+ </param>
4920+ </member>
4921+ <member name="M:NVelocity.Runtime.Resource.ResourceCache.enumerateKeys">
4922+ <summary> returns an Iterator of Keys in the cache
4923+ </summary>
4924+ </member>
4925+ <member name="T:NVelocity.Runtime.Resource.ResourceCacheImpl">
4926+ <summary>
4927+ Default implementation of the resource cache for the default
4928+ ResourceManager. The cache uses a <i>least recently used</i> (LRU)
4929+ algorithm, with a maximum size specified via the
4930+ <code>resource.manager.cache.size</code> property (identified by the
4931+ {@link
4932+ org.apache.velocity.runtime.RuntimeConstants#RESOURCE_MANAGER_CACHE_SIZE}
4933+ constant). This property get be set to <code>0</code> or less for
4934+ a greedy, unbounded cache (the behavior from pre-v1.5).
4935+ *
4936+ </summary>
4937+ <author> <a href="mailto:geirm@apache.org">Geir Magnusson Jr.</a>
4938+ </author>
4939+ <author> <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a>
4940+ </author>
4941+ <version> $Id: ResourceCacheImpl.cs,v 1.5 2004/12/23 08:14:32 corts Exp $
4942+
4943+ </version>
4944+ </member>
4945+ <member name="F:NVelocity.Runtime.Resource.ResourceCacheImpl.cache">
4946+ <summary>
4947+ Cache storage, assumed to be thread-safe.
4948+ </summary>
4949+ </member>
4950+ <member name="F:NVelocity.Runtime.Resource.ResourceCacheImpl.runtimeServices">
4951+ <summary>
4952+ Runtime services, generally initialized by the
4953+ <code>initialize()</code> method.
4954+ </summary>
4955+ </member>
4956+ <member name="T:NVelocity.Runtime.Resource.ResourceFactory">
4957+ <summary>
4958+ Class responsible for instantiating <code>Resource</code> objects,
4959+ given name and type.
4960+ </summary>
4961+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a> </author>
4962+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a> </author>
4963+ <version> $Id: ResourceFactory.cs,v 1.3 2003/10/27 13:54:11 corts Exp $ </version>
4964+ </member>
4965+ <member name="T:NVelocity.Runtime.Resource.ResourceType">
4966+ <summary>
4967+ Class to manage the text resource for the Velocity
4968+ Runtime.
4969+ </summary>
4970+ </member>
4971+ <member name="F:NVelocity.Runtime.Resource.ResourceType.Template">
4972+ <summary>
4973+ A template resources.
4974+ </summary>
4975+ </member>
4976+ <member name="F:NVelocity.Runtime.Resource.ResourceType.Content">
4977+ <summary>
4978+ A static content resource.
4979+ </summary>
4980+ </member>
4981+ <member name="M:NVelocity.Runtime.Resource.IResourceManager.Initialize(NVelocity.Runtime.IRuntimeServices)">
4982+ <summary>
4983+ Initialize the ResourceManager.
4984+ </summary>
4985+ </member>
4986+ <member name="M:NVelocity.Runtime.Resource.IResourceManager.GetResource(System.String,NVelocity.Runtime.Resource.ResourceType,System.String)">
4987+ <summary>
4988+ Gets the named resource. Returned class type corresponds to specified type
4989+ (i.e. <c>Template</c> to <c>Template</c>).
4990+ </summary>
4991+ <param name="resourceName">The name of the resource to retrieve.</param>
4992+ <param name="resourceType">The type of resource (<code>Template</code>, <code>Content</code>, etc.).</param>
4993+ <param name="encoding">The character encoding to use.</param>
4994+ <returns>Resource with the template parsed and ready.</returns>
4995+ <exception cref="T:NVelocity.Exception.ResourceNotFoundException">
4996+ if template not found from any available source.
4997+ </exception>
4998+ <exception cref="T:NVelocity.Exception.ParseErrorException">
4999+ if template cannot be parsed due to syntax (or other) error.
5000+ </exception>
5001+ <exception cref="T:System.Exception">
5002+ if a problem in parse
5003+ </exception>
5004+ </member>
5005+ <member name="M:NVelocity.Runtime.Resource.IResourceManager.GetLoaderNameForResource(System.String)">
5006+ <summary>
5007+ Determines is a template exists, and returns name of the loader that
5008+ provides it. This is a slightly less hokey way to support
5009+ the Velocity.templateExists() utility method, which was broken
5010+ when per-template encoding was introduced. We can revisit this.
5011+ </summary>
5012+ <param name="resourceName">Name of template or content resource</param>
5013+ <returns>class name of loader than can provide it</returns>
5014+ </member>
5015+ <member name="T:NVelocity.Runtime.Resource.ResourceManagerImpl">
5016+ <summary>
5017+ Class to manage the text resource for the Velocity Runtime.
5018+ </summary>
5019+ </member>
5020+ <member name="F:NVelocity.Runtime.Resource.ResourceManagerImpl.RESOURCE_LOADER_IDENTIFIER">
5021+ <summary>
5022+ token used to identify the loader internally
5023+ </summary>
5024+ </member>
5025+ <member name="F:NVelocity.Runtime.Resource.ResourceManagerImpl.globalCache">
5026+ <summary>
5027+ Object implementing ResourceCache to
5028+ be our resource manager's Resource cache.
5029+ </summary>
5030+ </member>
5031+ <member name="F:NVelocity.Runtime.Resource.ResourceManagerImpl.resourceLoaders">
5032+ <summary>
5033+ The List of templateLoaders that the Runtime will
5034+ use to locate the InputStream source of a template.
5035+ </summary>
5036+ </member>
5037+ <member name="F:NVelocity.Runtime.Resource.ResourceManagerImpl.sourceInitializerList">
5038+ <summary>
5039+ This is a list of the template input stream source
5040+ initializers, basically properties for a particular
5041+ template stream source. The order in this list
5042+ reflects numbering of the properties i.e.
5043+ &lt;loader-id&gt;.resource.loader.&lt;property&gt; = &lt;value&gt;
5044+ </summary>
5045+ </member>
5046+ <member name="F:NVelocity.Runtime.Resource.ResourceManagerImpl.resourceLoaderInitializersActive">
5047+ <summary>
5048+ Each loader needs a configuration object for
5049+ its initialization, this flags keeps track of whether
5050+ or not the configuration objects have been created
5051+ for the resource loaders.
5052+ </summary>
5053+ </member>
5054+ <member name="F:NVelocity.Runtime.Resource.ResourceManagerImpl.logWhenFound">
5055+ <summary>
5056+ switch to turn off log notice when a resource is found for
5057+ the first time.
5058+ </summary>
5059+ </member>
5060+ <member name="M:NVelocity.Runtime.Resource.ResourceManagerImpl.Initialize(NVelocity.Runtime.IRuntimeServices)">
5061+ <summary>
5062+ Initialize the ResourceManager.
5063+ </summary>
5064+ </member>
5065+ <member name="M:NVelocity.Runtime.Resource.ResourceManagerImpl.AssembleResourceLoaderInitializers">
5066+ <summary>
5067+ This will produce a List of Hashtables, each
5068+ hashtable contains the initialization info for
5069+ a particular resource loader. This Hashtable
5070+ will be passed in when initializing the
5071+ the template loader.
5072+ </summary>
5073+ </member>
5074+ <member name="M:NVelocity.Runtime.Resource.ResourceManagerImpl.GetResource(System.String,NVelocity.Runtime.Resource.ResourceType,System.String)">
5075+ <summary> Gets the named resource. Returned class type corresponds to specified type
5076+ (i.e. <code>Template</code> to <code>Template</code>).
5077+ *
5078+ </summary>
5079+ <param name="resourceName">The name of the resource to retrieve.
5080+ </param>
5081+ <param name="resourceType">The type of resource (<code>Template</code>,
5082+ <code>Content</code>, etc.).
5083+ </param>
5084+ <param name="encoding"> The character encoding to use.
5085+ </param>
5086+ <returns>Resource with the template parsed and ready.
5087+ @throws ResourceNotFoundException if template not found
5088+ from any available source.
5089+ @throws ParseErrorException if template cannot be parsed due
5090+ to syntax (or other) error.
5091+ @throws Exception if a problem in parse
5092+
5093+ </returns>
5094+ </member>
5095+ <member name="M:NVelocity.Runtime.Resource.ResourceManagerImpl.LoadResource(System.String,NVelocity.Runtime.Resource.ResourceType,System.String)">
5096+ <summary>
5097+ Loads a resource from the current set of resource loaders
5098+ </summary>
5099+ <param name="resourceName">The name of the resource to retrieve.</param>
5100+ <param name="resourceType">The type of resource (<code>Template</code>,
5101+ <code>Content</code>, etc.).
5102+ </param>
5103+ <param name="encoding"> The character encoding to use.</param>
5104+ <returns>Resource with the template parsed and ready.
5105+ @throws ResourceNotFoundException if template not found
5106+ from any available source.
5107+ @throws ParseErrorException if template cannot be parsed due
5108+ to syntax (or other) error.
5109+ @throws Exception if a problem in parse
5110+ </returns>
5111+ </member>
5112+ <member name="M:NVelocity.Runtime.Resource.ResourceManagerImpl.RefreshResource(NVelocity.Runtime.Resource.Resource,System.String)">
5113+ <summary> Takes an existing resource, and 'refreshes' it. This
5114+ generally means that the source of the resource is checked
5115+ for changes according to some cache/check algorithm
5116+ and if the resource changed, then the resource data is
5117+ reloaded and re-parsed.
5118+ *
5119+ </summary>
5120+ <param name="resource">resource to refresh
5121+ *
5122+ @throws ResourceNotFoundException if template not found
5123+ from current source for this Resource
5124+ @throws ParseErrorException if template cannot be parsed due
5125+ to syntax (or other) error.
5126+ @throws Exception if a problem in parse
5127+
5128+ </param>
5129+ <param name="encoding"></param>
5130+ </member>
5131+ <member name="M:NVelocity.Runtime.Resource.ResourceManagerImpl.GetResource(System.String,NVelocity.Runtime.Resource.ResourceType)">
5132+ <summary> Gets the named resource. Returned class type corresponds to specified type
5133+ (i.e. <code>Template</code> to <code>Template</code>).
5134+ *
5135+ </summary>
5136+ <param name="resourceName">The name of the resource to retrieve.
5137+ </param>
5138+ <param name="resourceType">The type of resource (<code>Template</code>,
5139+ <code>Content</code>, etc.).
5140+ </param>
5141+ <returns>Resource with the template parsed and ready.
5142+ @throws ResourceNotFoundException if template not found
5143+ from any available source.
5144+ @throws ParseErrorException if template cannot be parsed due
5145+ to syntax (or other) error.
5146+ @throws Exception if a problem in parse
5147+ *
5148+ </returns>
5149+ <deprecated>Use
5150+ {@link #GetResource(String resourceName, int resourceType,
5151+ String encoding )}
5152+
5153+ </deprecated>
5154+ </member>
5155+ <member name="M:NVelocity.Runtime.Resource.ResourceManagerImpl.GetLoaderNameForResource(System.String)">
5156+ <summary> Determines is a template exists, and returns name of the loader that
5157+ provides it. This is a slightly less hokey way to support
5158+ the Velocity.templateExists() utility method, which was broken
5159+ when per-template encoding was introduced. We can revisit this.
5160+ </summary>
5161+ <param name="resourceName">Name of template or content resource
5162+ </param>
5163+ <returns>class name of loader than can provide it
5164+
5165+ </returns>
5166+ </member>
5167+ <member name="T:NVelocity.Runtime.RuntimeConstants">
5168+ <summary>
5169+ This class defines the keys that are used in the
5170+ velocity.properties file so that they can be referenced as a constant
5171+ within Java code.
5172+ </summary>
5173+ <author> <a href="mailto:jon@latchkey.com">Jon S. Stevens</a></author>
5174+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a></author>
5175+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a></author>
5176+ </member>
5177+ <member name="F:NVelocity.Runtime.RuntimeConstants.RESOURCE_MANAGER_CACHE_CLASS">
5178+ <summary>
5179+ The <code>resource.manager.cache.class</code> property
5180+ specifies the name of the <see cref="T:NVelocity.Runtime.Resource.ResourceCache"/> implementation to use.
5181+ </summary>
5182+ </member>
5183+ <member name="F:NVelocity.Runtime.RuntimeConstants.RESOURCE_MANAGER_DEFAULTCACHE_SIZE">
5184+ <summary>
5185+ The <code>resource.manager.cache.size</code> property
5186+ specifies the cache upper bound (if relevant).
5187+ </summary>
5188+ </member>
5189+ <member name="F:NVelocity.Runtime.RuntimeConstants.NUMBER_OF_PARSERS">
5190+ <summary>
5191+ The default number of parser instances to create.
5192+ Configurable via the parameter named by the <see cref="F:NVelocity.Runtime.RuntimeConstants.PARSER_POOL_SIZE"/> constant.
5193+ </summary>
5194+ </member>
5195+ <member name="F:NVelocity.Runtime.RuntimeConstants.PARSER_POOL_SIZE">
5196+ <summary>
5197+ <see cref="F:NVelocity.Runtime.RuntimeConstants.NUMBER_OF_PARSERS"/>
5198+ </summary>
5199+ </member>
5200+ <member name="F:NVelocity.Runtime.RuntimeConstants.UBERSPECT_CLASSNAME">
5201+ <summary>
5202+ key name for uberspector
5203+ </summary>
5204+ </member>
5205+ <member name="T:NVelocity.Runtime.RuntimeInstance">
5206+ <summary>
5207+ This is the Runtime system for Velocity. It is the
5208+ single access point for all functionality in Velocity.
5209+ It adheres to the mediator pattern and is the only
5210+ structure that developers need to be familiar with
5211+ in order to get Velocity to perform.
5212+
5213+ The Runtime will also cooperate with external
5214+ systems like Turbine. Runtime properties can
5215+ set and then the Runtime is initialized.
5216+
5217+ Turbine for example knows where the templates
5218+ are to be loaded from, and where the velocity
5219+ log file should be placed.
5220+
5221+ So in the case of Velocity cooperating with Turbine
5222+ the code might look something like the following:
5223+
5224+ <code>
5225+ Runtime.setProperty(Runtime.FILE_RESOURCE_LOADER_PATH, templatePath);
5226+ Runtime.setProperty(Runtime.RUNTIME_LOG, pathToVelocityLog);
5227+ Runtime.init();
5228+ </code>
5229+
5230+ <pre>
5231+ -----------------------------------------------------------------------
5232+ N O T E S O N R U N T I M E I N I T I A L I Z A T I O N
5233+ -----------------------------------------------------------------------
5234+ Runtime.init()
5235+
5236+ If Runtime.init() is called by itself the Runtime will
5237+ initialize with a set of default values.
5238+ -----------------------------------------------------------------------
5239+ Runtime.init(String/Properties)
5240+
5241+ In this case the default velocity properties are layed down
5242+ first to provide a solid base, then any properties provided
5243+ in the given properties object will override the corresponding
5244+ default property.
5245+ -----------------------------------------------------------------------
5246+ </pre>
5247+
5248+ </summary>
5249+ </member>
5250+ <member name="F:NVelocity.Runtime.RuntimeInstance.vmFactory">
5251+ <summary>
5252+ VelocimacroFactory object to manage VMs
5253+ </summary>
5254+ </member>
5255+ <member name="F:NVelocity.Runtime.RuntimeInstance.parserPool">
5256+ <summary>
5257+ The Runtime parser pool
5258+ </summary>
5259+ </member>
5260+ <member name="F:NVelocity.Runtime.RuntimeInstance.initialized">
5261+ <summary>
5262+ Indicate whether the Runtime has been fully initialized.
5263+ </summary>
5264+ </member>
5265+ <member name="F:NVelocity.Runtime.RuntimeInstance.overridingProperties">
5266+ <summary>
5267+ These are the properties that are laid down over top
5268+ of the default properties when requested.
5269+ </summary>
5270+ </member>
5271+ <member name="F:NVelocity.Runtime.RuntimeInstance.configuration">
5272+ <summary>
5273+ Object that houses the configuration options for
5274+ the velocity runtime. The ExtendedProperties object allows
5275+ the convenient retrieval of a subset of properties.
5276+ For example all the properties for a resource loader
5277+ can be retrieved from the main ExtendedProperties object
5278+ using something like the following:
5279+
5280+ <code>
5281+ ExtendedProperties loaderConfiguration =
5282+ configuration.subset(loaderID);
5283+ </code>
5284+
5285+ And a configuration is a lot more convenient to deal
5286+ with then conventional properties objects, or Maps.
5287+ </summary>
5288+ </member>
5289+ <member name="F:NVelocity.Runtime.RuntimeInstance.introspector">
5290+ <summary>
5291+ Each runtime instance has it's own introspector
5292+ to ensure that each instance is completely separate.
5293+ </summary>
5294+ </member>
5295+ <member name="F:NVelocity.Runtime.RuntimeInstance.applicationAttributes">
5296+ <summary>
5297+ Opaque reference to something specified by the
5298+ application for use in application supplied/specified
5299+ pluggable components.
5300+ </summary>
5301+ </member>
5302+ <member name="M:NVelocity.Runtime.RuntimeInstance.initializeIntrospection">
5303+ <summary>
5304+ Gets the classname for the Uberspect introspection package and
5305+ instantiates an instance.
5306+ </summary>
5307+ </member>
5308+ <member name="M:NVelocity.Runtime.RuntimeInstance.setDefaultProperties">
5309+ <summary>
5310+ Initializes the Velocity Runtime with properties file.
5311+ The properties file may be in the file system proper,
5312+ or the properties file may be in the classpath.
5313+ </summary>
5314+ </member>
5315+ <member name="M:NVelocity.Runtime.RuntimeInstance.SetProperty(System.String,System.Object)">
5316+ <summary>
5317+ Allows an external system to set a property in
5318+ the Velocity Runtime.
5319+ </summary>
5320+ <param name="key">property key </param>
5321+ <param name="value">property value</param>
5322+ </member>
5323+ <member name="M:NVelocity.Runtime.RuntimeInstance.AddProperty(System.String,System.Object)">
5324+ <summary>
5325+ Add a property to the configuration. If it already
5326+ exists then the value stated here will be added
5327+ to the configuration entry.
5328+ <remarks>
5329+ For example, if
5330+ <c>resource.loader = file</c>
5331+ is already present in the configuration and you
5332+ <c>addProperty("resource.loader", "classpath")</c>
5333+
5334+ Then you will end up with a <see cref="T:System.Collections.IList"/> like the
5335+ following:
5336+
5337+ <c>["file", "classpath"]</c>
5338+ </remarks>
5339+ </summary>
5340+ <param name="key">key</param>
5341+ <param name="value">value</param>
5342+ </member>
5343+ <member name="M:NVelocity.Runtime.RuntimeInstance.ClearProperty(System.String)">
5344+ <summary>
5345+ Clear the values pertaining to a particular
5346+ property.
5347+ </summary>
5348+ <param name="key">key of property to clear</param>
5349+ </member>
5350+ <member name="M:NVelocity.Runtime.RuntimeInstance.GetProperty(System.String)">
5351+ <summary>
5352+ Allows an external caller to get a property.
5353+ <remarks>
5354+ The calling routine is required to know the type, as this routine
5355+ will return an Object, as that is what properties can be.
5356+ </remarks>
5357+ </summary>
5358+ <param name="key">property to return</param>
5359+ </member>
5360+ <member name="M:NVelocity.Runtime.RuntimeInstance.initializeProperties">
5361+ <summary>
5362+ Initialize Velocity properties, if the default
5363+ properties have not been laid down first then
5364+ do so. Then proceed to process any overriding
5365+ properties. Laying down the default properties
5366+ gives a much greater chance of having a
5367+ working system.
5368+ </summary>
5369+ </member>
5370+ <member name="M:NVelocity.Runtime.RuntimeInstance.Init(Commons.Collections.ExtendedProperties)">
5371+ <summary>
5372+ Initialize the Velocity Runtime with a Properties
5373+ object.
5374+ </summary>
5375+ <param name="p">Properties</param>
5376+ </member>
5377+ <member name="M:NVelocity.Runtime.RuntimeInstance.Init(System.String)">
5378+ <summary>
5379+ Initialize the Velocity Runtime with the name of
5380+ ExtendedProperties object.
5381+ </summary>
5382+ <param name="configurationFile">Properties</param>
5383+ </member>
5384+ <member name="M:NVelocity.Runtime.RuntimeInstance.initializeLogger">
5385+ <summary> Initialize the Velocity logging system.
5386+ *
5387+ @throws Exception
5388+ </summary>
5389+ </member>
5390+ <member name="M:NVelocity.Runtime.RuntimeInstance.initializeDirectives">
5391+ <summary> This methods initializes all the directives
5392+ that are used by the Velocity Runtime. The
5393+ directives to be initialized are listed in
5394+ the RUNTIME_DEFAULT_DIRECTIVES properties
5395+ file.
5396+
5397+ @throws Exception
5398+ </summary>
5399+ </member>
5400+ <member name="M:NVelocity.Runtime.RuntimeInstance.initializeParserPool">
5401+ <summary> Initializes the Velocity parser pool.
5402+ This still needs to be implemented.
5403+ </summary>
5404+ </member>
5405+ <member name="M:NVelocity.Runtime.RuntimeInstance.CreateNewParser">
5406+ <summary> Returns a JavaCC generated Parser.
5407+ </summary>
5408+ <returns>Parser javacc generated parser
5409+ </returns>
5410+ </member>
5411+ <member name="M:NVelocity.Runtime.RuntimeInstance.Parse(System.IO.TextReader,System.String)">
5412+ <summary>
5413+ Parse the input and return the root of
5414+ AST node structure.
5415+ <remarks>
5416+ In the event that it runs out of parsers in the
5417+ pool, it will create and let them be GC'd
5418+ dynamically, logging that it has to do that. This
5419+ is considered an exceptional condition. It is
5420+ expected that the user will set the
5421+ <c>PARSER_POOL_SIZE</c> property appropriately for their
5422+ application. We will revisit this.
5423+ </remarks>
5424+ </summary>
5425+ <param name="reader">inputstream retrieved by a resource loader</param>
5426+ <param name="templateName">name of the template being parsed</param>
5427+ </member>
5428+ <member name="M:NVelocity.Runtime.RuntimeInstance.Parse(System.IO.TextReader,System.String,System.Boolean)">
5429+ <summary>
5430+ Parse the input and return the root of the AST node structure.
5431+ </summary>
5432+ <param name="reader">inputstream retrieved by a resource loader</param>
5433+ <param name="templateName">name of the template being parsed</param>
5434+ <param name="dumpNamespace">flag to dump the Velocimacro namespace for this template</param>
5435+ </member>
5436+ <member name="M:NVelocity.Runtime.RuntimeInstance.GetTemplate(System.String)">
5437+ <summary>
5438+ Returns a <code>Template</code> from the resource manager.
5439+ This method assumes that the character encoding of the
5440+ template is set by the <code>input.encoding</code>
5441+ property. The default is "ISO-8859-1"
5442+ </summary>
5443+ <param name="name">The file name of the desired template.
5444+ </param>
5445+ <returns>The template.</returns>
5446+ <exception cref="T:NVelocity.Exception.ResourceNotFoundException">
5447+ if template not found from any available source
5448+ </exception>
5449+ <exception cref="T:NVelocity.Exception.ParseErrorException">
5450+ if template cannot be parsed due to syntax (or other) error.
5451+ </exception>
5452+ <exception cref="N:NVelocity.Runtime.Exception">
5453+ if an error occurs in template initialization
5454+ </exception>
5455+ </member>
5456+ <member name="M:NVelocity.Runtime.RuntimeInstance.GetTemplate(System.String,System.String)">
5457+ <summary>
5458+ Returns a <code>Template</code> from the resource manager
5459+ </summary>
5460+ <param name="name">The name of the desired template.</param>
5461+ <param name="encoding">Character encoding of the template</param>
5462+ <returns>The template.</returns>
5463+ <exception cref="T:NVelocity.Exception.ResourceNotFoundException">
5464+ if template not found from any available source.
5465+ </exception>
5466+ <exception cref="T:NVelocity.Exception.ParseErrorException">
5467+ if template cannot be parsed due to syntax (or other) error.
5468+ </exception>
5469+ <exception cref="N:NVelocity.Runtime.Exception">
5470+ if an error occurs in template initialization
5471+ </exception>
5472+ </member>
5473+ <member name="M:NVelocity.Runtime.RuntimeInstance.GetContent(System.String)">
5474+ <summary>
5475+ Returns a static content resource from the
5476+ resource manager. Uses the current value
5477+ if <c>INPUT_ENCODING</c> as the character encoding.
5478+ </summary>
5479+ <param name="name">Name of content resource to get</param>
5480+ <returns>ContentResource object ready for use</returns>
5481+ <exception cref="T:NVelocity.Exception.ResourceNotFoundException">
5482+ if template not found from any available source.
5483+ </exception>
5484+ </member>
5485+ <member name="M:NVelocity.Runtime.RuntimeInstance.GetContent(System.String,System.String)">
5486+ <summary>
5487+ Returns a static content resource from the
5488+ resource manager.
5489+ </summary>
5490+ <param name="name">Name of content resource to get</param>
5491+ <param name="encoding">Character encoding to use</param>
5492+ <returns>ContentResource object ready for use</returns>
5493+ <exception cref="T:NVelocity.Exception.ResourceNotFoundException">
5494+ if template not found from any available source.
5495+ </exception>
5496+ </member>
5497+ <member name="M:NVelocity.Runtime.RuntimeInstance.GetLoaderNameForResource(System.String)">
5498+ <summary>
5499+ Determines is a template exists, and returns name of the loader that
5500+ provides it. This is a slightly less hokey way to support
5501+ the <c>Velocity.templateExists()</c> utility method, which was broken
5502+ when per-template encoding was introduced. We can revisit this.
5503+ </summary>
5504+ <param name="resourceName">Name of template or content resource</param>
5505+ <returns>class name of loader than can provide it</returns>
5506+ </member>
5507+ <member name="M:NVelocity.Runtime.RuntimeInstance.showStackTrace">
5508+ <summary>
5509+ Added this to check and make sure that the configuration
5510+ is initialized before trying to get properties from it.
5511+ This occurs when there are errors during initialization
5512+ and the default properties have yet to be layed down.
5513+ </summary>
5514+ </member>
5515+ <member name="M:NVelocity.Runtime.RuntimeInstance.Log(NVelocity.Runtime.Log.LogLevel,System.Object)">
5516+ <summary>
5517+ Handle logging.
5518+ </summary>
5519+ <param name="level">log level</param>
5520+ <param name="message">message to log</param>
5521+ </member>
5522+ <member name="M:NVelocity.Runtime.RuntimeInstance.Warn(System.Object)">
5523+ <summary>
5524+ Log a warning message.
5525+ </summary>
5526+ <param name="message">message to log</param>
5527+ </member>
5528+ <member name="M:NVelocity.Runtime.RuntimeInstance.Info(System.Object)">
5529+ <summary>
5530+ Log an info message.
5531+ </summary>
5532+ <param name="message">message to log</param>
5533+ </member>
5534+ <member name="M:NVelocity.Runtime.RuntimeInstance.Error(System.Object)">
5535+ <summary>
5536+ Log an error message.
5537+ </summary>
5538+ <param name="message">message to log</param>
5539+ </member>
5540+ <member name="M:NVelocity.Runtime.RuntimeInstance.Debug(System.Object)">
5541+ <summary>
5542+ Log a debug message.
5543+ </summary>
5544+ <param name="message">message to log</param>
5545+ </member>
5546+ <member name="M:NVelocity.Runtime.RuntimeInstance.GetString(System.String,System.String)">
5547+ <summary>
5548+ String property accessor method with default to hide the
5549+ configuration implementation.
5550+ </summary>
5551+ <param name="key">key property key</param>
5552+ <param name="defaultValue">default value to return if key not found in resource manager.</param>
5553+ <returns>String value of key or default</returns>
5554+ </member>
5555+ <member name="M:NVelocity.Runtime.RuntimeInstance.GetVelocimacro(System.String,System.String)">
5556+ <summary>
5557+ Returns the appropriate VelocimacroProxy object if strVMname
5558+ is a valid current Velocimacro.
5559+ </summary>
5560+ <param name="vmName">Name of velocimacro requested</param>
5561+ <param name="templateName">Name of template</param>
5562+ <returns>VelocimacroProxy</returns>
5563+ </member>
5564+ <member name="M:NVelocity.Runtime.RuntimeInstance.AddVelocimacro(System.String,System.String,System.String[],System.String)">
5565+ <summary>
5566+ Adds a new Velocimacro. Usually called by Macro only while parsing.
5567+ </summary>
5568+ <param name="name">Name of velocimacro</param>
5569+ <param name="macro">String form of macro body</param>
5570+ <param name="argArray">Array of strings, containing the #macro() arguments. the 0th is the name.</param>
5571+ <param name="sourceTemplate">Name of template</param>
5572+ <returns>
5573+ True if added, false if rejected for some
5574+ reason (either parameters or permission settings)
5575+ </returns>
5576+ </member>
5577+ <member name="M:NVelocity.Runtime.RuntimeInstance.IsVelocimacro(System.String,System.String)">
5578+ <summary>
5579+ Checks to see if a VM exists
5580+ </summary>
5581+ <param name="vmName">Name of velocimacro</param>
5582+ <param name="templateName">Name of template</param>
5583+ <returns>
5584+ True if VM by that name exists, false if not
5585+ </returns>
5586+ </member>
5587+ <member name="M:NVelocity.Runtime.RuntimeInstance.DumpVMNamespace(System.String)">
5588+ <summary>
5589+ Tells the vmFactory to dump the specified namespace.
5590+ This is to support clearing the VM list when in
5591+ <c>inline-VM-local-scope</c> mode.
5592+ </summary>
5593+ </member>
5594+ <member name="M:NVelocity.Runtime.RuntimeInstance.GetString(System.String)">
5595+ <summary>
5596+ String property accessor method to hide the configuration implementation
5597+ </summary>
5598+ <param name="key">property key</param>
5599+ <returns>value of key or null</returns>
5600+ </member>
5601+ <member name="M:NVelocity.Runtime.RuntimeInstance.GetInt(System.String)">
5602+ <summary>
5603+ Int property accessor method to hide the configuration implementation.
5604+ </summary>
5605+ <param name="key">property key</param>
5606+ <returns>value</returns>
5607+ </member>
5608+ <member name="M:NVelocity.Runtime.RuntimeInstance.GetInt(System.String,System.Int32)">
5609+ <summary>
5610+ Int property accessor method to hide the configuration implementation.
5611+ </summary>
5612+ <param name="key">property key</param>
5613+ <param name="defaultValue">default value</param>
5614+ <returns>value</returns>
5615+ </member>
5616+ <member name="M:NVelocity.Runtime.RuntimeInstance.GetBoolean(System.String,System.Boolean)">
5617+ <summary>
5618+ Boolean property accessor method to hide the configuration implementation.
5619+ </summary>
5620+ <param name="key">property key</param>
5621+ <param name="def">default value if property not found</param>
5622+ <returns>boolean value of key or default value</returns>
5623+ </member>
5624+ <member name="M:NVelocity.Runtime.RuntimeInstance.GetApplicationAttribute(System.Object)">
5625+ <summary>
5626+ Return the velocity runtime configuration object.
5627+ </summary>
5628+ <returns>
5629+ ExtendedProperties configuration object which houses
5630+ the velocity runtime properties.
5631+ </returns>
5632+ </member>
5633+ <member name="P:NVelocity.Runtime.RuntimeInstance.Uberspect">
5634+ <summary>
5635+ Return the Introspector for this instance
5636+ </summary>
5637+ </member>
5638+ <member name="T:NVelocity.Runtime.RuntimeSingleton">
5639+ <summary>
5640+ This is the Runtime system for Velocity. It is the
5641+ single access point for all functionality in Velocity.
5642+ It adheres to the mediator pattern and is the only
5643+ structure that developers need to be familiar with
5644+ in order to get Velocity to perform.
5645+
5646+ The Runtime will also cooperate with external
5647+ systems like Turbine. Runtime properties can
5648+ set and then the Runtime is initialized.
5649+
5650+ Turbine for example knows where the templates
5651+ are to be loaded from, and where the velocity
5652+ log file should be placed.
5653+
5654+ So in the case of Velocity cooperating with Turbine
5655+ the code might look something like the following:
5656+
5657+ <pre>
5658+ RuntimeSingleton.setProperty(RuntimeConstants.FILE_RESOURCE_LOADER_PATH, templatePath);
5659+ RuntimeSingleton.setProperty(RuntimeConstants.RUNTIME_LOG, pathToVelocityLog);
5660+ RuntimeSingleton.init();
5661+ </pre>
5662+ <pre>
5663+ -----------------------------------------------------------------------
5664+ N O T E S O N R U N T I M E I N I T I A L I Z A T I O N
5665+ -----------------------------------------------------------------------
5666+ RuntimeSingleton.init()
5667+
5668+ If Runtime.init() is called by itself the Runtime will
5669+ initialize with a set of default values.
5670+ -----------------------------------------------------------------------
5671+ RuntimeSingleton.init(String/Properties)
5672+
5673+ In this case the default velocity properties are layed down
5674+ first to provide a solid base, then any properties provided
5675+ in the given properties object will override the corresponding
5676+ default property.
5677+ -----------------------------------------------------------------------
5678+ </pre>
5679+ </summary>
5680+ <author><a href="mailto:jvanzyl@apache.org">Jason van Zyl</a></author>
5681+ <author><a href="mailto:jlb@houseofdistraction.com">Jeff Bowden</a></author>
5682+ <author><a href="mailto:geirm@optonline.net">Geir Magusson Jr.</a></author>
5683+ <author><a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a></author>
5684+ <version> $Id: RuntimeSingleton.cs,v 1.5 2004/12/27 05:59:46 corts Exp $
5685+
5686+ </version>
5687+ </member>
5688+ <member name="M:NVelocity.Runtime.RuntimeSingleton.Init">
5689+ <summary>
5690+ This is the primary initialization method in the Velocity
5691+ Runtime. The systems that are setup/initialized here are
5692+ as follows:
5693+ <list type="">
5694+ <item>Logging System</item>
5695+ <item>ResourceManager</item>
5696+ <item>Parser Pool</item>
5697+ <item>Global Cache</item>
5698+ <item>Static Content Include System</item>
5699+ <item>Velocimacro System</item>
5700+ </list>
5701+ </summary>
5702+ </member>
5703+ <member name="M:NVelocity.Runtime.RuntimeSingleton.SetProperty(System.String,System.Object)">
5704+ <summary>
5705+ Allows an external system to set a property in
5706+ the Velocity Runtime.
5707+ </summary>
5708+ <param name="key">property key</param>
5709+ <param name="value">property value</param>
5710+ </member>
5711+ <member name="M:NVelocity.Runtime.RuntimeSingleton.AddProperty(System.String,System.Object)">
5712+ <summary> Add a property to the configuration. If it already
5713+ exists then the value stated here will be added
5714+ to the configuration entry. For example, if
5715+
5716+ <code>resource.loader = file</code>
5717+
5718+ is already present in the configuration and you
5719+
5720+ <code>addProperty("resource.loader", "classpath")</code>
5721+
5722+ Then you will end up with an ArrayList like the
5723+ following:
5724+
5725+ ["file", "classpath"]
5726+ </summary>
5727+ <param name="key">key</param>
5728+ <param name="value">value</param>
5729+ </member>
5730+ <member name="M:NVelocity.Runtime.RuntimeSingleton.ClearProperty(System.String)">
5731+ <summary>
5732+ Clear the values pertaining to a particular property.
5733+ </summary>
5734+ <param name="key">key of property to clear</param>
5735+ </member>
5736+ <member name="M:NVelocity.Runtime.RuntimeSingleton.GetProperty(System.String)">
5737+ <summary>
5738+ Allows an external caller to get a property. The calling
5739+ routine is required to know the type, as this routine
5740+ will return an Object, as that is what properties can be.
5741+ </summary>
5742+ <param name="key">property to return</param>
5743+ </member>
5744+ <member name="M:NVelocity.Runtime.RuntimeSingleton.Init(Commons.Collections.ExtendedProperties)">
5745+ <summary>
5746+ Initialize the Velocity Runtime with an ExtendedProperties object.
5747+ </summary>
5748+ <param name="p">Properties</param>
5749+ </member>
5750+ <member name="M:NVelocity.Runtime.RuntimeSingleton.Init(System.String)">
5751+ <summary> Initialize the Velocity Runtime with a configuration file.</summary>
5752+ <param name="configurationFile">configuration file</param>
5753+ </member>
5754+ <member name="M:NVelocity.Runtime.RuntimeSingleton.CreateNewParser">
5755+ <summary>
5756+ Returns a JavaCC generated Parser.
5757+ </summary>
5758+ <returns>Parser javacc generated parser</returns>
5759+ </member>
5760+ <member name="M:NVelocity.Runtime.RuntimeSingleton.Parse(System.IO.TextReader,System.String)">
5761+ <summary> Parse the input and return the root of
5762+ AST node structure.
5763+ </summary>
5764+ <remarks>
5765+ In the event that it runs out of parsers in the
5766+ pool, it will create and let them be GC'd
5767+ dynamically, logging that it has to do that. This
5768+ is considered an exceptional condition. It is
5769+ expected that the user will set the
5770+ PARSER_POOL_SIZE property appropriately for their
5771+ application. We will revisit this.
5772+ </remarks>
5773+ <param name="reader">TextReader retrieved by a resource loader</param>
5774+ <param name="templateName">name of the template being parsed</param>
5775+ </member>
5776+ <member name="M:NVelocity.Runtime.RuntimeSingleton.Parse(System.IO.TextReader,System.String,System.Boolean)">
5777+ <summary>
5778+ Parse the input and return the root of the AST node structure.
5779+ </summary>
5780+ <param name="reader">TextReader retrieved by a resource loader</param>
5781+ <param name="templateName">name of the template being parsed</param>
5782+ <param name="dumpNamespace">flag to dump the Velocimacro namespace for this template</param>
5783+ </member>
5784+ <member name="M:NVelocity.Runtime.RuntimeSingleton.GetTemplate(System.String)">
5785+ <summary> Returns a <code>Template</code> from the resource manager.
5786+ This method assumes that the character encoding of the
5787+ template is set by the <code>input.encoding</code>
5788+ property. The default is "ISO-8859-1"
5789+ *
5790+ </summary>
5791+ <param name="name">The file name of the desired template.
5792+ </param>
5793+ <returns> The template.
5794+ @throws ResourceNotFoundException if template not found
5795+ from any available source.
5796+ @throws ParseErrorException if template cannot be parsed due
5797+ to syntax (or other) error.
5798+ @throws Exception if an error occurs in template initialization
5799+
5800+ </returns>
5801+ </member>
5802+ <member name="M:NVelocity.Runtime.RuntimeSingleton.GetTemplate(System.String,System.String)">
5803+ <summary> Returns a <code>Template</code> from the resource manager
5804+ *
5805+ </summary>
5806+ <param name="name">The name of the desired template.
5807+ </param>
5808+ <param name="encoding">Character encoding of the template
5809+ </param>
5810+ <returns> The template.
5811+ @throws ResourceNotFoundException if template not found
5812+ from any available source.
5813+ @throws ParseErrorException if template cannot be parsed due
5814+ to syntax (or other) error.
5815+ @throws Exception if an error occurs in template initialization
5816+
5817+ </returns>
5818+ </member>
5819+ <member name="M:NVelocity.Runtime.RuntimeSingleton.GetContent(System.String)">
5820+ <summary> Returns a static content resource from the
5821+ resource manager. Uses the current value
5822+ if INPUT_ENCODING as the character encoding.
5823+ *
5824+ </summary>
5825+ <param name="name">Name of content resource to get
5826+ </param>
5827+ <returns>parsed ContentResource object ready for use
5828+ @throws ResourceNotFoundException if template not found
5829+ from any available source.
5830+
5831+ </returns>
5832+ </member>
5833+ <member name="M:NVelocity.Runtime.RuntimeSingleton.GetContent(System.String,System.String)">
5834+ <summary> Returns a static content resource from the
5835+ resource manager.
5836+ *
5837+ </summary>
5838+ <param name="name">Name of content resource to get
5839+ </param>
5840+ <param name="encoding">Character encoding to use
5841+ </param>
5842+ <returns>parsed ContentResource object ready for use
5843+ @throws ResourceNotFoundException if template not found
5844+ from any available source.
5845+
5846+ </returns>
5847+ </member>
5848+ <member name="M:NVelocity.Runtime.RuntimeSingleton.GetLoaderNameForResource(System.String)">
5849+ <summary> Determines is a template exists, and returns name of the loader that
5850+ provides it. This is a slightly less hokey way to support
5851+ the Velocity.templateExists() utility method, which was broken
5852+ when per-template encoding was introduced. We can revisit this.
5853+ *
5854+ </summary>
5855+ <param name="resourceName">Name of template or content resource
5856+ </param>
5857+ <returns>class name of loader than can provide it
5858+
5859+ </returns>
5860+ </member>
5861+ <member name="M:NVelocity.Runtime.RuntimeSingleton.Warn(System.Object)">
5862+ <summary>
5863+ Log a warning message.
5864+ </summary>
5865+ <param name="message">message to log</param>
5866+ </member>
5867+ <member name="M:NVelocity.Runtime.RuntimeSingleton.Info(System.Object)">
5868+
5869+ <summary>
5870+ Log an info message.
5871+ </summary>
5872+ <param name="message">message to log</param>
5873+ </member>
5874+ <member name="M:NVelocity.Runtime.RuntimeSingleton.Error(System.Object)">
5875+ <summary>
5876+ Log an error message.
5877+ </summary>
5878+ <param name="message">message to log</param>
5879+ </member>
5880+ <member name="M:NVelocity.Runtime.RuntimeSingleton.Debug(System.Object)">
5881+ <summary>
5882+ Log a debug message.
5883+ </summary>
5884+ <param name="message">message to log</param>
5885+ </member>
5886+ <member name="M:NVelocity.Runtime.RuntimeSingleton.getString(System.String,System.String)">
5887+ <summary> String property accessor method with default to hide the
5888+ configuration implementation.
5889+
5890+ </summary>
5891+ <param name="key">property key
5892+ </param>
5893+ <param name="defaultValue">default value to return if key not
5894+ found in resource manager.
5895+ </param>
5896+ <returns>String value of key or default
5897+
5898+ </returns>
5899+ </member>
5900+ <member name="M:NVelocity.Runtime.RuntimeSingleton.GetVelocimacro(System.String,System.String)">
5901+ <summary>
5902+ Returns the appropriate VelocimacroProxy object if vmName
5903+ is a valid current Velocimacro.
5904+ </summary>
5905+ <param name="vmName">Name of velocimacro requested</param>
5906+ <param name="templateName">Template Name</param>
5907+ <returns>VelocimacroProxy</returns>
5908+ </member>
5909+ <member name="M:NVelocity.Runtime.RuntimeSingleton.AddVelocimacro(System.String,System.String,System.String[],System.String)">
5910+ <summary>
5911+ Adds a new Velocimacro. Usually called by Macro only while parsing.
5912+ </summary>
5913+ <param name="name">Name of velocimacro</param>
5914+ <param name="macro">String form of macro body</param>
5915+ <param name="argArray">Array of strings, containing the
5916+ <code>#macro()</code> arguments. The 0th is the name.
5917+ </param>
5918+ <param name="sourceTemplate">Source template</param>
5919+ <returns>True if added, false if rejected for some
5920+ reason (either parameters or permission settings)
5921+ </returns>
5922+ </member>
5923+ <member name="M:NVelocity.Runtime.RuntimeSingleton.IsVelocimacro(System.String,System.String)">
5924+ <summary>
5925+ Checks to see if a VM exists
5926+ </summary>
5927+ <param name="vmName">Name of velocimacro</param>
5928+ <param name="templateName">Template Name</param>
5929+ <returns>True if VM by that name exists, false if not</returns>
5930+ </member>
5931+ <member name="M:NVelocity.Runtime.RuntimeSingleton.DumpVMNamespace(System.String)">
5932+ <summary>
5933+ Tells the vmFactory to dump the specified namespace.
5934+ This is to support clearing the VM list when in
5935+ inline-VM-local-scope mode
5936+ </summary>
5937+ </member>
5938+ <member name="M:NVelocity.Runtime.RuntimeSingleton.GetString(System.String)">
5939+ <summary>
5940+ String property accessor method to hide the configuration implementation.
5941+ </summary>
5942+ <param name="key">property key</param>
5943+ <returns>Value of key or <c>null</c></returns>
5944+ </member>
5945+ <member name="M:NVelocity.Runtime.RuntimeSingleton.GetInt(System.String)">
5946+ <summary>
5947+ Int property accessor method to hide the configuration implementation.
5948+ </summary>
5949+ <param name="key">property key</param>
5950+ <returns>value</returns>
5951+ </member>
5952+ <member name="M:NVelocity.Runtime.RuntimeSingleton.GetInt(System.String,System.Int32)">
5953+ <summary>
5954+ Int property accessor method to hide the configuration implementation.
5955+ </summary>
5956+ <param name="key">property key</param>
5957+ <param name="defaultValue">default value</param>
5958+ <returns>value</returns>
5959+ </member>
5960+ <member name="M:NVelocity.Runtime.RuntimeSingleton.GetBoolean(System.String,System.Boolean)">
5961+ <summary>
5962+ Boolean property accessor method to hide the configuration implementation.
5963+ </summary>
5964+ <param name="key">property key</param>
5965+ <param name="def">default value if property not found</param>
5966+ <returns>value of key or default value</returns>
5967+ </member>
5968+ <member name="M:NVelocity.Runtime.RuntimeSingleton.GetApplicationAttribute(System.Object)">
5969+ <summary>
5970+ <seealso cref="M:NVelocity.Runtime.IRuntimeServices.GetApplicationAttribute(System.Object)"/>
5971+ </summary>
5972+ <param name="key">key</param>
5973+ <returns>value</returns>
5974+ </member>
5975+ <member name="P:NVelocity.Runtime.RuntimeSingleton.Configuration">
5976+ <summary>
5977+ Return the velocity runtime configuration object.
5978+ </summary>
5979+ <returns>
5980+ ExtendedProperties configuration object which houses
5981+ the velocity runtime properties.
5982+ </returns>
5983+ </member>
5984+ <member name="P:NVelocity.Runtime.RuntimeSingleton.Introspector">
5985+ <summary>
5986+ Return the Introspector for this RuntimeInstance
5987+ </summary>
5988+ <returns>
5989+ Introspector object for this runtime instance
5990+ </returns>
5991+ </member>
5992+ <member name="P:NVelocity.Runtime.RuntimeSingleton.RuntimeInstance">
5993+ <summary>
5994+ Returns the RuntimeInstance object for this singleton.
5995+ For internal use only.
5996+ </summary>
5997+ <returns>
5998+ The <see cref="P:NVelocity.Runtime.RuntimeSingleton.RuntimeInstance"/> used by this Singleton instance.
5999+ </returns>
6000+ </member>
6001+ <member name="T:NVelocity.Runtime.VelocimacroFactory">
6002+ <summary> VelocimacroFactory.java
6003+ *
6004+ manages the set of VMs in a running Velocity engine.
6005+ *
6006+ </summary>
6007+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
6008+ </author>
6009+ <version> $Id: VelocimacroFactory.cs,v 1.5 2003/10/27 15:37:24 corts Exp $
6010+
6011+ </version>
6012+ </member>
6013+ <member name="F:NVelocity.Runtime.VelocimacroFactory.runtimeServices">
6014+ <summary> runtime services for this instance
6015+ </summary>
6016+ </member>
6017+ <member name="F:NVelocity.Runtime.VelocimacroFactory.velocimacroManager">
6018+ <summary> VMManager : deal with namespace management
6019+ and actually keeps all the VM definitions
6020+ </summary>
6021+ </member>
6022+ <member name="F:NVelocity.Runtime.VelocimacroFactory.replaceAllowed">
6023+ <summary> determines if replacement of global VMs are allowed
6024+ controlled by VM_PERM_ALLOW_INLINE_REPLACE_GLOBAL
6025+ </summary>
6026+ </member>
6027+ <member name="F:NVelocity.Runtime.VelocimacroFactory.addNewAllowed">
6028+ <summary> controls if new VMs can be added. Set by
6029+ VM_PERM_ALLOW_INLINE Note the assumption that only
6030+ through inline defs can this happen.
6031+ additions through auto-loaded VMs is allowed
6032+ </summary>
6033+ </member>
6034+ <member name="F:NVelocity.Runtime.VelocimacroFactory.templateLocal">
6035+ <summary> sets if template-local namespace in used
6036+ </summary>
6037+ </member>
6038+ <member name="F:NVelocity.Runtime.VelocimacroFactory.blather">
6039+ <summary> controls log output
6040+ </summary>
6041+ </member>
6042+ <member name="F:NVelocity.Runtime.VelocimacroFactory.autoReloadLibrary">
6043+ <summary> determines if the libraries are auto-loaded
6044+ when they change
6045+ </summary>
6046+ </member>
6047+ <member name="F:NVelocity.Runtime.VelocimacroFactory.macroLibVec">
6048+ <summary> vector of the library names
6049+ </summary>
6050+ </member>
6051+ <member name="F:NVelocity.Runtime.VelocimacroFactory.libModMap">
6052+ <summary> map of the library Template objects
6053+ used for reload determination
6054+ </summary>
6055+ </member>
6056+ <member name="M:NVelocity.Runtime.VelocimacroFactory.#ctor(NVelocity.Runtime.IRuntimeServices)">
6057+ <summary> CTOR : requires a runtime services from now
6058+ on
6059+ </summary>
6060+ </member>
6061+ <member name="M:NVelocity.Runtime.VelocimacroFactory.InitVelocimacro">
6062+ <summary> initialize the factory - setup all permissions
6063+ load all global libraries.
6064+ </summary>
6065+ </member>
6066+ <member name="M:NVelocity.Runtime.VelocimacroFactory.AddVelocimacro(System.String,System.String,System.String[],System.String)">
6067+ <summary> adds a macro to the factory.
6068+ </summary>
6069+ </member>
6070+ <member name="M:NVelocity.Runtime.VelocimacroFactory.CanAddVelocimacro(System.String,System.String)">
6071+ <summary> determines if a given macro/namespace (name, source) combo is allowed
6072+ to be added
6073+ *
6074+ </summary>
6075+ <param name="name">Name of VM to add
6076+ </param>
6077+ <param name="sourceTemplate">Source template that contains the definition of the VM
6078+ </param>
6079+ <returns>true if it is allowed to be added, false otherwise
6080+
6081+ </returns>
6082+ </member>
6083+ <member name="M:NVelocity.Runtime.VelocimacroFactory.LogVMMessageInfo(System.String)">
6084+ <summary> localization of the logging logic
6085+ </summary>
6086+ </member>
6087+ <member name="M:NVelocity.Runtime.VelocimacroFactory.LogVMMessageWarn(System.String)">
6088+ <summary> localization of the logging logic
6089+ </summary>
6090+ </member>
6091+ <member name="M:NVelocity.Runtime.VelocimacroFactory.IsVelocimacro(System.String,System.String)">
6092+ <summary> Tells the world if a given directive string is a Velocimacro
6093+ </summary>
6094+ </member>
6095+ <member name="M:NVelocity.Runtime.VelocimacroFactory.GetVelocimacro(System.String,System.String)">
6096+ <summary> actual factory : creates a Directive that will
6097+ behave correctly wrt getting the framework to
6098+ dig out the correct # of args
6099+ </summary>
6100+ </member>
6101+ <member name="M:NVelocity.Runtime.VelocimacroFactory.DumpVMNamespace(System.String)">
6102+ <summary> tells the velocimacroManager to dump the specified namespace
6103+ </summary>
6104+ </member>
6105+ <member name="T:NVelocity.Runtime.VelocimacroFactory.Twonk">
6106+ <summary> sets permission to have VMs local in scope to their declaring template
6107+ note that this is really taken care of in the VMManager class, but
6108+ we need it here for gating purposes in addVM
6109+ eventually, I will slide this all into the manager, maybe.
6110+ </summary>
6111+ <summary> sets the permission to add new macros
6112+ </summary>
6113+ <summary> sets the permission for allowing addMacro() calls to
6114+ replace existing VM's
6115+ </summary>
6116+ <summary> set output message mode
6117+ </summary>
6118+ <summary> get output message mode
6119+ </summary>
6120+ <summary> set the switch for automatic reloading of
6121+ global library-based VMs
6122+ </summary>
6123+ <summary> get the switch for automatic reloading of
6124+ global library-based VMs
6125+ </summary>
6126+ <summary> small container class to hold the duple
6127+ of a template and modification time.
6128+ We keep the modification time so we can
6129+ 'override' it on a reload to prevent
6130+ recursive reload due to inter-calling
6131+ VMs in a library
6132+ </summary>
6133+ </member>
6134+ <member name="T:NVelocity.Runtime.VelocimacroManager">
6135+ <summary>
6136+ Manages VMs in namespaces. Currently, two namespace modes are
6137+ supported:
6138+ *
6139+ <ul>
6140+ <li>flat - all allowable VMs are in the global namespace</li>
6141+ <li>local - inline VMs are added to it's own template namespace</li>
6142+ </ul>
6143+ *
6144+ Thanks to <a href="mailto:JFernandez@viquity.com">Jose Alberto Fernandez</a>
6145+ for some ideas incorporated here.
6146+ *
6147+ </summary>
6148+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
6149+ </author>
6150+ <author> <a href="mailto:JFernandez@viquity.com">Jose Alberto Fernandez</a>
6151+ </author>
6152+ </member>
6153+ <member name="F:NVelocity.Runtime.VelocimacroManager.namespaceHash">
6154+ <summary>Hash of namespace hashes.
6155+ </summary>
6156+ </member>
6157+ <member name="F:NVelocity.Runtime.VelocimacroManager.libraryMap">
6158+ <summary>map of names of library templates/namespaces</summary>
6159+ </member>
6160+ <member name="M:NVelocity.Runtime.VelocimacroManager.#ctor(NVelocity.Runtime.IRuntimeServices)">
6161+ <summary> Adds the global namespace to the hash.</summary>
6162+ </member>
6163+ <member name="M:NVelocity.Runtime.VelocimacroManager.AddVM(System.String,System.String,System.String[],System.String)">
6164+ <summary> Adds a VM definition to the cache.
6165+ </summary>
6166+ <returns>Whether everything went okay.
6167+
6168+ </returns>
6169+ </member>
6170+ <member name="M:NVelocity.Runtime.VelocimacroManager.get(System.String,System.String)">
6171+ <summary> gets a new living VelocimacroProxy object by the
6172+ name / source template duple
6173+ </summary>
6174+ </member>
6175+ <member name="M:NVelocity.Runtime.VelocimacroManager.DumpNamespace(System.String)">
6176+ <summary> Removes the VMs and the namespace from the manager.
6177+ Used when a template is reloaded to avoid
6178+ accumulating drek
6179+ </summary>
6180+ <param name="ns">namespace to dump
6181+ </param>
6182+ <returns>boolean representing success
6183+
6184+ </returns>
6185+ </member>
6186+ <member name="M:NVelocity.Runtime.VelocimacroManager.GetNamespace(System.String)">
6187+ <summary>
6188+ public switch to let external user of manager to control namespace
6189+ usage indep of properties. That way, for example, at startup the
6190+ library files are loaded into global namespace
6191+
6192+ returns the hash for the specified namespace. Will not create a new one
6193+ if it doesn't exist
6194+ </summary>
6195+ <param name="ns"> name of the namespace :) </param>
6196+ <returns>namespace Hashtable of VMs or null if doesn't exist </returns>
6197+ </member>
6198+ <member name="M:NVelocity.Runtime.VelocimacroManager.GetNamespace(System.String,System.Boolean)">
6199+ <summary>
6200+ returns the hash for the specified namespace, and if it doesn't exist
6201+ will create a new one and add it to the namespaces
6202+ </summary>
6203+ <param name="ns"> name of the namespace :)</param>
6204+ <param name="addIfNew"> flag to add a new namespace if it doesn't exist</param>
6205+ <returns>namespace Hashtable of VMs or null if doesn't exist</returns>
6206+ </member>
6207+ <member name="M:NVelocity.Runtime.VelocimacroManager.AddNamespace(System.String)">
6208+ <summary>adds a namespace to the namespaces</summary>
6209+ <param name="ns">name of namespace to add</param>
6210+ <returns>Hash added to namespaces, ready for use</returns>
6211+ </member>
6212+ <member name="M:NVelocity.Runtime.VelocimacroManager.UsingNamespaces(System.String)">
6213+ <summary>determines if currently using namespaces.</summary>
6214+ <param name="ns">currently ignored</param>
6215+ <returns>true if using namespaces, false if not</returns>
6216+ </member>
6217+ <member name="T:NVelocity.Runtime.VelocimacroManager.MacroEntry">
6218+ <summary> wrapper class for holding VM information
6219+ </summary>
6220+ </member>
6221+ <member name="T:NVelocity.Runtime.Visitor.BaseVisitor">
6222+ <summary> This is the base class for all visitors.
6223+ For each AST node, this class will provide
6224+ a bare-bones method for traversal.
6225+ *
6226+ </summary>
6227+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
6228+ </author>
6229+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
6230+ </author>
6231+ <version> $Id: BaseVisitor.cs,v 1.3 2003/10/27 13:54:11 corts Exp $
6232+
6233+ </version>
6234+ </member>
6235+ <member name="F:NVelocity.Runtime.Visitor.BaseVisitor.context">
6236+ <summary>
6237+ Context used during traversal
6238+ </summary>
6239+ </member>
6240+ <member name="F:NVelocity.Runtime.Visitor.BaseVisitor.writer">
6241+ <summary>
6242+ Writer used as the output sink
6243+ </summary>
6244+ </member>
6245+ <member name="T:NVelocity.Runtime.Visitor.NodeViewMode">
6246+ <summary> This class is simply a visitor implementation
6247+ that traverses the AST, produced by the Velocity
6248+ parsing process, and creates a visual structure
6249+ of the AST. This is primarily used for
6250+ debugging, but it useful for documentation
6251+ as well.
6252+ *
6253+ </summary>
6254+ <author> <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
6255+ </author>
6256+ <version> $Id: NodeViewMode.cs,v 1.3 2003/10/27 13:54:11 corts Exp $
6257+
6258+ </version>
6259+ </member>
6260+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.IndentString">
6261+ <summary>Indent child nodes to help visually identify
6262+ the structure of the AST.
6263+ </summary>
6264+ </member>
6265+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.ShowNode(NVelocity.Runtime.Parser.Node.INode,System.Object)">
6266+ <summary> Display the type of nodes and optionally the
6267+ first token.
6268+ </summary>
6269+ </member>
6270+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.SimpleNode,System.Object)">
6271+ <summary>Display a SimpleNode
6272+ </summary>
6273+ </member>
6274+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTprocess,System.Object)">
6275+ <summary>Display an ASTprocess node
6276+ </summary>
6277+ </member>
6278+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTExpression,System.Object)">
6279+ <summary>Display an ASTExpression node
6280+ </summary>
6281+ </member>
6282+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTAssignment,System.Object)">
6283+ <summary>Display an ASTAssignment node ( = )
6284+ </summary>
6285+ </member>
6286+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTOrNode,System.Object)">
6287+ <summary>Display an ASTOrNode ( || )
6288+ </summary>
6289+ </member>
6290+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTAndNode,System.Object)">
6291+ <summary>Display an ASTAndNode ( &amp;&amp; )
6292+ </summary>
6293+ </member>
6294+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTEQNode,System.Object)">
6295+ <summary>Display an ASTEQNode ( == )
6296+ </summary>
6297+ </member>
6298+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTNENode,System.Object)">
6299+ <summary>Display an ASTNENode ( != )
6300+ </summary>
6301+ </member>
6302+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTLTNode,System.Object)">
6303+ <summary>Display an ASTLTNode ( &lt; )
6304+ </summary>
6305+ </member>
6306+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTGTNode,System.Object)">
6307+ <summary>Display an ASTGTNode ( &gt; )
6308+ </summary>
6309+ </member>
6310+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTLENode,System.Object)">
6311+ <summary>Display an ASTLENode ( &lt;= )
6312+ </summary>
6313+ </member>
6314+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTGENode,System.Object)">
6315+ <summary>Display an ASTGENode ( &gt;= )
6316+ </summary>
6317+ </member>
6318+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTAddNode,System.Object)">
6319+ <summary>Display an ASTAddNode ( + )
6320+ </summary>
6321+ </member>
6322+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTSubtractNode,System.Object)">
6323+ <summary>Display an ASTSubtractNode ( - )
6324+ </summary>
6325+ </member>
6326+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTMulNode,System.Object)">
6327+ <summary>Display an ASTMulNode ( * )
6328+ </summary>
6329+ </member>
6330+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTDivNode,System.Object)">
6331+ <summary>Display an ASTDivNode ( / )
6332+ </summary>
6333+ </member>
6334+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTModNode,System.Object)">
6335+ <summary>Display an ASTModNode ( % )
6336+ </summary>
6337+ </member>
6338+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTNotNode,System.Object)">
6339+ <summary>Display an ASTNotNode ( ! )
6340+ </summary>
6341+ </member>
6342+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTNumberLiteral,System.Object)">
6343+ <summary>Display an ASTNumberLiteral node
6344+ </summary>
6345+ </member>
6346+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTStringLiteral,System.Object)">
6347+ <summary>Display an ASTStringLiteral node
6348+ </summary>
6349+ </member>
6350+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTIdentifier,System.Object)">
6351+ <summary>Display an ASTIdentifier node
6352+ </summary>
6353+ </member>
6354+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTMethod,System.Object)">
6355+ <summary>Display an ASTMethod node
6356+ </summary>
6357+ </member>
6358+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTReference,System.Object)">
6359+ <summary>Display an ASTReference node
6360+ </summary>
6361+ </member>
6362+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTTrue,System.Object)">
6363+ <summary>Display an ASTTrue node
6364+ </summary>
6365+ </member>
6366+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTFalse,System.Object)">
6367+ <summary>Display an ASTFalse node
6368+ </summary>
6369+ </member>
6370+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTBlock,System.Object)">
6371+ <summary>Display an ASTBlock node
6372+ </summary>
6373+ </member>
6374+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTText,System.Object)">
6375+ <summary>Display an ASTText node
6376+ </summary>
6377+ </member>
6378+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTIfStatement,System.Object)">
6379+ <summary>Display an ASTIfStatement node
6380+ </summary>
6381+ </member>
6382+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTElseStatement,System.Object)">
6383+ <summary>Display an ASTElseStatement node
6384+ </summary>
6385+ </member>
6386+ <member name="M:NVelocity.Runtime.Visitor.NodeViewMode.Visit(NVelocity.Runtime.Parser.Node.ASTElseIfStatement,System.Object)">
6387+ <summary>Display an ASTElseIfStatement node
6388+ </summary>
6389+ </member>
6390+ <member name="T:NVelocity.Runtime.Visitor.VMReferenceMungeVisitor">
6391+ <summary>
6392+ This class is a visitor used by the VM proxy to change the
6393+ literal representation of a reference in a VM. The reason is
6394+ to preserve the 'render literal if null' behavior w/o making
6395+ the VMProxy stuff more complicated than it is already.
6396+ </summary>
6397+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a></author>
6398+ <version> $Id: VMReferenceMungeVisitor.cs,v 1.3 2003/10/27 13:54:11 corts Exp $</version>
6399+ </member>
6400+ <member name="F:NVelocity.Runtime.Visitor.VMReferenceMungeVisitor.argumentMap">
6401+ <summary>
6402+ Map containing VM arg to instance-use reference
6403+ Passed in with CTOR
6404+ </summary>
6405+ </member>
6406+ <member name="M:NVelocity.Runtime.Visitor.VMReferenceMungeVisitor.#ctor(System.Collections.Hashtable)">
6407+ <summary>
6408+ CTOR - takes a map of args to reference
6409+ </summary>
6410+ </member>
6411+ <member name="M:NVelocity.Runtime.Visitor.VMReferenceMungeVisitor.Visit(NVelocity.Runtime.Parser.Node.ASTReference,System.Object)">
6412+ <summary>
6413+ Visitor method - if the literal is right, will
6414+ set the literal in the ASTReference node
6415+ </summary>
6416+ <param name="node">ASTReference to work on</param>
6417+ <param name="data">Object to pass down from caller</param>
6418+ </member>
6419+ <member name="M:NVelocity.SupportClass.CreateNewInstance(System.Type)">
6420+ <summary>
6421+ Creates an instance of a received Type
6422+ </summary>
6423+ <param name="classType">The Type of the new class instance to return</param>
6424+ <returns>An Object containing the new instance</returns>
6425+ </member>
6426+ <member name="T:NVelocity.Template">
6427+ <summary>
6428+ This class is used for controlling all template
6429+ operations. This class uses a parser created
6430+ by JavaCC to create an AST that is subsequently
6431+ traversed by a Visitor.
6432+
6433+ <code>
6434+ Template template = Velocity.getTemplate("test.wm");
6435+ IContext context = new VelocityContext();
6436+
6437+ context.Put("foo", "bar");
6438+ context.Put("customer", new Customer());
6439+
6440+ template.Merge(context, writer);
6441+ </code>
6442+ </summary>
6443+ </member>
6444+ <member name="M:NVelocity.Template.Process">
6445+ <summary>
6446+ Gets the named resource as a stream, parses and inits.
6447+ </summary>
6448+ <returns>true if successful</returns>
6449+ <exception cref="T:NVelocity.Exception.ResourceNotFoundException">
6450+ if template not found from any available source.
6451+ </exception>
6452+ <exception cref="T:NVelocity.Exception.ParseErrorException">
6453+ if template cannot be parsed due to syntax (or other) error.
6454+ </exception>
6455+ <exception cref="T:System.Exception">
6456+ some other problem, should only be from initialization of the template AST.
6457+ </exception>
6458+ </member>
6459+ <member name="M:NVelocity.Template.InitDocument">
6460+ <summary>
6461+ initializes the document. init() is not longer
6462+ dependant upon context, but we need to let the
6463+ init() carry the template name down through for VM
6464+ namespace features
6465+ </summary>
6466+ </member>
6467+ <member name="M:NVelocity.Template.Merge(NVelocity.Context.IContext,System.IO.TextWriter)">
6468+ <summary>
6469+ The AST node structure is merged with the
6470+ context to produce the final output.
6471+
6472+ Throws IOException if failure is due to a file related
6473+ issue, and Exception otherwise
6474+ </summary>
6475+ <param name="context">Context with data elements accessed by template</param>
6476+ <param name="writer">writer for rendered template</param>
6477+ <exception cref="T:NVelocity.Exception.ResourceNotFoundException">
6478+ if template not found from any available source.
6479+ </exception>
6480+ <exception cref="T:NVelocity.Exception.ParseErrorException">
6481+ if template cannot be parsed due to syntax (or other) error.
6482+ </exception>
6483+ <exception cref="T:System.Exception">
6484+ anything else.
6485+ </exception>
6486+ </member>
6487+ <member name="T:NVelocity.Tool.DataInfo">
6488+ <summary> ToolInfo implementation to handle "primitive" data types.
6489+ It currently supports String, Number, and Boolean data.
6490+ *
6491+ </summary>
6492+ <author> <a href="mailto:nathan@esha.com">Nathan Bubna</a>
6493+ *
6494+ </author>
6495+ <version> $Id: DataInfo.cs,v 1.2 2003/10/27 13:54:12 corts Exp $
6496+
6497+ </version>
6498+ </member>
6499+ <member name="T:NVelocity.Tool.IToolInfo">
6500+ <summary> Interface to simplify and abstract tool handling.
6501+ *
6502+ Implementations of this class should hold both the context
6503+ key for the tool and sufficient information to return
6504+ an instance of the tool.
6505+ *
6506+ </summary>
6507+ <author> <a href="mailto:nathan@esha.com">Nathan Bubna</a>
6508+ *
6509+ </author>
6510+ <version> $Id: IToolInfo.cs,v 1.2 2003/10/27 13:54:12 corts Exp $
6511+
6512+ </version>
6513+ </member>
6514+ <member name="M:NVelocity.Tool.IToolInfo.getInstance(System.Object)">
6515+ <returns>the context key for the tool
6516+
6517+ </returns>
6518+ <returns>the fully qualified classname for the tool
6519+
6520+ </returns>
6521+ <summary> Returns an instance of the tool.
6522+ *
6523+ Instances returned may be new on each call, pooled, or
6524+ the be same instance every time depending on the
6525+ implementation. The object passed to this method may
6526+ be used to initialize or create the tool that is returned,
6527+ or it may be null if no such data is required.
6528+ *
6529+ </summary>
6530+ <param name="initData">an object that may be used to initialize the instance
6531+ </param>
6532+ <returns>an instance of the tool
6533+
6534+ </returns>
6535+ </member>
6536+ <member name="M:NVelocity.Tool.DataInfo.#ctor(System.String,System.String,System.String)">
6537+ <summary> Parses the value string into a recognized type. If
6538+ the type specified is not supported, the data will
6539+ be held and returned as a string.
6540+ *
6541+ </summary>
6542+ <param name="key">the context key for the data
6543+ </param>
6544+ <param name="type">the data type
6545+ </param>
6546+ <param name="value">the data
6547+
6548+ </param>
6549+ </member>
6550+ <member name="M:NVelocity.Tool.DataInfo.getInstance(System.Object)">
6551+ <summary> Returns the data. Always returns the same
6552+ object since the data is a constant. Initialization
6553+ data is ignored.
6554+ </summary>
6555+ </member>
6556+ <member name="T:NVelocity.Tool.ToolLoader">
6557+ <summary>
6558+ <p>A view tool that allows template designers to load
6559+ an arbitrary object into the context. Any object
6560+ with a public constructor without parameters can be used
6561+ as a view tool.</p>
6562+ <p>THIS CLASS IS HERE AS A PROOF OF CONCEPT ONLY. IT IS NOT
6563+ INTENDED FOR USE IN PRODUCTION ENVIRONMENTS. USE AT YOUR OWN RISK.</p>
6564+ </summary>
6565+ <author><a href="mailto:sidler@teamup.com">Gabe Sidler</a></author>
6566+ <author><a href="mailto:geirm@apache.org">Geir Magnusson Jr.</a></author>
6567+ </member>
6568+ <member name="M:NVelocity.Tool.ToolLoader.Load(System.String)">
6569+ <summary>
6570+ Creates and returns an object of the specified classname.
6571+ The object must have a valid default constructor.
6572+ </summary>
6573+ <param name="className">the fully qualified class name of the object</param>
6574+ <returns>an instance of the specified class or null if the class
6575+ could not be instantiated.</returns>
6576+ </member>
6577+ <member name="T:NVelocity.Util.Introspection.AmbiguousException">
6578+ <summary>
6579+ Simple distinguishable exception, used when
6580+ we run across ambiguous overloading
6581+ </summary>
6582+ </member>
6583+ <member name="M:NVelocity.Util.Introspection.AmbiguousException.#ctor(System.String)">
6584+ <summary>
6585+ Initializes a new instance of the <see cref="T:NVelocity.Util.Introspection.AmbiguousException"/> class.
6586+ </summary>
6587+ <param name="message">The message.</param>
6588+ </member>
6589+ <member name="M:NVelocity.Util.Introspection.AmbiguousException.#ctor(System.String,System.Exception)">
6590+ <summary>
6591+ Initializes a new instance of the <see cref="T:NVelocity.Util.Introspection.AmbiguousException"/> class.
6592+ </summary>
6593+ <param name="message">The message.</param>
6594+ <param name="innerException">The inner exception.</param>
6595+ </member>
6596+ <member name="M:NVelocity.Util.Introspection.AmbiguousException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
6597+ <summary>
6598+ Initializes a new instance of the <see cref="T:NVelocity.Util.Introspection.AmbiguousException"/> class.
6599+ </summary>
6600+ <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"></see> that holds the serialized object data about the exception being thrown.</param>
6601+ <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"></see> that contains contextual information about the source or destination.</param>
6602+ <exception cref="T:System.Runtime.Serialization.SerializationException">The class name is null or <see cref="P:System.Exception.HResult"></see> is zero (0). </exception>
6603+ <exception cref="T:System.ArgumentNullException">The info parameter is null. </exception>
6604+ </member>
6605+ <member name="T:NVelocity.Util.Introspection.ClassMap">
6606+ <summary>
6607+ A cache of introspection information for a specific class instance.
6608+ Keys <see cref="T:System.Reflection.MethodInfo"/> objects by a concatenation of the
6609+ method name and the names of classes that make up the parameters.
6610+ </summary>
6611+ </member>
6612+ <member name="F:NVelocity.Util.Introspection.ClassMap.methodCache">
6613+ <summary> Cache of Methods, or CACHE_MISS, keyed by method
6614+ name and actual arguments used to find it.
6615+ </summary>
6616+ </member>
6617+ <member name="M:NVelocity.Util.Introspection.ClassMap.#ctor(System.Type)">
6618+ <summary> Standard constructor
6619+ </summary>
6620+ </member>
6621+ <member name="M:NVelocity.Util.Introspection.ClassMap.FindMethod(System.String,System.Object[])">
6622+ <summary>
6623+ Find a Method using the methodKey provided.
6624+
6625+ Look in the methodMap for an entry. If found,
6626+ it'll either be a CACHE_MISS, in which case we
6627+ simply give up, or it'll be a Method, in which
6628+ case, we return it.
6629+
6630+ If nothing is found, then we must actually go
6631+ and introspect the method from the MethodMap.
6632+ </summary>
6633+ <returns>
6634+ the class object whose methods are cached by this map.
6635+ </returns>
6636+ </member>
6637+ <member name="M:NVelocity.Util.Introspection.ClassMap.FindProperty(System.String)">
6638+ <summary>
6639+ Find a Method using the methodKey
6640+ provided.
6641+
6642+ Look in the methodMap for an entry. If found,
6643+ it'll either be a CACHE_MISS, in which case we
6644+ simply give up, or it'll be a Method, in which
6645+ case, we return it.
6646+
6647+ If nothing is found, then we must actually go
6648+ and introspect the method from the MethodMap.
6649+ </summary>
6650+ </member>
6651+ <member name="M:NVelocity.Util.Introspection.ClassMap.PopulateMethodCache">
6652+ <summary>
6653+ Populate the Map of direct hits. These
6654+ are taken from all the public methods
6655+ that our class provides.
6656+ </summary>
6657+ </member>
6658+ <member name="M:NVelocity.Util.Introspection.ClassMap.MakeMethodKey(System.Reflection.MethodInfo)">
6659+ <summary>
6660+ Make a methodKey for the given method using
6661+ the concatenation of the name and the
6662+ types of the method parameters.
6663+ </summary>
6664+ </member>
6665+ <member name="M:NVelocity.Util.Introspection.ClassMap.GetAccessibleMethods(System.Type)">
6666+ <summary>
6667+ Retrieves public methods for a class.
6668+ </summary>
6669+ </member>
6670+ <member name="P:NVelocity.Util.Introspection.ClassMap.CachedClass">
6671+ <summary>
6672+ Class passed into the constructor used to as
6673+ the basis for the Method map.
6674+ </summary>
6675+ </member>
6676+ <member name="T:NVelocity.Util.Introspection.Info">
6677+ <summary>
6678+ Little class to carry in info such as template name, line and column
6679+ for information error reporting from the uberspector implementations
6680+ *
6681+ </summary>
6682+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
6683+ </author>
6684+ <version> $Id: Info.cs,v 1.1 2004/12/27 05:55:08 corts Exp $
6685+
6686+ </version>
6687+ </member>
6688+ <member name="M:NVelocity.Util.Introspection.Info.#ctor(System.String,System.Int32,System.Int32)">
6689+ <param name="source">Usually a template name.
6690+ </param>
6691+ <param name="line">The line number from <code>source</code>.
6692+ </param>
6693+ <param name="column">The column number from <code>source</code>.
6694+
6695+ </param>
6696+ </member>
6697+ <member name="M:NVelocity.Util.Introspection.Info.ToString">
6698+ <summary> Formats a textual representation of this object as <code>SOURCE
6699+ [line X, column Y]</code>.
6700+ </summary>
6701+ </member>
6702+ <member name="T:NVelocity.Util.Introspection.IntrospectionCacheData">
6703+ <summary>
6704+ Holds information for node-local context data introspection
6705+ information.
6706+ </summary>
6707+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a> </author>
6708+ <version> $Id: IntrospectionCacheData.cs,v 1.3 2003/10/27 13:54:12 corts Exp $ </version>
6709+ </member>
6710+ <member name="F:NVelocity.Util.Introspection.IntrospectionCacheData.Thingy">
6711+ <summary>
6712+ Object to pair with class - currently either a Method or
6713+ AbstractExecutor. It can be used in any way the using node
6714+ wishes.
6715+ </summary>
6716+ </member>
6717+ <member name="F:NVelocity.Util.Introspection.IntrospectionCacheData.ContextData">
6718+ <summary>
6719+ Class of context data object associated with the
6720+ introspection information
6721+ </summary>
6722+ </member>
6723+ <member name="T:NVelocity.Util.Introspection.Introspector">
6724+ <summary>
6725+ This basic function of this class is to return a Method
6726+ object for a particular class given the name of a method
6727+ and the parameters to the method in the form of an Object[]
6728+
6729+ The first time the Introspector sees a
6730+ class it creates a class method map for the
6731+ class in question. Basically the class method map
6732+ is a Hashtable where Method objects are keyed by a
6733+ concatenation of the method name and the names of
6734+ classes that make up the parameters.
6735+
6736+ For example, a method with the following signature:
6737+
6738+ public void method(String a, StringBuffer b)
6739+
6740+ would be mapped by the key:
6741+
6742+ "method" + "java.lang.String" + "java.lang.StringBuffer"
6743+
6744+ This mapping is performed for all the methods in a class
6745+ and stored for
6746+ </summary>
6747+ </member>
6748+ <member name="T:NVelocity.Util.Introspection.IntrospectorBase">
6749+ <summary>
6750+ This basic function of this class is to return a Method
6751+ object for a particular class given the name of a method
6752+ and the parameters to the method in the form of an Object[]
6753+
6754+ The first time the Introspector sees a
6755+ class it creates a class method map for the
6756+ class in question. Basically the class method map
6757+ is a Hashtable where Method objects are keyed by a
6758+ concatenation of the method name and the names of
6759+ classes that make up the parameters.
6760+
6761+ For example, a method with the following signature:
6762+
6763+ public void method(String a, StringBuffer b)
6764+
6765+ would be mapped by the key:
6766+
6767+ "method" + "java.lang.String" + "java.lang.StringBuffer"
6768+
6769+ This mapping is performed for all the methods in a class
6770+ and stored for
6771+ </summary>
6772+ <version> $Id: IntrospectorBase.cs,v 1.3 2003/10/27 13:54:12 corts Exp $ </version>
6773+ </member>
6774+ <member name="F:NVelocity.Util.Introspection.IntrospectorBase.classMethodMaps">
6775+ <summary>
6776+ Holds the method maps for the classes we know about, keyed by
6777+ Class object.
6778+ </summary>
6779+ </member>
6780+ <member name="F:NVelocity.Util.Introspection.IntrospectorBase.cachedClassNames">
6781+ <summary>
6782+ Holds the qualified class names for the classes
6783+ we hold in the classMethodMaps hash
6784+ </summary>
6785+ </member>
6786+ <member name="M:NVelocity.Util.Introspection.IntrospectorBase.GetMethod(System.Type,System.String,System.Object[])">
6787+ <summary>
6788+ Gets the method defined by <code>name</code> and
6789+ <code>params</code> for the Class <code>c</code>.
6790+ </summary>
6791+ <param name="c">Class in which the method search is taking place</param>
6792+ <param name="name">Name of the method being searched for</param>
6793+ <param name="parameters">An array of Objects (not Classes) that describe the the parameters</param>
6794+ <returns>The desired <see cref="T:System.Reflection.MethodInfo"/> object.</returns>
6795+ </member>
6796+ <member name="M:NVelocity.Util.Introspection.IntrospectorBase.GetProperty(System.Type,System.String)">
6797+ <summary>
6798+ Gets the method defined by <code>name</code>
6799+ for the Class <code>c</code>.
6800+ </summary>
6801+ <param name="c">Class in which the method search is taking place</param>
6802+ <param name="name">Name of the method being searched for</param>
6803+ <returns>The desired <see cref="T:System.Reflection.PropertyInfo"/> object.</returns>
6804+ </member>
6805+ <member name="M:NVelocity.Util.Introspection.IntrospectorBase.CreateClassMap(System.Type)">
6806+ <summary>
6807+ Creates a class map for specific class and registers it in the
6808+ cache. Also adds the qualified name to the name->class map
6809+ for later Classloader change detection.
6810+ </summary>
6811+ </member>
6812+ <member name="F:NVelocity.Util.Introspection.Introspector.rlog">
6813+ <summary> our engine runtime services
6814+ </summary>
6815+ </member>
6816+ <member name="M:NVelocity.Util.Introspection.Introspector.#ctor(NVelocity.Runtime.IRuntimeLogger)">
6817+ <summary> Receives our RuntimeServices object
6818+ </summary>
6819+ </member>
6820+ <member name="M:NVelocity.Util.Introspection.Introspector.GetMethod(System.Type,System.String,System.Object[])">
6821+ <summary>
6822+ Gets the method defined by <code>name</code> and
6823+ <code>params</code> for the Class <code>c</code>.
6824+ </summary>
6825+ <param name="c">Class in which the method search is taking place</param>
6826+ <param name="name">Name of the method being searched for</param>
6827+ <param name="parameters">An array of Objects (not Classes) that describe the the parameters</param>
6828+ <returns>The desired Method object.</returns>
6829+ </member>
6830+ <member name="M:NVelocity.Util.Introspection.Introspector.GetProperty(System.Type,System.String)">
6831+ <summary>
6832+ Gets the method defined by <code>name</code>
6833+ for the Class <code>c</code>.
6834+ </summary>
6835+ <param name="c">Class in which the method search is taking place</param>
6836+ <param name="name">Name of the method being searched for</param>
6837+ <returns>The desired <see cref="T:System.Reflection.PropertyInfo"/> object.</returns>
6838+ </member>
6839+ <member name="T:NVelocity.Util.Introspection.IUberspect">
6840+ <summary> 'Federated' introspection/reflection interface to allow the introspection
6841+ behavior in Velocity to be customized.
6842+ *
6843+ </summary>
6844+ <author> <a href="mailto:geirm@apache.org">Geir Magusson Jr.</a>
6845+ </author>
6846+ <version> $Id: Uberspect.cs,v 1.1 2004/12/27 05:55:08 corts Exp $
6847+
6848+ </version>
6849+ </member>
6850+ <member name="M:NVelocity.Util.Introspection.IUberspect.Init">
6851+ <summary> Initializer - will be called before use
6852+ </summary>
6853+ </member>
6854+ <member name="M:NVelocity.Util.Introspection.IUberspect.GetMethod(System.Object,System.String,System.Object[],NVelocity.Util.Introspection.Info)">
6855+ <summary> Returns a general method, corresponding to $foo.bar( $woogie )
6856+ </summary>
6857+ </member>
6858+ <member name="M:NVelocity.Util.Introspection.IUberspect.GetPropertyGet(System.Object,System.String,NVelocity.Util.Introspection.Info)">
6859+ <summary> Property getter - returns VelPropertyGet appropos for #set($foo = $bar.woogie)
6860+ </summary>
6861+ </member>
6862+ <member name="M:NVelocity.Util.Introspection.IUberspect.GetPropertySet(System.Object,System.String,System.Object,NVelocity.Util.Introspection.Info)">
6863+ <summary> Property setter - returns VelPropertySet appropos for #set($foo.bar = "geir")
6864+ </summary>
6865+ </member>
6866+ <member name="T:NVelocity.Util.Introspection.IVelMethod">
6867+ <summary> Method used for regular method invocation
6868+ *
6869+ $foo.bar()
6870+ *
6871+ *
6872+ </summary>
6873+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
6874+ </author>
6875+ <version> $Id: VelMethod.cs,v 1.1 2004/12/27 05:55:08 corts Exp $
6876+
6877+ </version>
6878+ </member>
6879+ <member name="M:NVelocity.Util.Introspection.IVelMethod.Invoke(System.Object,System.Object[])">
6880+ <summary> invocation method - called when the method invocation should be
6881+ performed and a value returned
6882+ </summary>
6883+ </member>
6884+ <member name="P:NVelocity.Util.Introspection.IVelMethod.Cacheable">
6885+ <summary> specifies if this VelMethod is cacheable and able to be
6886+ reused for this class of object it was returned for
6887+ *
6888+ </summary>
6889+ <returns> true if can be reused for this class, false if not
6890+
6891+ </returns>
6892+ </member>
6893+ <member name="P:NVelocity.Util.Introspection.IVelMethod.MethodName">
6894+ <summary> returns the method name used
6895+ </summary>
6896+ </member>
6897+ <member name="P:NVelocity.Util.Introspection.IVelMethod.ReturnType">
6898+ <summary> returns the return type of the method invoked
6899+ </summary>
6900+ </member>
6901+ <member name="T:NVelocity.Util.Introspection.IVelPropertyGet">
6902+ <summary>
6903+ Interface defining a 'getter'. For uses when looking for resolution of
6904+ property references
6905+ <code>
6906+ $foo.bar
6907+ </code>
6908+ </summary>
6909+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a> </author>
6910+ <version> $Id: VelPropertyGet.cs,v 1.1 2004/12/27 05:55:08 corts Exp $ </version>
6911+ </member>
6912+ <member name="M:NVelocity.Util.Introspection.IVelPropertyGet.Invoke(System.Object)">
6913+ <summary>
6914+ invocation method - called when the 'get action' should be
6915+ performed and a value returned
6916+ </summary>
6917+ </member>
6918+ <member name="P:NVelocity.Util.Introspection.IVelPropertyGet.Cacheable">
6919+ <summary>
6920+ specifies if this VelPropertyGet is cacheable and able to be
6921+ reused for this class of object it was returned for
6922+ </summary>
6923+ <returns>true if can be reused for this class, false if not</returns>
6924+ </member>
6925+ <member name="P:NVelocity.Util.Introspection.IVelPropertyGet.MethodName">
6926+ <summary>
6927+ returns the method name used to return this 'property'
6928+ </summary>
6929+ </member>
6930+ <member name="T:NVelocity.Util.Introspection.IVelPropertySet">
6931+ <summary> Interface used for setting values that appear to be properties in
6932+ Velocity. Ex.
6933+ *
6934+ #set($foo.bar = "hello")
6935+ *
6936+ </summary>
6937+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
6938+ </author>
6939+ <version> $Id: VelPropertySet.cs,v 1.1 2004/12/27 05:55:08 corts Exp $
6940+
6941+ </version>
6942+ </member>
6943+ <member name="M:NVelocity.Util.Introspection.IVelPropertySet.Invoke(System.Object,System.Object)">
6944+ <summary> method used to set the value in the object
6945+ *
6946+ </summary>
6947+ <param name="o">Object on which the method will be called with the arg
6948+ </param>
6949+ <param name="arg">value to be set
6950+ </param>
6951+ <returns> the value returned from the set operation (impl specific)
6952+
6953+ </returns>
6954+ </member>
6955+ <member name="P:NVelocity.Util.Introspection.IVelPropertySet.Cacheable">
6956+ <summary> specifies if this VelPropertySet is cacheable and able to be
6957+ reused for this class of object it was returned for
6958+ *
6959+ </summary>
6960+ <returns> true if can be reused for this class, false if not
6961+
6962+ </returns>
6963+ </member>
6964+ <member name="P:NVelocity.Util.Introspection.IVelPropertySet.MethodName">
6965+ <summary> returns the method name used to set this 'property'
6966+ </summary>
6967+ </member>
6968+ <member name="F:NVelocity.Util.Introspection.MethodMap.methodByNameMap">
6969+ <summary> Keep track of all methods with the same name.</summary>
6970+ </member>
6971+ <member name="M:NVelocity.Util.Introspection.MethodMap.Add(System.Reflection.MethodInfo)">
6972+ <summary> Add a method to a list of methods by name.
6973+ For a particular class we are keeping track
6974+ of all the methods with the same name.
6975+ </summary>
6976+ </member>
6977+ <member name="M:NVelocity.Util.Introspection.MethodMap.Get(System.String)">
6978+ <summary>
6979+ Return a list of methods with the same name.
6980+ </summary>
6981+ <param name="key">key</param>
6982+ <returns> List list of methods</returns>
6983+ </member>
6984+ <member name="M:NVelocity.Util.Introspection.MethodMap.Find(System.String,System.Object[])">
6985+ <summary>
6986+ Find a method. Attempts to find the
6987+ most specific applicable method using the
6988+ algorithm described in the JLS section
6989+ 15.12.2 (with the exception that it can't
6990+ distinguish a primitive type argument from
6991+ an object type argument, since in reflection
6992+ primitive type arguments are represented by
6993+ their object counterparts, so for an argument of
6994+ type (say) java.lang.Integer, it will not be able
6995+ to decide between a method that takes int and a
6996+ method that takes java.lang.Integer as a parameter.
6997+
6998+ <para>
6999+ This turns out to be a relatively rare case
7000+ where this is needed - however, functionality
7001+ like this is needed.
7002+ </para>
7003+ </summary>
7004+ <param name="methodName">name of method</param>
7005+ <param name="args">the actual arguments with which the method is called</param>
7006+ <returns> the most specific applicable method, or null if no method is applicable.</returns>
7007+ <exception cref="T:NVelocity.Util.Introspection.AmbiguousException">if there is more than one maximally specific applicable method</exception>
7008+ </member>
7009+ <member name="M:NVelocity.Util.Introspection.MethodMap.IsMoreSpecific(System.Reflection.ParameterInfo[],System.Reflection.ParameterInfo[])">
7010+ <summary> Determines which method signature (represented by a class array) is more
7011+ specific. This defines a partial ordering on the method signatures.
7012+ </summary>
7013+ <param name="c1">first signature to compare
7014+ </param>
7015+ <param name="c2">second signature to compare
7016+ </param>
7017+ <returns> MORE_SPECIFIC if c1 is more specific than c2, LESS_SPECIFIC if
7018+ c1 is less specific than c2, INCOMPARABLE if they are incomparable.
7019+
7020+ </returns>
7021+ </member>
7022+ <member name="M:NVelocity.Util.Introspection.MethodMap.GetApplicables(System.Collections.IList,System.Type[])">
7023+ <summary>
7024+ Returns all methods that are applicable to actual argument types.
7025+ </summary>
7026+ <param name="methods">list of all candidate methods</param>
7027+ <param name="classes">the actual types of the arguments</param>
7028+ <returns>
7029+ a list that contains only applicable methods (number of
7030+ formal and actual arguments matches, and argument types are assignable
7031+ to formal types through a method invocation conversion).
7032+ </returns>
7033+ TODO: this used to return a LinkedList -- changed to an ArrayList for now until I can figure out what is really needed
7034+ </member>
7035+ <member name="M:NVelocity.Util.Introspection.MethodMap.IsApplicable(System.Reflection.MethodInfo,System.Type[])">
7036+ <summary>
7037+ Returns true if the supplied method is applicable to actual
7038+ argument types.
7039+ </summary>
7040+ </member>
7041+ <member name="M:NVelocity.Util.Introspection.MethodMap.IsMethodInvocationConvertible(System.Reflection.ParameterInfo,System.Type)">
7042+ <summary>
7043+ Determines whether a type represented by a class object is
7044+ convertible to another type represented by a class object using a
7045+ method invocation conversion, treating object types of primitive
7046+ types as if they were primitive types (that is, a Boolean actual
7047+ parameter type matches boolean primitive formal type). This behavior
7048+ is because this method is used to determine applicable methods for
7049+ an actual parameter list, and primitive types are represented by
7050+ their object duals in reflective method calls.
7051+ </summary>
7052+ <param name="formal">the formal parameter type to which the actual parameter type should be convertible</param>
7053+ <param name="actual">the actual parameter type.</param>
7054+ <returns>
7055+ true if either formal type is assignable from actual type,
7056+ or formal is a primitive type and actual is its corresponding object
7057+ type or an object type of a primitive type that can be converted to
7058+ the formal type.
7059+ </returns>
7060+ </member>
7061+ <member name="M:NVelocity.Util.Introspection.MethodMap.IsStrictMethodInvocationConvertible(System.Reflection.ParameterInfo,System.Reflection.ParameterInfo)">
7062+ <summary>
7063+ Determines whether a type represented by a class object is
7064+ convertible to another type represented by a class object using a
7065+ method invocation conversion, without matching object and primitive
7066+ types. This method is used to determine the more specific type when
7067+ comparing signatures of methods.
7068+ </summary>
7069+ <param name="formal">the formal parameter type to which the actual parameter type should be convertible</param>
7070+ <param name="actual">the actual parameter type.</param>
7071+ <returns>
7072+ true if either formal type is assignable from actual type,
7073+ or formal and actual are both primitive types and actual can be
7074+ subject to widening conversion to formal.
7075+ </returns>
7076+ </member>
7077+ <member name="T:NVelocity.Util.Introspection.UberspectImpl">
7078+ <summary> Implementation of Uberspect to provide the default introspective
7079+ functionality of Velocity
7080+ *
7081+ </summary>
7082+ <author> <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
7083+ </author>
7084+ <version> $Id: UberspectImpl.cs,v 1.1 2004/12/27 05:55:08 corts Exp $
7085+
7086+ </version>
7087+ </member>
7088+ <member name="T:NVelocity.Util.Introspection.UberspectLoggable">
7089+ <summary>
7090+ Marker interface to let an uberspector indicate it can and wants to
7091+ log
7092+ *
7093+ Thanks to Paulo for the suggestion
7094+ *
7095+ </summary>
7096+ <author> <a href="mailto:geirm@apache.org">Geir Magnusson Jr.</a>
7097+ </author>
7098+ <version> $Id: UberspectLoggable.cs,v 1.1 2004/12/27 05:55:08 corts Exp $
7099+ *
7100+
7101+ </version>
7102+ </member>
7103+ <member name="P:NVelocity.Util.Introspection.UberspectLoggable.RuntimeLogger">
7104+ <summary> Sets the logger. This will be called before any calls to the
7105+ uberspector
7106+ </summary>
7107+ </member>
7108+ <member name="F:NVelocity.Util.Introspection.UberspectImpl.runtimeLogger">
7109+ <summary>
7110+ Our runtime logger.
7111+ </summary>
7112+ </member>
7113+ <member name="F:NVelocity.Util.Introspection.UberspectImpl.introspector">
7114+ <summary>
7115+ the default Velocity introspector
7116+ </summary>
7117+ </member>
7118+ <member name="M:NVelocity.Util.Introspection.UberspectImpl.Init">
7119+ <summary>
7120+ init - does nothing - we need to have setRuntimeLogger
7121+ called before getting our introspector, as the default
7122+ vel introspector depends upon it.
7123+ </summary>
7124+ </member>
7125+ <member name="M:NVelocity.Util.Introspection.UberspectImpl.GetMethod(System.Object,System.String,System.Object[],NVelocity.Util.Introspection.Info)">
7126+ <summary>
7127+ Method
7128+ </summary>
7129+ </member>
7130+ <member name="M:NVelocity.Util.Introspection.UberspectImpl.GetPropertyGet(System.Object,System.String,NVelocity.Util.Introspection.Info)">
7131+ <summary>
7132+ Property getter.
7133+ </summary>
7134+ </member>
7135+ <member name="M:NVelocity.Util.Introspection.UberspectImpl.GetPropertySet(System.Object,System.String,System.Object,NVelocity.Util.Introspection.Info)">
7136+ <summary>
7137+ Property setter.
7138+ </summary>
7139+ </member>
7140+ <member name="P:NVelocity.Util.Introspection.UberspectImpl.RuntimeLogger">
7141+ <summary>
7142+ Sets the runtime logger - this must be called before anything
7143+ else besides init() as to get the logger. Makes the pull
7144+ model appealing...
7145+ </summary>
7146+ </member>
7147+ <member name="T:NVelocity.Util.Introspection.UberspectImpl.VelMethodImpl">
7148+ <summary>
7149+ Implementation of <see cref="T:NVelocity.Util.Introspection.IVelMethod"/>.
7150+ </summary>
7151+ </member>
7152+ <member name="T:NVelocity.Util.Introspection.UberspectImpl.VelGetterImpl">
7153