Uses of Interface

Packages that use InternalContextAdapter   

Uses of InternalContextAdapter in

Methods in with parameters of type InternalContextAdapter
static String EventHandlerUtil.includeEvent(RuntimeServices rsvc, InternalContextAdapter context, String includeResourcePath, String currentResourcePath, String directiveName)
          Called when an include-type directive is encountered (#include or #parse).
static Object EventHandlerUtil.invalidGetMethod(RuntimeServices rsvc, InternalContextAdapter context, String reference, Object object, String property, Info info)
          Called when an invalid get method is encountered.
static Object EventHandlerUtil.invalidMethod(RuntimeServices rsvc, InternalContextAdapter context, String reference, Object object, String method, Info info)
          Called when an invalid method is encountered.
static Object EventHandlerUtil.invalidReferenceHandlerCall(EventHandlerMethodExecutor methodExecutor, RuntimeServices rsvc, InternalContextAdapter context)
          Calls event handler method with appropriate chaining across event handlers.
static void EventHandlerUtil.invalidSetMethod(RuntimeServices rsvc, InternalContextAdapter context, String leftreference, String rightreference, Info info)
          Called when an invalid set method is encountered.
static Object EventHandlerUtil.methodException(RuntimeServices rsvc, InternalContextAdapter context, Class claz, String method, Exception e)
          Called when a method exception is generated during Velocity merge.
static Object EventHandlerUtil.referenceInsert(RuntimeServices rsvc, InternalContextAdapter context, String reference, Object value)
          Called before a reference is inserted.

Uses of InternalContextAdapter in org.apache.velocity.context

Classes in org.apache.velocity.context that implement InternalContextAdapter
 class ChainedInternalContextAdapter
          This is an abstract internal-use-only context implementation to be used as a subclass for other internal-use-only contexts that wrap other internal-use-only contexts.
 class InternalContextAdapterImpl
          This adapter class is the container for all context types for internal use.

Fields in org.apache.velocity.context declared as InternalContextAdapter
protected  InternalContextAdapter ChainedInternalContextAdapter.wrappedContext
          the parent context

Methods in org.apache.velocity.context that return InternalContextAdapter
 InternalContextAdapter ChainedInternalContextAdapter.getBaseContext()
 InternalContextAdapter InternalContextAdapterImpl.getBaseContext()
          Returns the base context that we are wrapping.
 InternalContextAdapter InternalWrapperContext.getBaseContext()
          Returns the base full context impl.

Constructors in org.apache.velocity.context with parameters of type InternalContextAdapter
ChainedInternalContextAdapter(InternalContextAdapter inner)
          CTOR, wraps an ICA

Uses of InternalContextAdapter in org.apache.velocity.runtime

Methods in org.apache.velocity.runtime with parameters of type InternalContextAdapter
 boolean Renderable.render(InternalContextAdapter context, Writer writer)

Uses of InternalContextAdapter in org.apache.velocity.runtime.directive

Methods in org.apache.velocity.runtime.directive with parameters of type InternalContextAdapter
protected  void VelocimacroProxy.checkDepth(InternalContextAdapter context)
          check that we aren't already at the max call depth and throws a MacroOverflowException if we are there.
protected  void Foreach.clean(InternalContextAdapter context, Object o)
protected  String InputBase.getInputEncoding(InternalContextAdapter context)
          Decides the encoding used during input processing of this directive.
protected  Iterator Foreach.getIterator(InternalContextAdapter context, Node node)
          Retrieve the contextual iterator.
protected  Object[][] VelocimacroProxy.handleArgValues(InternalContextAdapter context, Node node, int callArgNum)
          Gets the macro argument values and puts them in the context under the argument names.
protected  String context)
          Creates a string identifying the source and location of the block definition, and the current template being rendered if that is different.
 void Evaluate.init(RuntimeServices rs, InternalContextAdapter context, Node node)
          Initialize and check arguments.
 void Define.init(RuntimeServices rs, InternalContextAdapter context, Node node)
          simple init - get the key
 void Break.init(RuntimeServices rs, InternalContextAdapter context, Node node)
 void Block.init(RuntimeServices rs, InternalContextAdapter context, Node node)
          simple init - get the key
 void Macro.init(RuntimeServices rs, InternalContextAdapter context, Node node)
 void Parse.init(RuntimeServices rs, InternalContextAdapter context, Node node)
          Init's the #parse directive.
 void RuntimeMacro.init(RuntimeServices rs, InternalContextAdapter context, Node node)
          Intialize the Runtime macro.
 void Stop.init(RuntimeServices rs, InternalContextAdapter context, Node node)
 void Foreach.init(RuntimeServices rs, InternalContextAdapter context, Node node)
          simple init - init the tree and get the elementKey from the AST
 void Include.init(RuntimeServices rs, InternalContextAdapter context, Node node)
          simple init - init the tree and get the elementKey from the AST
 void BlockMacro.init(RuntimeServices rs, InternalContextAdapter context, Node node)
          Initializes the directive.
 void Directive.init(RuntimeServices rs, InternalContextAdapter context, Node node)
          How this directive is to be initialized.
protected  void Directive.postRender(InternalContextAdapter context)
          This cleans up any scope control for this directive after rendering, assuming the scope control was turned on.
protected  void Directive.preRender(InternalContextAdapter context)
          This creates and places the scope control for this directive into the context (if scope provision is turned on).
protected  void Foreach.put(InternalContextAdapter context, String key, Object value)
          Extension hook to allow subclasses to control whether loop vars are set locally or not.
 boolean Block.render(InternalContextAdapter context, Writer writer)
 boolean Block.Reference.render(InternalContextAdapter context, Writer writer)
          Render the AST of this block into the writer using the context.
 boolean Evaluate.render(InternalContextAdapter context, Writer writer, Node node)
          Evaluate the argument, convert to a String, and evaluate again (with the same context).
 boolean Define.render(InternalContextAdapter context, Writer writer, Node node)
          directive.render() simply makes an instance of the Block inner class and places it into the context as indicated.
 boolean Break.render(InternalContextAdapter context, Writer writer, Node node)
          This directive throws a StopCommand which signals either the nearest Scope or the specified scope to stop rendering its content.
 boolean VelocimacroProxy.render(InternalContextAdapter context, Writer writer, Node node)
 boolean Macro.render(InternalContextAdapter context, Writer writer, Node node)
          render() doesn't do anything in the final output rendering.
 boolean Parse.render(InternalContextAdapter context, Writer writer, Node node)
          iterates through the argument list and renders every argument that is appropriate.
 boolean RuntimeMacro.render(InternalContextAdapter context, Writer writer, Node node)
          Velocimacro implementation is not known at the init time.
 boolean Stop.render(InternalContextAdapter context, Writer writer, Node node)
 boolean Foreach.render(InternalContextAdapter context, Writer writer, Node node)
          renders the #foreach() block
 boolean Include.render(InternalContextAdapter context, Writer writer, Node node)
          iterates through the argument list and renders every argument that is appropriate.
 boolean BlockMacro.render(InternalContextAdapter context, Writer writer, Node node)
          Renders content using the selected macro and the passed AST body.
abstract  boolean Directive.render(InternalContextAdapter context, Writer writer, Node node)
          How this directive is to be rendered
 boolean VelocimacroProxy.render(InternalContextAdapter context, Writer writer, Node node, Renderable body)
          Renders the macro using the context.
 boolean RuntimeMacro.render(InternalContextAdapter context, Writer writer, Node node, Renderable body)
          This method is used with BlockMacro when we want to render a macro with a body AST.
protected  void Foreach.renderBlock(InternalContextAdapter context, Writer writer, Node block)

Constructors in org.apache.velocity.runtime.directive with parameters of type InternalContextAdapter
Block.Reference(InternalContextAdapter context, Block parent)

Uses of InternalContextAdapter in org.apache.velocity.runtime.directive.contrib

Methods in org.apache.velocity.runtime.directive.contrib with parameters of type InternalContextAdapter
 void For.init(RuntimeServices rs, InternalContextAdapter context, Node node)
 boolean For.render(InternalContextAdapter context, Writer writer, Node node)
protected  void For.renderBlock(InternalContextAdapter context, Writer writer, Node node)

Uses of InternalContextAdapter in org.apache.velocity.runtime.parser.node

Methods in org.apache.velocity.runtime.parser.node with parameters of type InternalContextAdapter
static Object ASTIndex.adjMinusIndexArg(Object argument, Object o, InternalContextAdapter context, SimpleNode node)
          If argument is an Integer and negative, then return (o.size() - argument).
 boolean ASTElseIfStatement.evaluate(InternalContextAdapter context)
          An ASTElseStatement is true if the expression it contains evaluates to true.
 boolean ASTExpression.evaluate(InternalContextAdapter context)
 boolean SimpleNode.evaluate(InternalContextAdapter context)
 boolean ASTNENode.evaluate(InternalContextAdapter context)
 boolean ASTElseStatement.evaluate(InternalContextAdapter context)
          An ASTElseStatement always evaluates to true.
 boolean ASTNotNode.evaluate(InternalContextAdapter context)
 boolean ASTOrNode.evaluate(InternalContextAdapter context)
          the logical or : the rule : left || null -> left null || right -> right null || null -> false left || right -> left || right
 boolean ASTComparisonNode.evaluate(InternalContextAdapter context)
 boolean ASTReference.evaluate(InternalContextAdapter context)
          Computes boolean value of this reference Returns the actual value of reference return type boolean, and 'true' if value is not null
 boolean ASTTrue.evaluate(InternalContextAdapter context)
 boolean ASTAndNode.evaluate(InternalContextAdapter context)
          logical and : null && right = false left && null = false null && null = false
 boolean ASTFalse.evaluate(InternalContextAdapter context)
 boolean Node.evaluate(InternalContextAdapter context)
 Object ASTIdentifier.execute(Object o, InternalContextAdapter context)
 Object SimpleNode.execute(Object o, InternalContextAdapter context)
 Object ASTReference.execute(Object o, InternalContextAdapter context)
          gets an Object that 'is' the value of the reference
 Object ASTMethod.execute(Object o, InternalContextAdapter context)
          invokes the method.
 Object ASTIndex.execute(Object o, InternalContextAdapter context)
 Object Node.execute(Object o, InternalContextAdapter context)
protected  String SimpleNode.getLocation(InternalContextAdapter context)
          Return a string that tells the current location of this node.
 Object ASTReference.getVariableValue(InternalContextAdapter context, String variable)
protected  Object ASTMathNode.handleSpecial(Object left, Object right, InternalContextAdapter context)
          Extension hook to allow special behavior by subclasses If this method returns a non-null value, that is returned, rather than the result of the math operation.
protected  Object ASTAddNode.handleSpecial(Object left, Object right, InternalContextAdapter context)
 Object ASTIdentifier.init(InternalContextAdapter context, Object data)
          simple init - don't do anything that is context specific.
 Object ASTIntegerLiteral.init(InternalContextAdapter context, Object data)
 Object SimpleNode.init(InternalContextAdapter context, Object data)
 Object ASTFloatingPointLiteral.init(InternalContextAdapter context, Object data)
          Initialization method - doesn't do much but do the object creation.
 Object ASTText.init(InternalContextAdapter context, Object data)
 Object ASTSetDirective.init(InternalContextAdapter context, Object data)
          simple init.
 Object ASTEscape.init(InternalContextAdapter context, Object data)
 Object ASTDirective.init(InternalContextAdapter context, Object data)
 Object ASTMathNode.init(InternalContextAdapter context, Object data)
 Object ASTStringLiteral.init(InternalContextAdapter context, Object data)
          init : we don't have to do much.
 Object ASTReference.init(InternalContextAdapter context, Object data)
 Object ASTMethod.init(InternalContextAdapter context, Object data)
          simple init - init our subtree and get what we can from the AST
 Object ASTIndex.init(InternalContextAdapter context, Object data)
 Object ASTTextblock.init(InternalContextAdapter context, Object data)
 Object Node.init(InternalContextAdapter context, Object data)
 Object ASTComment.init(InternalContextAdapter context, Object data)
          We need to make sure we catch any of the dreaded MORE tokens.
 Number ASTModNode.perform(Number left, Number right, InternalContextAdapter context)
 Number ASTDivNode.perform(Number left, Number right, InternalContextAdapter context)
abstract  Number ASTMathNode.perform(Number left, Number right, InternalContextAdapter context)
          Performs the math operation represented by this node.
 Number ASTMulNode.perform(Number left, Number right, InternalContextAdapter context)
 Number ASTSubtractNode.perform(Number left, Number right, InternalContextAdapter context)
 Number ASTAddNode.perform(Number left, Number right, InternalContextAdapter context)
 void ASTIfStatement.process(InternalContextAdapter context, ParserVisitor visitor)
 boolean ASTEscapedDirective.render(InternalContextAdapter context, Writer writer)
 boolean ASTElseIfStatement.render(InternalContextAdapter context, Writer writer)
 boolean SimpleNode.render(InternalContextAdapter context, Writer writer)
 boolean ASTText.render(InternalContextAdapter context, Writer writer)
 boolean ASTSetDirective.render(InternalContextAdapter context, Writer writer)
          puts the value of the RHS into the context under the key of the LHS
 boolean ASTEscape.render(InternalContextAdapter context, Writer writer)
 boolean ASTIfStatement.render(InternalContextAdapter context, Writer writer)
 boolean ASTDirective.render(InternalContextAdapter context, Writer writer)
 boolean ASTReference.render(InternalContextAdapter context, Writer writer)
          gets the value of the reference and outputs it to the writer.
 boolean ASTTextblock.render(InternalContextAdapter context, Writer writer)
 boolean Node.render(InternalContextAdapter context, Writer writer)
 boolean ASTBlock.render(InternalContextAdapter context, Writer writer)
 boolean ASTComment.render(InternalContextAdapter context, Writer writer)
 boolean ASTReference.setValue(InternalContextAdapter context, Object value)
          Sets the value of a complex reference (something like $ Currently used by ASTSetReference()
 Object ASTExpression.value(InternalContextAdapter context)
 Object ASTIntegerRange.value(InternalContextAdapter context)
          does the real work.
 Object ASTIntegerLiteral.value(InternalContextAdapter context)
 Object SimpleNode.value(InternalContextAdapter context)
 Object ASTFloatingPointLiteral.value(InternalContextAdapter context)
 Object ASTNotNode.value(InternalContextAdapter context)
 Object ASTMap.value(InternalContextAdapter context)
 Object ASTOrNode.value(InternalContextAdapter context)
          Returns the value of the expression.
 Object ASTMathNode.value(InternalContextAdapter context)
          gets the two args and performs the operation on them
 Object ASTStringLiteral.value(InternalContextAdapter context)
          renders the value of the string literal If the properties allow, and the string literal contains a $ or a # the literal is rendered against the context Otherwise, the stringlit is returned.
 Object ASTComparisonNode.value(InternalContextAdapter context)
 Object ASTReference.value(InternalContextAdapter context)
 Object ASTTrue.value(InternalContextAdapter context)
 Object ASTObjectArray.value(InternalContextAdapter context)
 Object ASTAndNode.value(InternalContextAdapter context)
          Returns the value of the expression.
 Object ASTFalse.value(InternalContextAdapter context)
 Object Node.value(InternalContextAdapter context)

Uses of InternalContextAdapter in org.apache.velocity.runtime.visitor

Fields in org.apache.velocity.runtime.visitor declared as InternalContextAdapter
protected  InternalContextAdapter BaseVisitor.context
          Context used during traversal

Methods in org.apache.velocity.runtime.visitor with parameters of type InternalContextAdapter
 void BaseVisitor.setContext(InternalContextAdapter context)

Uses of InternalContextAdapter in org.apache.velocity.util

Methods in org.apache.velocity.util with parameters of type InternalContextAdapter
static VelMethod ClassUtils.getMethod(String methodName, Object[] params, Class[] paramClasses, Object o, InternalContextAdapter context, SimpleNode node, boolean strictRef)
          Lookup a VelMethod object given the method signature that is specified in the passed in parameters.

Copyright © 2000-2012 The Apache Software Foundation. All Rights Reserved.