/** Calculates the accumulated PRE value shifts for all updates on the list. */
private void accumulatePreValueShifts() {
if (!dirty) return;
int s = 0;
for (int i = updStructural.size() - 1; i >= 0; i--) {
final BasicUpdate t = updStructural.get(i);
s += t.shifts;
t.accumulatedShifts = s;
}
dirty = false;
}
/**
* Calculates the PRE value of a given node before/after updates.
*
* <p>Finds all updates that affect the given node N. The result is than calculated based on N and
* the accumulated PRE value shifts introduced by these updates.
*
* <p>If a node has been inserted at position X and this method is used to calculate the PRE value
* of X before updates, X is the result. As the node at position X has not existed before the
* insertion, its PRE value is unchanged. If in contrast the PRE value is calculated after
* updates, the result is X+1, as the node with the original position X has been shifted by the
* insertion at position X.
*
* <p>Make sure accumulated shifts have been calculated before calling this method!
*
* @param pre PRE value
* @param beforeUpdates calculate PRE value before shifts/updates have been applied
* @return index of update, or -1
*/
public int calculatePreValue(final int pre, final boolean beforeUpdates) {
int i = find(pre, beforeUpdates);
// given PRE not changed by updates
if (i == -1) return pre;
i = refine(updStructural, i, beforeUpdates);
final int acm = updStructural.get(i).accumulatedShifts;
return beforeUpdates ? pre - acm : pre + acm;
}
/**
* Resolves unwanted text node adjacency which can result from structural changes in the database.
* Adjacent text nodes are two text nodes A and B, where PRE(B)=PRE(A)+1 and PARENT(A)=PARENT(B).
*/
private void resolveTextAdjacency() {
// Text node merges are also gathered on a separate list to leverage optimizations.
final AtomicUpdateList allMerges = new AtomicUpdateList(data);
// keep track of the visited locations to avoid superfluous checks
final IntSet s = new IntSet();
// Text nodes have to be merged from the highest to the lowest pre value
for (int i = 0; i < updStructural.size(); i++) {
final BasicUpdate u = updStructural.get(i);
final Data insseq = u.getInsertionData();
// calculate the new location of the update, here we have to check for adjacency
final int newLocation = u.location + u.accumulatedShifts - u.shifts;
final int beforeNewLocation = newLocation - 1;
// check surroundings of this location for adjacent text nodes depending on the
// kind of update, first the one with higher PRE values (due to shifts!)
// ... for insert/replace ...
if (insseq != null) {
// calculate the current following node
final int followingNode = newLocation + insseq.meta.size;
final int beforeFollowingNode = followingNode - 1;
// check the nodes at the end of/after the insertion sequence
if (!s.contains(beforeFollowingNode)) {
final AtomicUpdateList merges = necessaryMerges(beforeFollowingNode, allMerges.data);
mergeNodes(merges);
allMerges.merge(merges);
s.add(beforeFollowingNode);
}
}
// check nodes for delete and for insert before the updated location
if (!s.contains(beforeNewLocation)) {
final AtomicUpdateList merges = necessaryMerges(beforeNewLocation, allMerges.data);
mergeNodes(merges);
allMerges.merge(merges);
s.add(beforeNewLocation);
}
}
allMerges.updateDistances();
allMerges.clear();
}
/**
* Removes superfluous update operations. If a node T is deleted or replaced, all updates on the
* descendant axis of T can be left out as they won't affect the database after all.
*
* <p>Superfluous updates can have a minimum PRE value of pre(T)+1 and a maximum PRE value of
* pre(T)+size(T).
*
* <p>An update with location pre(T)+size(T) can only be removed if the update is an atomic insert
* and the inserted node is then part of the subtree of T.
*/
public void optimize() {
if (opt) return;
check();
// traverse from lowest to highest PRE value
int i = updStructural.size() - 1;
while (i >= 0) {
final BasicUpdate u = updStructural.get(i);
// If this update can lead to superfluous updates ...
if (u.destructive()) {
// we determine the lowest and highest PRE values of a superfluous update
final int pre = u.location;
final int fol = pre + data.size(pre, data.kind(pre));
i--;
// and have a look at the next candidate
while (i >= 0) {
final BasicUpdate desc = updStructural.get(i);
final int descpre = desc.location;
// if the candidate operates on the subtree of T and inserts a node ...
if (descpre <= fol
&& (desc instanceof Insert || desc instanceof InsertAttr)
&& desc.parent() >= pre
&& desc.parent() < fol) {
// it is removed.
updStructural.remove(i--);
// Other updates (not inserting a node) that operate on the subtree of T can
// only have a PRE value that is smaller than the following PRE of T
} else if (descpre < fol) {
// these we delete.
updStructural.remove(i--);
// Else there's nothing to delete
} else break;
}
} else i--;
}
opt = true;
}
/**
* Checks the list of updates for violations. Updates must be ordered strictly from the highest to
* the lowest PRE value.
*
* <p>A single node must not be affected by more than one {@link Rename}, {@link UpdateValue}
* operation.
*
* <p>A single node must not be affected by more than one destructive operation. These operations
* include {@link Replace}, {@link Delete}.
*/
public void check() {
if (ok || updStructural.size() < 2 && updValue.size() < 2) return;
int i = 0;
while (i + 1 < updStructural.size()) {
final BasicUpdate current = updStructural.get(i);
final BasicUpdate next = updStructural.get(++i);
// check order of location PRE
if (current.location < next.location)
Util.notexpected("Invalid order at location " + current.location);
if (current.location == next.location) {
// check multiple {@link Delete}, {@link Replace}
if (current.destructive() && next.destructive())
Util.notexpected("Multiple deletes/replaces on node " + current.location);
}
}
i = 0;
while (i + 1 < updValue.size()) {
final BasicUpdate current = updValue.get(i++);
final BasicUpdate next = updValue.get(i);
// check order of location PRE
if (current.location < next.location)
Util.notexpected("Invalid order at location " + current.location);
if (current.location == next.location) {
// check multiple {@link Rename}
if (current instanceof Rename && next instanceof Rename)
Util.notexpected("Multiple renames on node " + current.location);
// check multiple {@link UpdateValue}
if (current instanceof UpdateValue && next instanceof UpdateValue)
Util.notexpected("Multiple updates on node " + current.location);
}
}
ok = true;
}
/**
* Finds the position of the update with the lowest index that affects the given PRE value P. If
* there are multiple updates whose affected PRE value equals P, the search has to be further
* refined as this method returns the first match.
*
* @param pre given PRE value
* @param beforeUpdates compare based on PRE values before/after updates
* @return index of update
*/
private int find(final int pre, final boolean beforeUpdates) {
int left = 0;
int right = updStructural.size() - 1;
while (left <= right) {
if (left == right) {
if (c(updStructural, left, beforeUpdates) <= pre) return left;
return -1;
}
if (right - left == 1) {
if (c(updStructural, left, beforeUpdates) <= pre) return left;
if (c(updStructural, right, beforeUpdates) <= pre) return right;
return -1;
}
final int middle = left + right >>> 1;
final int value = c(updStructural, middle, beforeUpdates);
if (value == pre) return middle;
else if (value > pre) left = middle + 1;
else right = middle;
}
// empty array
return -1;
}
/**
* Recalculates the PRE value of the first node whose distance is affected by the given update.
*
* @param l list of updates
* @param index index of the update
* @param beforeUpdates calculate PRE value before or after updates
* @return PRE value
*/
private int c(final List<BasicUpdate> l, final int index, final boolean beforeUpdates) {
final BasicUpdate u = l.get(index);
return u.preOfAffectedNode + (beforeUpdates ? u.accumulatedShifts : 0);
}
/**
* Adds all updates in a given list B to the end of the updates in this list (A).
*
* <p>As updates must be unambiguous and are ordered from the highest to the lowest PRE value,
* make sure that all updates in B access PRE values smaller than any update in A.
*
* <p>Mainly used to resolve text node adjacency.
*
* @param toMerge given list that is appended to the end of this list
*/
private void merge(final AtomicUpdateList toMerge) {
updStructural.addAll(toMerge.updStructural);
updValue.addAll(toMerge.updValue);
dirty();
}
/**
* Adds an update to the corresponding list.
*
* @param u atomic update
* @param s true if given update performs structural changes, false if update only alters values
*/
private void add(final BasicUpdate u, final boolean s) {
if (s) updStructural.add(u);
else updValue.add(u);
dirty();
}
/** Resets the list. */
public void clear() {
updStructural.clear();
updValue.clear();
dirty();
}
/**
* Returns the number of value updates.
*
* @return number of value updates
*/
public int valueUpdatesSize() {
return updValue.size();
}
/**
* Returns the number of structural updates.
*
* @return number of structural updates
*/
public int structuralUpdatesSize() {
return updStructural.size();
}