Class ASTExpr

  • Direct Known Subclasses:
    ConditionalExpr

    public class ASTExpr
    extends Expr
    A single string template expression enclosed in $...; separator=...$ parsed into an AST chunk to be evaluated.
    • Field Detail

      • DEFAULT_ATTRIBUTE_NAME

        public static final java.lang.String DEFAULT_ATTRIBUTE_NAME
        See Also:
        Constant Field Values
      • DEFAULT_ATTRIBUTE_NAME_DEPRECATED

        public static final java.lang.String DEFAULT_ATTRIBUTE_NAME_DEPRECATED
        See Also:
        Constant Field Values
      • DEFAULT_INDEX_VARIABLE_NAME

        public static final java.lang.String DEFAULT_INDEX_VARIABLE_NAME
        See Also:
        Constant Field Values
      • DEFAULT_INDEX0_VARIABLE_NAME

        public static final java.lang.String DEFAULT_INDEX0_VARIABLE_NAME
        See Also:
        Constant Field Values
      • DEFAULT_MAP_VALUE_NAME

        public static final java.lang.String DEFAULT_MAP_VALUE_NAME
        See Also:
        Constant Field Values
      • DEFAULT_MAP_KEY_NAME

        public static final java.lang.String DEFAULT_MAP_KEY_NAME
        See Also:
        Constant Field Values
      • MAP_KEY_VALUE

        public static final StringTemplate MAP_KEY_VALUE
        Used to indicate "default:key" in maps within groups
      • EMPTY_OPTION

        public static final java.lang.String EMPTY_OPTION
        Using an expr option w/o value, makes options table hold EMPTY_OPTION value for that key.
        See Also:
        Constant Field Values
      • defaultOptionValues

        public static final java.util.Map defaultOptionValues
      • supportedOptions

        public static final java.util.Set supportedOptions
        John Snyders gave me an example implementation for this checking
    • Constructor Detail

      • ASTExpr

        public ASTExpr​(StringTemplate enclosingTemplate,
                       antlr.collections.AST exprTree,
                       java.util.Map options)
    • Method Detail

      • getAST

        public antlr.collections.AST getAST()
        Return the tree interpreted when this template is written out.
      • write

        public int write​(StringTemplate self,
                         StringTemplateWriter out)
                  throws java.io.IOException
        To write out the value of an ASTExpr, invoke the evaluator in eval.g to walk the tree writing out the values. For efficiency, don't compute a bunch of strings and then pack them together. Write out directly. Compute separator and wrap expressions, save as strings so we don't recompute for each value in a multi-valued attribute or expression. If they set anchor option, then inform the writer to push current char position.
        Specified by:
        write in class Expr
        Throws:
        java.io.IOException
      • handleExprOptions

        protected void handleExprOptions​(StringTemplate self)
        Grab and cache options; verify options are valid
      • applyTemplateToListOfAttributes

        public java.lang.Object applyTemplateToListOfAttributes​(StringTemplate self,
                                                                java.util.List attributes,
                                                                StringTemplate templateToApply)
        For treat the names, phones as lists to be walked in lock step as n=names[i], p=phones[i].
      • applyListOfAlternatingTemplates

        public java.lang.Object applyListOfAlternatingTemplates​(StringTemplate self,
                                                                java.lang.Object attributeValue,
                                                                java.util.List templatesToApply)
      • setSoleFormalArgumentToIthValue

        protected void setSoleFormalArgumentToIthValue​(StringTemplate embedded,
                                                       java.util.Map argumentContext,
                                                       java.lang.Object ithValue)
      • getObjectProperty

        public java.lang.Object getObjectProperty​(StringTemplate self,
                                                  java.lang.Object o,
                                                  java.lang.Object propertyName)
        Return o.getPropertyName() given o and propertyName. If o is a stringtemplate then access it's attributes looking for propertyName instead (don't check any of the enclosing scopes; look directly into that object). Also try isXXX() for booleans. Allow Map as special case (grab value for key). Cache repeated requests for obj.prop within same group.
      • rawGetObjectProperty

        protected java.lang.Object rawGetObjectProperty​(StringTemplate self,
                                                        java.lang.Object o,
                                                        java.lang.Object property)
      • accessField

        protected java.lang.Object accessField​(java.lang.reflect.Field f,
                                               java.lang.Object o,
                                               java.lang.Object value)
                                        throws java.lang.IllegalAccessException
        Throws:
        java.lang.IllegalAccessException
      • invokeMethod

        protected java.lang.Object invokeMethod​(java.lang.reflect.Method m,
                                                java.lang.Object o,
                                                java.lang.Object value)
                                         throws java.lang.IllegalAccessException,
                                                java.lang.reflect.InvocationTargetException
        Throws:
        java.lang.IllegalAccessException
        java.lang.reflect.InvocationTargetException
      • getMethod

        protected java.lang.reflect.Method getMethod​(java.lang.Class c,
                                                     java.lang.String methodName)
      • testAttributeTrue

        public boolean testAttributeTrue​(java.lang.Object a)
        Normally StringTemplate tests presence or absence of attributes for adherence to my principles of separation, but some people disagree and want to change. For 2.0, if the object is a boolean, do something special. $if(boolean)$ will actually test the value. Now, this breaks my rules of entanglement listed in my paper, but it truly surprises programmers to have booleans always true. Further, the key to isolating logic in the model is avoiding operators (for which you need attribute values). But, no operator is needed to use boolean values. Well, actually I guess "!" (not) is an operator. Regardless, for practical reasons, I'm going to technically violate my rules as I currently have them defined. Perhaps for a future version of the paper I will refine the rules. Post 2.1, I added a check for non-null Iterators, Collections, ... with size==0 to return false. TJP 5/1/2005
      • add

        public java.lang.Object add​(java.lang.Object a,
                                    java.lang.Object b)
        For now, we can only add two objects as strings; convert objects to Strings then cat.
      • getTemplateInclude

        public StringTemplate getTemplateInclude​(StringTemplate enclosing,
                                                 java.lang.String templateName,
                                                 StringTemplateAST argumentsAST)
        Call a string template with args and return result. Do not convert to a string yet. It may need attributes that will be available after this is inserted into another template.
      • writeAttribute

        public int writeAttribute​(StringTemplate self,
                                  java.lang.Object o,
                                  StringTemplateWriter out)
        How to spit out an object. If it's not a StringTemplate nor a List, just do o.toString(). If it's a StringTemplate, do o.write(out). If it's a Vector, do a write(out, o.elementAt(i)) for all elements. Note that if you do something weird like set the values of a multivalued tag to be vectors, it will effectively flatten it. If self is an embedded template, you might have specified a separator arg; used when is a vector.
      • writeTemplate

        protected int writeTemplate​(StringTemplate self,
                                    java.lang.Object o,
                                    StringTemplateWriter out)
                             throws java.io.IOException
        Throws:
        java.io.IOException
      • writeIterableValue

        protected int writeIterableValue​(StringTemplate self,
                                         java.lang.Object o,
                                         StringTemplateWriter out)
                                  throws java.io.IOException
        Throws:
        java.io.IOException
      • evaluateExpression

        public java.lang.String evaluateExpression​(StringTemplate self,
                                                   java.lang.Object expr)
        A expr is normally just a string literal, but is still an AST that we must evaluate. The expr can be any expression such as a template include or string cat expression etc... Evaluate with its own writer so that we can convert to string and then reuse, don't want to compute all the time; must precompute w/o writing to output buffer.
      • evaluateArguments

        protected void evaluateArguments​(StringTemplate self)
        Evaluate an argument list within the context of the enclosing template but store the values in the context of self, the new embedded template. For example, bold(item=item) means that bold.item should get the value of enclosing.item.
      • convertArrayToList

        public static java.lang.Object convertArrayToList​(java.lang.Object value)
        Do a standard conversion of array attributes to a List. Wrap the array instead of copying like old version. Make an ArrayWrappedInList that knows to create an ArrayIterator.
      • convertAnythingIteratableToIterator

        protected static java.lang.Object convertAnythingIteratableToIterator​(java.lang.Object o)
      • convertAnythingToIterator

        protected static java.util.Iterator convertAnythingToIterator​(java.lang.Object o)
      • first

        public java.lang.Object first​(java.lang.Object attribute)
        Return the first attribute if multiple valued or the attribute itself if single-valued. Used in
      • rest

        public java.lang.Object rest​(java.lang.Object attribute)
        Return the everything but the first attribute if multiple valued or null if single-valued. Used in .
      • last

        public java.lang.Object last​(java.lang.Object attribute)
        Return the last attribute if multiple valued or the attribute itself if single-valued. Used in . This is pretty slow as it iterates until the last element. Ultimately, I could make a special case for a List or Vector.
      • strip

        public java.lang.Object strip​(java.lang.Object attribute)
        Return a new list w/o null values.
      • trunc

        public java.lang.Object trunc​(java.lang.Object attribute)
        Return all but the last element. trunc(x)=null if x is single-valued.
      • length

        public java.lang.Object length​(java.lang.Object attribute)
        Return the length of a multiple valued attribute or 1 if it is a single attribute. If attribute is null return 0. Special case several common collections and primitive arrays for speed. This method by Kay Roepke.
      • getOption

        public java.lang.Object getOption​(java.lang.String name)
      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object