@Override
public final boolean has(final Flag flag) {
// first step or root expression will be used as context
if (flag == Flag.CTX) return root == null || root.has(flag);
for (final Expr s : steps) if (s.has(flag)) return true;
return root != null && root.has(flag);
}
@Override
public void checkUp() throws QueryException {
for (final Let c : copies) c.checkUp();
final Expr m = expr[0];
m.checkUp();
if (!m.isVacuous() && !m.has(Flag.UPD)) throw UPMODIFY.get(info);
checkNoUp(expr[1]);
}
/**
* Merges expensive descendant-or-self::node() steps.
*
* @param qc query context
* @return original or new expression
*/
private Expr mergeSteps(final QueryContext qc) {
boolean opt = false;
final int sl = steps.length;
final ExprList stps = new ExprList(sl);
for (int s = 0; s < sl; s++) {
final Expr step = steps[s];
// check for simple descendants-or-self step with succeeding step
if (s < sl - 1 && step instanceof Step) {
final Step curr = (Step) step;
if (curr.simple(DESCORSELF, false)) {
// check succeeding step
final Expr next = steps[s + 1];
// descendant-or-self::node()/child::X -> descendant::X
if (simpleChild(next)) {
((Step) next).axis = DESC;
opt = true;
continue;
}
// descendant-or-self::node()/(X, Y) -> (descendant::X | descendant::Y)
Expr e = mergeList(next);
if (e != null) {
steps[s + 1] = e;
opt = true;
continue;
}
// //(X, Y)[text()] -> (/descendant::X | /descendant::Y)[text()]
if (next instanceof Filter && !next.has(Flag.FCS)) {
final Filter f = (Filter) next;
e = mergeList(f.root);
if (e != null) {
f.root = e;
opt = true;
continue;
}
}
}
}
stps.add(step);
}
if (opt) {
qc.compInfo(OPTDESC);
return get(info, root, stps.finish());
}
return this;
}
@Override
public boolean has(final Flag flag) {
if (occ != null) for (final Expr o : occ) if (o.has(flag)) return true;
return query.has(flag);
}
