public void Merge(IContext context, TextWriter writer)
{
if (this.errorCondition != null)
{
throw this.errorCondition;
}
if (this.data != null)
{
InternalContextAdapterImpl internalContextAdapterImpl = new InternalContextAdapterImpl(context);
try
{
internalContextAdapterImpl.PushCurrentTemplateName(this.name);
internalContextAdapterImpl.CurrentResource = this;
((SimpleNode)this.data).Render(internalContextAdapterImpl, writer);
}
finally
{
internalContextAdapterImpl.PopCurrentTemplateName();
internalContextAdapterImpl.CurrentResource = null;
}
return;
}
string message = "Template.merge() failure. The document is null, most likely due to parsing error.";
this.rsvc.Error(message);
throw new System.Exception(message);
}
/// <summary> initializes the document. Init() is not longer
/// dependant upon context, but we need to let the
/// Init() carry the template name down throught for VM
/// namespace features
/// </summary>
/// <throws> TemplateInitException When a problem occurs during the document initialization. </throws>
public virtual void InitDocument()
{
/*
* send an empty InternalContextAdapter down into the AST to Initialize it
*/
InternalContextAdapterImpl ica = new InternalContextAdapterImpl(new VelocityContext());
try
{
/*
* Put the current template name on the stack
*/
ica.PushCurrentTemplateName(name);
ica.CurrentResource = this;
/*
* Init the AST
*/
((SimpleNode)data).Init(ica, rsvc);
}
finally
{
/*
* in case something blows up...
* pull it off for completeness
*/
ica.PopCurrentTemplateName();
ica.CurrentResource = null;
}
}
/// <summary>
/// Renders the input reader using the context into the output writer.
/// To be used when a template is dynamically constructed, or want to
/// use Velocity as a token replacer.
/// </summary>
/// <param name="context">context to use in rendering input string</param>
/// <param name="out"> Writer in which to render the output</param>
/// <param name="logTag"> string to be used as the template name for log messages in case of error</param>
/// <param name="reader">Reader containing the VTL to be rendered</param>
/// <returns>true if successful, false otherwise. If false, see Velocity runtime log</returns>
public static bool Evaluate(IContext context, TextWriter writer, String logTag, TextReader reader)
{
SimpleNode nodeTree = null;
try
{
nodeTree = RuntimeSingleton.parse(reader, logTag);
}
catch (ParseException pex)
{
throw new ParseErrorException(pex.Message);
}
/*
* now we want to init and render
*/
if (nodeTree != null)
{
InternalContextAdapterImpl ica = new InternalContextAdapterImpl(context);
ica.PushCurrentTemplateName(logTag);
try
{
try
{
nodeTree.init(ica, RuntimeSingleton.RuntimeServices);
}
catch (Exception e)
{
RuntimeSingleton.error("Velocity.evaluate() : init exception for tag = " + logTag + " : " + e);
}
/*
* now render, and let any exceptions fly
*/
nodeTree.render(ica, writer);
}
finally
{
ica.PopCurrentTemplateName();
}
return(true);
}
return(false);
}
public void InitDocument()
{
InternalContextAdapterImpl internalContextAdapterImpl = new InternalContextAdapterImpl(new VelocityContext());
try
{
internalContextAdapterImpl.PushCurrentTemplateName(this.name);
((SimpleNode)this.data).Init(internalContextAdapterImpl, this.rsvc);
}
finally
{
internalContextAdapterImpl.PopCurrentTemplateName();
}
}
public bool Evaluate(IContext context, TextWriter writer, string logTag, TextReader reader)
{
SimpleNode simpleNode = null;
try
{
simpleNode = this.ri.Parse(reader, logTag);
}
catch (ParseException ex)
{
throw new ParseErrorException(ex.Message, ex);
}
bool result;
if (simpleNode != null)
{
InternalContextAdapterImpl internalContextAdapterImpl = new InternalContextAdapterImpl(context);
internalContextAdapterImpl.PushCurrentTemplateName(logTag);
try
{
try
{
simpleNode.Init(internalContextAdapterImpl, this.ri);
}
catch (System.Exception ex2)
{
this.ri.Error(string.Concat(new object[]
{
"Velocity.evaluate() : init exception for tag = ",
logTag,
" : ",
ex2
}));
}
simpleNode.Render(internalContextAdapterImpl, writer);
}
finally
{
internalContextAdapterImpl.PopCurrentTemplateName();
}
result = true;
}
else
{
result = false;
}
return(result);
}
/// <summary>
/// The AST node structure is merged with the
/// context to produce the final output.
///
/// Throws IOException if failure is due to a file related
/// issue, and Exception otherwise
/// </summary>
/// <param name="context">Conext with data elements accessed by template</param>
/// <param name="writer">
/// output writer for rendered template
/// @throws ResourceNotFoundException if template not found
/// from any available source.
/// @throws ParseErrorException if template cannot be parsed due
/// to syntax (or other) error.
/// @throws Exception anything else.
/// </param>
public void Merge(IContext context, TextWriter writer)
{
/*
* we shouldn't have to do this, as if there is an error condition,
* the application code should never get a reference to the
* Template
*/
if (errorCondition != null)
{
throw errorCondition;
}
if (data != null)
{
/*
* create an InternalContextAdapter to carry the user Context down
* into the rendering engine. Set the template name and render()
*/
InternalContextAdapterImpl ica = new InternalContextAdapterImpl(context);
try
{
ica.PushCurrentTemplateName(name);
ica.CurrentResource = this;
((SimpleNode)data).render(ica, writer);
}
finally
{
/*
* lets make sure that we always clean up the context
*/
ica.PopCurrentTemplateName();
ica.CurrentResource = null;
}
}
else
{
/*
* this shouldn't happen either, but just in case.
*/
String msg = "Template.merge() failure. The document is null, " + "most likely due to parsing error.";
rsvc.error(msg);
throw new System.Exception(msg);
}
}
/// <summary>
/// Renders the input reader using the context into the output writer.
/// To be used when a template is dynamically constructed, or want to
/// use Velocity as a token replacer.
/// </summary>
/// <param name="context">context to use in rendering input string</param>
/// <param name="writer"> Writer in which to render the output</param>
/// <param name="logTag"> string to be used as the template name for log messages in case of error</param>
/// <param name="reader">Reader containing the VTL to be rendered</param>
/// <returns>true if successful, false otherwise. If false, see Velocity runtime log</returns>
public static bool Evaluate(IContext context, TextWriter writer, String logTag, TextReader reader)
{
SimpleNode nodeTree = null;
try
{
nodeTree = RuntimeSingleton.Parse(reader, logTag);
}
catch (ParseException parseException)
{
throw new ParseErrorException(parseException.Message, parseException);
}
// now we want to init and render
if (nodeTree != null)
{
InternalContextAdapterImpl internalContextAdapterImpl = new InternalContextAdapterImpl(context);
internalContextAdapterImpl.PushCurrentTemplateName(logTag);
try
{
try
{
nodeTree.Init(internalContextAdapterImpl, RuntimeSingleton.RuntimeServices);
}
catch (Exception exception)
{
RuntimeSingleton.Error(
string.Format("Velocity.evaluate() : init exception for tag = {0} : {1}", logTag, exception));
}
// now render, and let any exceptions fly
nodeTree.Render(internalContextAdapterImpl, writer);
}
finally
{
internalContextAdapterImpl.PopCurrentTemplateName();
}
return(true);
}
return(false);
}
internal bool Render(DvslNode node, IContext context, TextWriter writer)
{
/*
* find if we have an AST where the xpath expression mathes
* for this node
*/
XmlNode dom4jnode = (XmlNode)node.NodeImpl;
XPathNavigator nav = dom4jnode.CreateNavigator();
SimpleNode sn = null;
for (int i = 0; i < xpathList.Count; i++)
{
Hashtable m = (Hashtable)xpathList[i];
XPathExpression expr = nav.Compile((String)m["xpath"]);
if (nav.Matches((String)m["xpath"]))
{
sn = (SimpleNode)m["ast"];
break;
}
}
// if we found something, render
if (sn != null)
{
InternalContextAdapterImpl ica = new InternalContextAdapterImpl(context);
ica.PushCurrentTemplateName(node.Name);
try
{
sn.render(ica, writer);
}
finally
{
ica.PopCurrentTemplateName();
}
return(true);
}
return(false);
}
/// <summary>
/// initializes the document. init() is not longer
/// dependant upon context, but we need to let the
/// init() carry the template name down through for VM
/// namespace features
/// </summary>
public void InitDocument()
{
// send an empty InternalContextAdapter down into the AST to initialize it
InternalContextAdapterImpl internalContextAdapterImpl = new InternalContextAdapterImpl(new VelocityContext());
try
{
// put the current template name on the stack
internalContextAdapterImpl.PushCurrentTemplateName(name);
// init the AST
((SimpleNode)data).Init(internalContextAdapterImpl, runtimeServices);
}
finally
{
// in case something blows up...
// pull it off for completeness
internalContextAdapterImpl.PopCurrentTemplateName();
}
}
/// <summary>
/// initializes the document. init() is not longer
/// dependant upon context, but we need to let the
/// init() carry the template name down through for VM
/// namespace features
/// </summary>
public void InitDocument()
{
// send an empty InternalContextAdapter down into the AST to initialize it
InternalContextAdapterImpl internalContextAdapterImpl = new InternalContextAdapterImpl(new VelocityContext());
try
{
// put the current template name on the stack
internalContextAdapterImpl.PushCurrentTemplateName(name);
// init the AST
((SimpleNode) data).Init(internalContextAdapterImpl, runtimeServices);
}
finally
{
// in case something blows up...
// pull it off for completeness
internalContextAdapterImpl.PopCurrentTemplateName();
}
}
/// <summary>
/// The AST node structure is merged with the
/// context to produce the final output.
///
/// Throws IOException if failure is due to a file related
/// issue, and Exception otherwise
/// </summary>
/// <param name="context">Context with data elements accessed by template</param>
/// <param name="writer">writer for rendered template</param>
/// <exception cref="ResourceNotFoundException">
/// if template not found from any available source.
/// </exception>
/// <exception cref="ParseErrorException">
/// if template cannot be parsed due to syntax (or other) error.
/// </exception>
/// <exception cref="System.Exception">
/// anything else.
/// </exception>
public void Merge(IContext context, TextWriter writer)
{
// we shouldn't have to do this, as if there is an error condition,
// the application code should never get a reference to the
// Template
if (errorCondition != null)
{
throw errorCondition;
}
if (data != null)
{
// create an InternalContextAdapter to carry the user Context down
// into the rendering engine. Set the template name and render()
InternalContextAdapterImpl internalContextAdapterImpl = new InternalContextAdapterImpl(context);
try
{
internalContextAdapterImpl.PushCurrentTemplateName(name);
internalContextAdapterImpl.CurrentResource = this;
((SimpleNode)data).Render(internalContextAdapterImpl, writer);
}
finally
{
// lets make sure that we always clean up the context
internalContextAdapterImpl.PopCurrentTemplateName();
internalContextAdapterImpl.CurrentResource = null;
}
}
else
{
// this shouldn't happen either, but just in case.
String msg = "Template.merge() failure. The document is null, most likely due to parsing error.";
runtimeServices.Error(msg);
throw new System.Exception(msg);
}
}
/// <summary> The AST node structure is merged with the
/// context to produce the final output.
///
/// </summary>
/// <param name="context">Conext with data elements accessed by template
/// </param>
/// <param name="writer">output writer for rendered template
/// </param>
/// <param name="macroLibraries">a list of template files containing macros to be used when merging
/// </param>
/// <throws> ResourceNotFoundException if template not found </throws>
/// <summary> from any available source.
/// </summary>
/// <throws> ParseErrorException if template cannot be parsed due </throws>
/// <summary> to syntax (or other) Error.
/// </summary>
/// <throws> MethodInvocationException When a method on a referenced object in the context could not invoked. </throws>
/// <throws> IOException Might be thrown while rendering. </throws>
/// <since> 1.6
/// </since>
public virtual void Merge(IContext context, TextWriter writer, IList macroLibraries)
{
/*
* we shouldn't have to do this, as if there is an Error condition,
* the application code should never Get a reference to the
* Template
*/
if (errorCondition != null)
{
throw errorCondition;
}
if (data != null)
{
/*
* create an InternalContextAdapter to carry the user Context down
* into the rendering engine. Set the template name and render()
*/
InternalContextAdapterImpl ica = new InternalContextAdapterImpl(context);
/**
* Set the macro libraries
*/
ica.MacroLibraries = macroLibraries;
if (macroLibraries != null)
{
for (int i = 0; i < macroLibraries.Count; i++)
{
/**
* Build the macro library
*/
try
{
rsvc.GetTemplate((string)macroLibraries[i]);
}
catch (ResourceNotFoundException re)
{
/*
* the macro lib wasn't found. Note it and throw
*/
rsvc.Log.Error("template.merge(): " + "cannot find template " + ((string)macroLibraries[i]));
throw re;
}
catch (ParseErrorException pe)
{
/*
* the macro lib was found, but didn't parse - syntax Error
* note it and throw
*/
rsvc.Log.Error("template.merge(): " + "syntax error in template " + ((string)macroLibraries[i]) + ".");
throw pe;
}
catch (System.Exception e)
{
throw new RuntimeException("Template.merge(): parse failed in template " + ((string)macroLibraries[i]) + ".", e);
}
}
}
try
{
ica.PushCurrentTemplateName(name);
ica.CurrentResource = this;
((SimpleNode)data).Render(ica, writer);
}
finally
{
/*
* lets make sure that we always clean up the context
*/
ica.PopCurrentTemplateName();
ica.CurrentResource = null;
}
}
else
{
/*
* this shouldn't happen either, but just in case.
*/
string msg = "Template.merge() failure. The document is null, " + "most likely due to parsing error.";
throw new SystemException(msg);
}
}
/// <summary>
/// Renders the input reader using the context into the output writer.
/// To be used when a template is dynamically constructed, or want to
/// use Velocity as a token replacer.
/// </summary>
/// <param name="context">context to use in rendering input string</param>
/// <param name="writer"> Writer in which to render the output</param>
/// <param name="logTag"> string to be used as the template name for log messages in case of error</param>
/// <param name="reader">Reader containing the VTL to be rendered</param>
/// <returns>true if successful, false otherwise. If false, see Velocity runtime log</returns>
public bool Evaluate(IContext context, TextWriter writer, String logTag, TextReader reader)
{
SimpleNode nodeTree = null;
try
{
nodeTree = ri.Parse(reader, logTag);
}
catch(ParseException pex)
{
throw new ParseErrorException(pex.Message, pex);
}
// now we want to init and render
if (nodeTree != null)
{
InternalContextAdapterImpl ica = new InternalContextAdapterImpl(context);
ica.PushCurrentTemplateName(logTag);
try
{
try
{
nodeTree.Init(ica, ri);
}
catch(Exception e)
{
ri.Error("Velocity.evaluate() : init exception for tag = " + logTag + " : " + e);
}
// now render, and let any exceptions fly
nodeTree.Render(ica, writer);
}
finally
{
ica.PopCurrentTemplateName();
}
return true;
}
return false;
}
/// <summary>
/// Renders the input reader using the context into the output writer.
/// To be used when a template is dynamically constructed, or want to
/// use Velocity as a token replacer.
/// </summary>
/// <param name="context">context to use in rendering input string</param>
/// <param name="writer"> Writer in which to render the output</param>
/// <param name="logTag"> string to be used as the template name for log messages in case of error</param>
/// <param name="reader">Reader containing the VTL to be rendered</param>
/// <returns>true if successful, false otherwise. If false, see Velocity runtime log</returns>
public bool Evaluate(IContext context, TextWriter writer, String logTag, TextReader reader)
{
SimpleNode nodeTree = null;
try
{
nodeTree = runtimeInstance.Parse(reader, logTag);
}
catch(ParseException parseException)
{
throw new ParseErrorException(parseException.Message, parseException);
}
// now we want to init and render
if (nodeTree != null)
{
InternalContextAdapterImpl internalContextAdapterImpl = new InternalContextAdapterImpl(context);
internalContextAdapterImpl.PushCurrentTemplateName(logTag);
try
{
try
{
nodeTree.Init(internalContextAdapterImpl, runtimeInstance);
}
catch(Exception e)
{
runtimeInstance.Error(string.Format("Velocity.evaluate() : init exception for tag = {0} : {1}", logTag, e));
}
// now render, and let any exceptions fly
nodeTree.Render(internalContextAdapterImpl, writer);
}
finally
{
internalContextAdapterImpl.PopCurrentTemplateName();
}
return true;
}
return false;
}
/// <summary>
/// The AST node structure is merged with the
/// context to produce the final output.
///
/// Throws IOException if failure is due to a file related
/// issue, and Exception otherwise
/// </summary>
/// <param name="context">Conext with data elements accessed by template</param>
/// <param name="writer">writer for rendered template</param>
/// <exception cref="ResourceNotFoundException">
/// if template not found from any available source.
/// </exception>
/// <exception cref="ParseErrorException">
/// if template cannot be parsed due to syntax (or other) error.
/// </exception>
/// <exception cref="System.Exception">
/// anything else.
/// </exception>
public void Merge(IContext context, TextWriter writer)
{
// we shouldn't have to do this, as if there is an error condition,
// the application code should never get a reference to the
// Template
if (errorCondition != null)
{
throw errorCondition;
}
if (data != null)
{
// create an InternalContextAdapter to carry the user Context down
// into the rendering engine. Set the template name and render()
InternalContextAdapterImpl ica = new InternalContextAdapterImpl(context);
try
{
ica.PushCurrentTemplateName(name);
ica.CurrentResource = this;
((SimpleNode) data).Render(ica, writer);
}
finally
{
// lets make sure that we always clean up the context
ica.PopCurrentTemplateName();
ica.CurrentResource = null;
}
}
else
{
// this shouldn't happen either, but just in case.
String msg = "Template.merge() failure. The document is null, most likely due to parsing error.";
rsvc.Error(msg);
throw new System.Exception(msg);
}
}