private int findInSeq( TemplateModel target, int scanStartIndex, int seqSize) throws TemplateModelException { if (findFirst) { for (int i = scanStartIndex; i < seqSize; i++) { if (modelsEqual(i, m_seq.get(i), target, m_env)) return i; } } else { for (int i = scanStartIndex; i >= 0; i--) { if (modelsEqual(i, m_seq.get(i), target, m_env)) return i; } } return -1; }
public TemplateModel next() throws TemplateModelException { return sequence.get(index++); }
public TemplateModel get(int relIndex) throws TemplateModelException { int absIndex = baseIndex + relIndex; if (absIndex < wrappedTsm.size()) { return wrappedTsm.get(absIndex); } else { return absIndex < numberOfChunks * chunkSize ? fillerItem : null; } }
public TemplateModel get(int i) throws TemplateModelException { if (sequence != null) { return sequence.get(i); } else { initSequence(); return data.get(i); } }
public DebugModel[] get(int fromIndex, int toIndex) throws TemplateModelException, RemoteException { DebugModel[] dm = new DebugModel[toIndex - fromIndex]; TemplateSequenceModel s = (TemplateSequenceModel) model; for (int i = fromIndex; i < toIndex; i++) { dm[i - fromIndex] = getDebugModel(s.get(i)); } return dm; }
@Override TemplateModel calculateResult(TemplateSequenceModel tsm) throws TemplateModelException { int size = tsm.size(); if (size == 0) { return null; } return tsm.get(size - 1); } }
private TemplateModel calculateResultForSequence(TemplateSequenceModel seq) throws TemplateModelException { if (seq.size() == 0) { return null; } return seq.get(0); }
public TemplateModel get(int index) throws TemplateModelException { return seq.get(seq.size() - 1 - index); }
public DebugModel get(int index) throws TemplateModelException, RemoteException { return getDebugModel(((TemplateSequenceModel) model).get(index)); }
public Object exec(List args) throws TemplateModelException { checkMethodArgCount(args, 1); TemplateModel arg = (TemplateModel) args.get(0); int size = m_seq.size(); for (int i = 0; i < size; i++) { if (modelsEqual(i, m_seq.get(i), arg, m_env)) return TemplateBooleanModel.TRUE; } return TemplateBooleanModel.FALSE; }
@Override public Object get(int index) { try { return wrapper.unwrap(model.get(index)); } catch (TemplateModelException e) { throw new UndeclaredThrowableException(e); } }
private TemplateModel calculateResultForSequence(TemplateSequenceModel seq, Environment env) throws TemplateException { TemplateModel best = null; for (int i = 0; i < seq.size(); i++) { TemplateModel cur = seq.get(i); if (cur != null && (best == null || EvalUtil.compare(cur, null, comparatorOperator, null, best, null, this, true, false, false, false, env))) { best = cur; } } return best; }
@Override public PyObject __finditem__(int index) { if (model instanceof TemplateSequenceModel) { try { return unwrap(((TemplateSequenceModel) model).get(index)); } catch (TemplateModelException e) { throw Py.JavaError(e); } } throw Py.TypeError("item lookup on non-sequence model (" + getModelClass() + ")"); }
size = Integer.MAX_VALUE; return index < size ? tsm.get(index) : null;
private TemplateModel getNodeProcessor(final String nodeName, final String nsURI, int startIndex) throws TemplateException { TemplateModel result = null; int i; int size = nodeNamespaces.size(); for (i = startIndex; i < size; i++) { Namespace ns = null; try { ns = (Namespace) nodeNamespaces.get(i); } catch (ClassCastException cce) { throw new _MiscTemplateException(this, "A \"using\" clause should contain a sequence of namespaces or strings that indicate the " + "location of importable macro libraries."); } result = getNodeProcessor(ns, nodeName, nsURI); if (result != null) break; } if (result != null) { this.nodeNamespaceIndex = i + 1; this.currentNodeName = nodeName; this.currentNodeNS = nsURI; } return result; }
try { for (int i = 0; i < size; i++) { final TemplateModel seqItem = seq.get(i); Object val = tryUnwrapTo(seqItem, componentType, 0, recursionStops); if (val == ObjectWrapperAndUnwrapper.CANT_UNWRAP_TO_TARGET_CLASS) {
subvars = new String[ln]; for (int i = 0; i < ln; i++) { Object item = seq.get(i); try { subvars[i] = ((TemplateScalarModel) item)
void recurse(TemplateNodeModel node, TemplateSequenceModel namespaces) throws TemplateException, IOException { if (node == null) { node = this.getCurrentVisitorNode(); if (node == null) { throw new _TemplateModelException( "The target node of recursion is missing or null."); } } TemplateSequenceModel children = node.getChildNodes(); if (children == null) { return; } int size = children.size(); for (int i = 0; i < size; i++) { TemplateNodeModel child = (TemplateNodeModel) children.get(i); if (child != null) { invokeNodeHandlerFor(child, namespaces); } } }
TemplateSequenceModel evaluateStringsToNamespaces(Environment env) throws TemplateException { TemplateSequenceModel val = (TemplateSequenceModel) eval(env); SimpleSequence result = new SimpleSequence(val.size()); for (int i = 0; i < items.size(); i++) { Object itemExpr = items.get(i); if (itemExpr instanceof StringLiteral) { String s = ((StringLiteral) itemExpr).getAsString(); try { Environment.Namespace ns = env.importLib(s, null); result.add(ns); } catch (IOException ioe) { throw new _MiscTemplateException(((StringLiteral) itemExpr), "Couldn't import library ", new _DelayedJQuote(s), ": ", new _DelayedGetMessage(ioe)); } } else { result.add(val.get(i)); } } return result; }