Context(Environment env) throws TemplateException { invokingMacroContext = env.getCurrentMacroContext(); List bodyParameterNames = invokingMacroContext.nestedContentParameterNames; if (bodyParameters != null) { for (int i = 0; i < bodyParameters.size(); i++) { Expression exp = (Expression) bodyParameters.get(i); TemplateModel tm = exp.eval(env); if (bodyParameterNames != null && i < bodyParameterNames.size()) { String bodyParameterName = (String) bodyParameterNames.get(i); if (bodyVars == null) { bodyVars = env.new Namespace(); } bodyVars.put(bodyParameterName, tm); } } } }
/** * Defines the given macro in the current namespace (doesn't call it). */ void visitMacroDef(Macro macro) { macroToNamespaceLookup.put(macro, currentNamespace); currentNamespace.put(macro.getName(), macro); }
@Override public void close() throws IOException { SimpleScalar result = new SimpleScalar(buf.toString()); try { if (localVar) { env.setLocalVariable(varName, result); } else if (globalVar) { env.setGlobalVariable(varName, result); } else { if (nsModel == null) { env.setVariable(varName, result); } else { ((Environment.Namespace) nsModel).put(varName, result); } } } catch (java.lang.IllegalStateException ise) { // if somebody uses 'local' outside a macro throw new IOException("Could not set variable " + varName + ": " + ise.getMessage()); } } };
/** * Sets a variable that is visible globally. This is correspondent to FTL * <code><#global <i>name</i>=<i>model</i>></code>. This can be considered a convenient shorthand for: * getGlobalNamespace().put(name, model) */ public void setGlobalVariable(String name, TemplateModel model) { globalNamespace.put(name, model); }
/** * Defines the given macro in the current namespace (doesn't call it). */ void visitMacroDef(Macro macro) { macroToNamespaceLookup.put(macro, currentNamespace); currentNamespace.put(macro.getName(), macro); }
/** * Set a local variable in this macro */ void setLocalVar(String name, TemplateModel var) { localVars.put(name, var); }
@Override public void put(String key, Object value) { ensureInitializedRTE(); super.put(key, value); }
/** * Set a local variable in this macro */ void setLocalVar(String name, TemplateModel var) { localVars.put(name, var); }
/** * Defines the given macro in the current namespace (doesn't call it). */ void visitMacroDef(Macro macro) { macroToNamespaceLookup.put(macro, currentNamespace); currentNamespace.put(macro.getName(), macro); }
private Map<String, TemplateModel> reduce() throws TemplateModelException { Map<String, TemplateModel> reduceMap = new LinkedHashMap<>(); ObjectWrapper objectWrapper = environment.getObjectWrapper(); Namespace namespace = environment.getCurrentNamespace(); Iterator<Entry<String, Object>> iterator = map.entrySet().iterator(); for (int i = 0; iterator.hasNext(); i++) { Entry<String, Object> entry = iterator.next(); if (i < loopVars.length) { loopVars[i] = objectWrapper.wrap(entry.getValue()); } else { String key = entry.getKey(); reduceMap.put(key, namespace.get(key)); namespace.put(key, objectWrapper.wrap(entry.getValue())); } } return reduceMap; }
private Map<String, TemplateModel> reduce() throws TemplateModelException { Map<String, TemplateModel> reduceMap = new LinkedHashMap<>(); ObjectWrapper objectWrapper = environment.getObjectWrapper(); Namespace namespace = environment.getCurrentNamespace(); Iterator<Entry<String, Object>> iterator = map.entrySet().iterator(); for (int i = 0; iterator.hasNext(); i++) { Entry<String, Object> entry = iterator.next(); if (i < loopVars.length) { loopVars[i] = objectWrapper.wrap(entry.getValue()); } else { String key = entry.getKey(); reduceMap.put(key, namespace.get(key)); namespace.put(key, objectWrapper.wrap(entry.getValue())); } } return reduceMap; }
env.setLocalVariable(variableName, value); } else { namespace.put(variableName, value);
localVars.put(argName, tm); resolvedAnArg = true;
setVariable(targetNsVarName, existingNamespace); if (isIcI2324OrLater() && currentNamespace == mainNamespace) { globalNamespace.put(targetNsVarName, existingNamespace); setVariable(targetNsVarName, newNamespace); if (currentNamespace == mainNamespace) { globalNamespace.put(targetNsVarName, newNamespace);
@Override TemplateElement[] accept(Environment env) throws TemplateException, IOException { TemplateElement[] children = getChildBuffer(); TemplateModel value; if (children != null) { StringWriter out = new StringWriter(); env.visit(children, out); value = capturedStringToModel(out.toString()); } else { value = capturedStringToModel(""); } if (namespaceExp != null) { ((Environment.Namespace) namespaceExp.eval(env)).put(varName, value); } else if (scope == Assignment.NAMESPACE) { env.setVariable(varName, value); } else if (scope == Assignment.GLOBAL) { env.setGlobalVariable(varName, value); } else if (scope == Assignment.LOCAL) { env.setLocalVariable(varName, value); } else { throw new BugException("Unhandled scope"); } return null; }
@Override public void put(String key, Object value) { ensureInitializedRTE(); super.put(key, value); }
/** * Sets a variable in the current namespace. This is correspondent to FTL * <code><#assign <i>name</i>=<i>model</i>></code>. This can be considered a convenient shorthand for: * getCurrentNamespace().put(name, model) */ public void setVariable(String name, TemplateModel model) { currentNamespace.put(name, model); }
/** * Sets a variable that is visible globally. This is correspondent to FTL * <code><#global <i>name</i>=<i>model</i>></code>. This can be considered a convenient shorthand for: * getGlobalNamespace().put(name, model) */ public void setGlobalVariable(String name, TemplateModel model) { globalNamespace.put(name, model); }
@Override public void put(String key, boolean b) { ensureInitializedRTE(); super.put(key, b); }
/** * Set a local variable in this macro */ void setLocalVar(String name, TemplateModel var) { localVars.put(name, var); }