Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2014 Attila Szegedi, Daniel Dekany, Jonathan Revusky
   * 
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   * 
   * http://www.apache.org/licenses/LICENSE-2.0
   * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package freemarker.core;
 
 import java.util.List;
 import java.util.Map;
 
An element representing a macro declaration.

Deprecated:
Subject to be changed or renamed any time; no "stable" replacement exists yet.
 
 public final class Macro extends TemplateElement implements TemplateModel {
 
     static final Macro DO_NOTHING_MACRO = new Macro(".pass"
             .
             .,
             nullfalse,
             .);
     
     final static int TYPE_MACRO = 0;
     final static int TYPE_FUNCTION = 1;
     
     private final String name;
     private final String[] paramNames;
     private final Map paramDefaults;
     private final String catchAllParamName;
     private final boolean function;
 
     Macro(String nameList argumentNamesMap args
             String catchAllParamNameboolean function,
             TemplateElement nestedBlock
     {
         this. = name;
         this. = (String[])argumentNames.toArray(
                 new String[argumentNames.size()]);
         this. = args;
         
         this. = function;
         this. = catchAllParamName
         
         this.setNestedBlock(nestedBlock);
     }
 
     public String getCatchAll() {
         return ;
     }
     
     public String[] getArgumentNames() {
         return (String[]).clone();
     }
 
         return ;
     }
 
     boolean hasArgNamed(String name) {
         return .containsKey(name);
     }
     
     public String getName() {
         return ;
     }
 
     void accept(Environment env) {
         env.visitMacroDef(this);
     }
 
     protected String dump(boolean canonical) {
         StringBuffer sb = new StringBuffer();
         if (canonicalsb.append('<');
         sb.append(getNodeTypeSymbol());
         sb.append(' ');
         sb.append(_CoreStringUtils.toFTLTopLevelTragetIdentifier());
         if (sb.append('(');
        int argCnt = .;
        for (int i = 0; i < argCnti++) {
            if () {
                if (i != 0) {
                    sb.append(", ");
                }
            } else {
                sb.append(' ');
            }
            String argName = [i];
            sb.append(_CoreStringUtils.toFTLTopLevelIdentifierReference(argName));
            if ( != null && .get(argName) != null) {
                sb.append('=');
                Expression defaultExpr = (Expression.get(argName);
                if () {
                    sb.append(defaultExpr.getCanonicalForm());
                } else {
                    MessageUtil.appendExpressionAsUntearable(sbdefaultExpr);
                }
            }
        }
        if ( != null) {
            if () {
                if (argCnt != 0) {
                    sb.append(", ");
                }
            } else {
                sb.append(' ');
            }
            sb.append();
            sb.append("...");
        }
        if (sb.append(')');
        if (canonical) {
            sb.append('>');
            if (getNestedBlock() != null) {
                sb.append(getNestedBlock().getCanonicalForm());
            }
            sb.append("</").append(getNodeTypeSymbol()).append('>');
        }
        return sb.toString();
    }
    
        return  ? "#function" : "#macro";
    }
    
    boolean isShownInStackTrace() {
        return false;
    }
    
    public boolean isFunction() {
        return ;
    }
    class Context implements LocalContext {
        final Environment.Namespace localVars
        final TemplateElement nestedContent;
        final List nestedContentParameterNames;
        final ArrayList prevLocalContextStack;
        final Context prevMacroContext;
        
        Context(Environment env
                TemplateElement nestedContent,
                List nestedContentParameterNames
        {
            this. = env.new Namespace();
            this. = nestedContent;
            this. = env.getCurrentNamespace();
            this. = nestedContentParameterNames;
            this. = env.getLocalContextStack();
            this. = env.getCurrentMacroContext();
        }
                
        
        Macro getMacro() {
            return Macro.this;
        }
        void runMacro(Environment envthrows TemplateExceptionIOException {
            sanityCheck(env);
            // Set default values for unspecified parameters
            if (getNestedBlock() != null) {
                env.visit(getNestedBlock());
            }
        }
        // Set default parameters, check if all the required parameters are defined.
        void sanityCheck(Environment envthrows TemplateException {
            boolean resolvedAnArghasUnresolvedArg;
            Expression firstUnresolvedExpression;
            InvalidReferenceException firstReferenceException;
            do {
                firstUnresolvedExpression = null;
                firstReferenceException = null;
                resolvedAnArg = hasUnresolvedArg = false;
                for(int i = 0; i < .; ++i) {
                    String argName = [i];
                    if(.get(argName) == null) {
                        Expression valueExp = (Expression.get(argName);
                        if (valueExp != null) {
                            try {
                                TemplateModel tm = valueExp.eval(env);
                                if(tm == null) {
                                    if(!hasUnresolvedArg) {
                                        firstUnresolvedExpression = valueExp;
                                        hasUnresolvedArg = true;
                                    }
                                }
                                else {
                                    .put(argNametm);
                                    resolvedAnArg = true;
                                }
                            }
                            catch(InvalidReferenceException e) {
                                if(!hasUnresolvedArg) {
                                    hasUnresolvedArg = true;
                                    firstReferenceException = e;
                                }
                            }
                        }
                        else if (!env.isClassicCompatible()) {
                            boolean argWasSpecified = .containsKey(argName);
                            throw new _MiscTemplateException(env,
                                    new _ErrorDescriptionBuilder(new Object[] {
                                            "When calling macro "new _DelayedJQuote(), 
                                            ", required parameter "new _DelayedJQuote(argName),
                                            " (parameter #"new Integer(i + 1), ") was "
                                            (argWasSpecified
                                                    ? "specified, but had null/missing value."
                                                    : "not specified."
                                    }).tip(argWasSpecified
                                            ? new Object[] {
                                                    "If the parameter value expression on the caller side is known to "
                                                    + "be legally null/missing, you may want to specify a default "
                                                    + "value for it with the \"!\" operator, like "
                                                    + "paramValue!defaultValue." }
                                            : new Object[] { 
                                                    "If the omission was deliberate, you may consider making the "
                                                    + "parameter optional in the macro by specifying a default value "
                                                    + "for it, like ""<#macro macroName paramName=defaultExpr>"")" }
                                            ));
                        }
                    }
                }
            }
            while(resolvedAnArg && hasUnresolvedArg);
            if(hasUnresolvedArg) {
                if(firstReferenceException != null) {
                    throw firstReferenceException;
                } else if (!env.isClassicCompatible()) {
                    throw InvalidReferenceException.getInstance(firstUnresolvedExpressionenv);
                }
            }
        }

        

Returns:
the local variable of the given name or null if it doesn't exist.
 
        public TemplateModel getLocalVariable(String namethrows TemplateModelException {
             return .get(name);
        }
        Environment.Namespace getLocals() {
            return ;
        }
        
        
Set a local variable in this macro
        void setLocalVar(String nameTemplateModel var) {
            .put(namevar);
        }
        public Collection getLocalVariableNames() throws TemplateModelException {
            HashSet result = new HashSet();
            for (TemplateModelIterator it = .keys().iterator(); it.hasNext();) {
                result.add(it.next().toString());
            }
            return result;
        }
    }
    int getParameterCount() {
        return 1/*name*/ + . * 2/*name=default*/ + 1/*catchAll*/ + 1/*type*/;
    }
    Object getParameterValue(int idx) {
        if (idx == 0) {
            return ;
        } else {
            final int argDescsEnd = . * 2 + 1;
            if (idx < argDescsEnd) {
                String paramName = [(idx - 1) / 2];
                if (idx % 2 != 0) {
                    return paramName;
                } else {
                    return .get(paramName);
                }
            } else if (idx == argDescsEnd) {
                return ;
            } else if (idx == argDescsEnd + 1) {
                return new Integer( ?  : );
            } else {
                throw new IndexOutOfBoundsException();
            }
        }
    }
    ParameterRole getParameterRole(int idx) {
        if (idx == 0) {
            return .;
        } else {
            final int argDescsEnd = . * 2 + 1;
            if (idx < argDescsEnd) {
                if (idx % 2 != 0) {
                    return .;
                } else {
                    return .;
                }
            } else if (idx == argDescsEnd) {
                return .;
            } else if (idx == argDescsEnd + 1) {
                return .;
            } else {
                throw new IndexOutOfBoundsException();
            }
        }
    }
    boolean isNestedBlockRepeater() {
        // Because of recursive calls
        return true;
    }
    
New to GrepCode? Check out our FAQ X