/**
* Returns all editors.
*
* @return editors
*/
EditorArea[] editors() {
final ArrayList<EditorArea> edits = new ArrayList<EditorArea>();
for (final Component c : tabs.getComponents()) {
if (c instanceof EditorArea) edits.add((EditorArea) c);
}
return edits.toArray(new EditorArea[edits.size()]);
}
/**
* Converts descendant to child steps.
*
* @param qc query context
* @param rt root value
* @return original or new expression
*/
private Expr children(final QueryContext qc, final Value rt) {
// skip if index does not exist or is out-dated, or if several namespaces occur in the input
final Data data = rt.data();
if (data == null || !data.meta.uptodate || data.nspaces.globalNS() == null) return this;
Path path = this;
final int sl = steps.length;
for (int s = 0; s < sl; s++) {
// don't allow predicates in preceding location steps
final Step prev = s > 0 ? axisStep(s - 1) : null;
if (prev != null && prev.preds.length != 0) break;
// ignore axes other than descendant, or numeric predicates
final Step curr = axisStep(s);
if (curr == null || curr.axis != DESC || curr.has(Flag.FCS)) continue;
// check if child steps can be retrieved for current step
ArrayList<PathNode> nodes = pathNodes(data, s);
if (nodes == null) continue;
// cache child steps
final ArrayList<QNm> qnm = new ArrayList<>();
while (nodes.get(0).parent != null) {
QNm nm = new QNm(data.elemNames.key(nodes.get(0).name));
// skip children with prefixes
if (nm.hasPrefix()) return this;
for (final PathNode p : nodes) {
if (nodes.get(0).name != p.name) nm = null;
}
qnm.add(nm);
nodes = PathSummary.parent(nodes);
}
qc.compInfo(OPTCHILD, steps[s]);
// build new steps
int ts = qnm.size();
final Expr[] stps = new Expr[ts + sl - s - 1];
for (int t = 0; t < ts; t++) {
final Expr[] preds = t == ts - 1 ? ((Preds) steps[s]).preds : new Expr[0];
final QNm nm = qnm.get(ts - t - 1);
final NameTest nt =
nm == null ? new NameTest(false) : new NameTest(nm, Kind.NAME, false, null);
stps[t] = Step.get(info, CHILD, nt, preds);
}
while (++s < sl) stps[ts++] = steps[s];
path = get(info, root, stps);
break;
}
// check if all steps yield results; if not, return empty sequence
final ArrayList<PathNode> nodes = pathNodes(qc);
if (nodes != null && nodes.isEmpty()) {
qc.compInfo(OPTPATH, path);
return Empty.SEQ;
}
return path;
}
/**
* Checks if steps before index step need to be inverted and traversed.
*
* @param data data reference
* @param iStep index step
* @return result of check
*/
private boolean predSteps(final Data data, final int iStep) {
for (int s = iStep; s >= 0; s--) {
final Step step = axisStep(s);
// ensure that the index step does not use wildcard
if (step.test.kind == Kind.WILDCARD && s != iStep) continue;
// consider child steps with name test and without predicates
if (step.test.kind != Kind.NAME
|| step.axis != Axis.CHILD
|| s != iStep && step.preds.length > 0) return true;
// support only unique paths with nodes on the correct level
final ArrayList<PathNode> pn = data.paths.desc(step.test.name.local());
if (pn.size() != 1 || pn.get(0).level() != s + 1) return true;
}
return false;
}
/**
* Adds values to the index.
*
* @param key key to be indexed
* @param vals sorted values
*/
void add(final byte[] key, final int... vals) {
// token index: add values. otherwise, reference existing values
final int id = type == IndexType.TOKEN ? values.put(key) : values.id(key), vl = vals.length;
// updatable index: if required, resize existing arrays
while (idsList.size() < id + 1) idsList.add(null);
if (lenList.size() < id + 1) lenList.set(id, 0);
final int len = lenList.get(id), size = len + vl;
int[] ids = idsList.get(id);
if (ids == null) {
ids = vals;
} else {
if (ids.length < size) ids = Arrays.copyOf(ids, Array.newSize(size));
System.arraycopy(vals, 0, ids, len, vl);
if (ids[len - 1] > vals[0]) {
if (reorder == null) reorder = new BoolList(values.size());
reorder.set(id, true);
}
}
idsList.set(id, ids);
lenList.set(id, size);
}
/**
* Converts descendant to child steps.
*
* @param ctx query context
* @param data data reference
* @return path
*/
Expr children(final QueryContext ctx, final Data data) {
// skip path check if no path index exists, or if it is out-of-date
if (!data.meta.uptodate || data.nspaces.globalNS() == null) return this;
Path path = this;
for (int s = 0; s < steps.length; ++s) {
// don't allow predicates in preceding location steps
final Step prev = s > 0 ? axisStep(s - 1) : null;
if (prev != null && prev.preds.length != 0) break;
// ignore axes other than descendant, or numeric predicates
final Step curr = axisStep(s);
if (curr == null || curr.axis != DESC || curr.has(Flag.FCS)) continue;
// check if child steps can be retrieved for current step
ArrayList<PathNode> pn = pathNodes(data, s);
if (pn == null) continue;
// cache child steps
final ArrayList<QNm> qnm = new ArrayList<>();
while (pn.get(0).par != null) {
QNm nm = new QNm(data.tagindex.key(pn.get(0).name));
// skip children with prefixes
if (nm.hasPrefix()) return this;
for (final PathNode p : pn) {
if (pn.get(0).name != p.name) nm = null;
}
qnm.add(nm);
pn = PathSummary.parent(pn);
}
ctx.compInfo(OPTCHILD, steps[s]);
// build new steps
int ts = qnm.size();
final Expr[] stps = new Expr[ts + steps.length - s - 1];
for (int t = 0; t < ts; ++t) {
final Expr[] preds = t == ts - 1 ? ((Preds) steps[s]).preds : new Expr[0];
final QNm nm = qnm.get(ts - t - 1);
final NameTest nt =
nm == null ? new NameTest(false) : new NameTest(nm, Mode.LN, false, null);
stps[t] = Step.get(info, CHILD, nt, preds);
}
while (++s < steps.length) stps[ts++] = steps[s];
path = get(info, root, stps);
break;
}
// check if the all children in the path exist; don't test with namespaces
if (data.nspaces.size() == 0) {
LOOP:
for (int s = 0; s < path.steps.length; ++s) {
// only verify child steps; ignore namespaces
final Step st = path.axisStep(s);
if (st == null || st.axis != CHILD) break;
if (st.test.mode == Mode.ALL || st.test.mode == null) continue;
if (st.test.mode != Mode.LN) break;
// check if one of the addressed nodes is on the correct level
final int name = data.tagindex.id(st.test.name.local());
for (final PathNode pn : data.paths.desc(name, Data.ELEM)) {
if (pn.level() == s + 1) continue LOOP;
}
ctx.compInfo(OPTPATH, path);
return Empty.SEQ;
}
}
return path;
}