/**
* Returns atomic text node merging operations if necessary for the given node PRE and its right
* neighbor PRE+1.
*
* @param a node PRE value
* @param d target data reference
* @return list of text merging operations
*/
private AtomicUpdateList necessaryMerges(final int a, final Data d) {
final AtomicUpdateList mergeTwoNodes = new AtomicUpdateList(d);
final int s = d.meta.size;
final int b = a + 1;
// don't leave table
if (a >= s || b >= s || a < 0 || b < 0) return mergeTwoNodes;
// only merge texts
if (d.kind(a) != Data.TEXT || d.kind(b) != Data.TEXT) return mergeTwoNodes;
// only merge neighboring texts
if (d.parent(a, Data.TEXT) != d.parent(b, Data.TEXT)) return mergeTwoNodes;
mergeTwoNodes.addDelete(b);
mergeTwoNodes.addUpdateValue(a, Data.TEXT, Token.concat(d.text(a, true), d.text(b, true)));
return mergeTwoNodes;
}
/**
* 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();
}
@Override
public void addAtomics(final AtomicUpdateList l) {
l.addReplace(targetPre, insseq);
}
/**
* Applies text node merges of the given list.
*
* @param mergeTexts list of atomic text node merging operations
*/
private void mergeNodes(final AtomicUpdateList mergeTexts) {
mergeTexts.check();
mergeTexts.applyValueUpdates();
mergeTexts.applyStructuralUpdates();
}