void accept(Environment env) throws IOException, TemplateException { TemplateModel node = targetNode == null ? null : targetNode.getAsTemplateModel(env); TemplateModel nss = namespaces == null ? null : namespaces.getAsTemplateModel(env); if (namespaces instanceof StringLiteral) { nss = env.importLib(((TemplateScalarModel) nss).getAsString(), null); } else if (namespaces instanceof ListLiteral) { nss = ((ListLiteral) namespaces).evaluateStringsToNamespaces(env); } if (node != null && !(node instanceof TemplateNodeModel)) { throw new TemplateException( "Expecting an XML node here, for expression: " + targetNode + ", found a: " + node.getClass().getName(), env); } if (nss != null) { if (nss instanceof TemplateHashModel) { SimpleSequence ss = new SimpleSequence(1); ss.add(nss); nss = ss; } else if (!(nss instanceof TemplateSequenceModel)) { throw new TemplateException("Expecting a sequence of namespaces after 'using'", env); } } env.recurse((TemplateNodeModel) node, (TemplateSequenceModel) nss); }
void accept(Environment env) throws TemplateException, IOException { TemplateModel baseModel = listExpression.getAsTemplateModel(env); if (baseModel == null) { if (env.isClassicCompatible()) { // Classic behavior of simply ignoring null references. return; } assertNonNull(baseModel, listExpression, env); } env.visit(new Context(baseModel)); }
/* * WARNING! This algorithm is duplicated in SequenceBuiltins.modelsEqual. * Thus, if you update this method, then you have to update that too! */ boolean isTrue(Environment env) throws TemplateException { TemplateModel ltm = left.getAsTemplateModel(env); TemplateModel rtm = right.getAsTemplateModel(env); if (env != null && env.isClassicCompatible()) { if (ltm == null) { ltm = TemplateScalarModel.EMPTY_STRING; } if (rtm == null) { rtm = TemplateScalarModel.EMPTY_STRING; } } assertNonNull(ltm, left, env); assertNonNull(rtm, right, env); int comp = 0; if (ltm instanceof TemplateNumberModel && rtm instanceof TemplateNumberModel) { Number first = EvaluationUtil.getNumber((TemplateNumberModel) ltm, left, env); Number second = EvaluationUtil.getNumber((TemplateNumberModel) rtm, right, env); ArithmeticEngine ae = env != null ? env.getArithmeticEngine() : getTemplate().getArithmeticEngine(); comp = ae.compareNumbers(first, second); } else if (ltm instanceof TemplateDateModel && rtm instanceof TemplateDateModel) { TemplateDateModel ltdm = (TemplateDateModel) ltm; TemplateDateModel rtdm = (TemplateDateModel) rtm; int ltype = ltdm.getDateType(); int rtype = rtdm.getDateType(); if (ltype != rtype) { throw new TemplateException( "Can not compare dates of different type. Left date is of " + TemplateDateModel.TYPE_NAMES.get(ltype) + " type, right date is of " + TemplateDateModel.TYPE_NAMES.get(rtype) + " type.", env); } if (ltype == TemplateDateModel.UNKNOWN) { throw new TemplateException("Left date is of UNKNOWN type, and can not be compared.", env); } if (rtype == TemplateDateModel.UNKNOWN) { throw new TemplateException("Right date is of UNKNOWN type, and can not be compared.", env); } Date first = EvaluationUtil.getDate(ltdm, left, env); Date second = EvaluationUtil.getDate(rtdm, right, env); comp = first.compareTo(second); } else if (ltm instanceof TemplateScalarModel && rtm instanceof TemplateScalarModel) { if (operation != EQUALS && operation != NOT_EQUALS) { throw new TemplateException("Can not use operator " + opString + " on string values.", env); } String first = EvaluationUtil.getString((TemplateScalarModel) ltm, left, env); String second = EvaluationUtil.getString((TemplateScalarModel) rtm, right, env); comp = env.getCollator().compare(first, second); } else if (ltm instanceof TemplateBooleanModel && rtm instanceof TemplateBooleanModel) { if (operation != EQUALS && operation != NOT_EQUALS) { throw new TemplateException( "Can not use operator " + opString + " on boolean values.", env); } boolean first = ((TemplateBooleanModel) ltm).getAsBoolean(); boolean second = ((TemplateBooleanModel) rtm).getAsBoolean(); comp = (first ? 1 : 0) - (second ? 1 : 0); } // Here we handle compatibility issues else if (env.isClassicCompatible()) { String first = left.getStringValue(env); String second = right.getStringValue(env); comp = env.getCollator().compare(first, second); } else { throw new TemplateException( "The only legal comparisons are between two numbers, two strings, or two dates.\n" + "Left hand operand is a " + ltm.getClass().getName() + "\n" + "Right hand operand is a " + rtm.getClass().getName() + "\n", env); } switch (operation) { case EQUALS: return comp == 0; case NOT_EQUALS: return comp != 0; case LESS_THAN: return comp < 0; case GREATER_THAN: return comp > 0; case LESS_THAN_EQUALS: return comp <= 0; case GREATER_THAN_EQUALS: return comp >= 0; default: throw new TemplateException("unknown operation", env); } }
static Number getNumber(Expression expr, Environment env) throws TemplateException { TemplateModel model = expr.getAsTemplateModel(env); return getNumber(model, expr, env); }