Skip to content

Commit

Permalink
moved extraction of reshuffled diffElements out of the loop with the …
Browse files Browse the repository at this point in the history 
…rest
  • Loading branch information
@ThLeu
ThLeu committed Jun 7, 2018
1 parent 6cc0b68 commit 996b784
Showing 1 changed file with 82 additions and 74 deletions.
156 changes: 82 additions & 74 deletions ...rser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/Difference.java
View file
Expand Up @@ -121,6 +121,8 @@ private int considerEnforcingIndentation(NodeText nodeText, int nodeTextIndex) {
* to the difference (adding and removing the elements provided). * to the difference (adding and removing the elements provided).
*/ */
void apply() { void apply() {
extractReshuffledDiffElements(diffElements);

do { do {
if (diffIndex < diffElements.size() && originalIndex >= originalElements.size()) { if (diffIndex < diffElements.size() && originalIndex >= originalElements.size()) {
DifferenceElement diffElement = diffElements.get(diffIndex); DifferenceElement diffElement = diffElements.get(diffIndex);
Expand Down Expand Up @@ -165,8 +167,6 @@ void apply() {
applyKeptDiffElement((Kept) diffElement, originalElement, originalElementIsChild, originalElementIsToken); applyKeptDiffElement((Kept) diffElement, originalElement, originalElementIsChild, originalElementIsToken);
} else if (diffElement instanceof Removed) { } else if (diffElement instanceof Removed) {
applyRemovedDiffElement((Removed) diffElement, originalElement, originalElementIsChild, originalElementIsToken); applyRemovedDiffElement((Removed) diffElement, originalElement, originalElementIsChild, originalElementIsToken);
} else if (diffElement instanceof Reshuffled) {
applyReshuffledDiffElement((Reshuffled) diffElement);
} else { } else {
throw new UnsupportedOperationException("" + diffElement + " vs " + originalElement); throw new UnsupportedOperationException("" + diffElement + " vs " + originalElement);
} }
Expand All @@ -175,92 +175,100 @@ void apply() {
} while (diffIndex < diffElements.size() || originalIndex < originalElements.size()); } while (diffIndex < diffElements.size() || originalIndex < originalElements.size());
} }


private void applyReshuffledDiffElement(Reshuffled reshuffled) { private void extractReshuffledDiffElements(List<DifferenceElement> diffElements) {
// First, let's see how many tokens we need to attribute to the previous version of the of the CsmMix for (int index = 0; index < diffElements.size(); index++) {
CsmMix elementsFromPreviousOrder = reshuffled.getPreviousOrder(); DifferenceElement diffElement = diffElements.get(index);
CsmMix elementsFromNextOrder = reshuffled.getNextOrder(); if (diffElement instanceof Reshuffled) {

Reshuffled reshuffled = (Reshuffled) diffElement;
// This contains indexes from elementsFromNextOrder to indexes from elementsFromPreviousOrder
Map<Integer, Integer> correspondanceBetweenNextOrderAndPreviousOrder = getCorrespondanceBetweenNextOrderAndPreviousOrder(elementsFromPreviousOrder, elementsFromNextOrder);


// We now find out which Node Text elements corresponds to the elements in the original CSM // First, let's see how many tokens we need to attribute to the previous version of the of the CsmMix
List<Integer> nodeTextIndexOfPreviousElements = findIndexOfCorrespondingNodeTextElement(elementsFromPreviousOrder.getElements(), nodeText, originalIndex, node); CsmMix elementsFromPreviousOrder = reshuffled.getPreviousOrder();
CsmMix elementsFromNextOrder = reshuffled.getNextOrder();


Map<Integer, Integer> nodeTextIndexToPreviousCSMIndex = new HashMap<>(); // This contains indexes from elementsFromNextOrder to indexes from elementsFromPreviousOrder
for (int i=0;i<nodeTextIndexOfPreviousElements.size();i++) { Map<Integer, Integer> correspondanceBetweenNextOrderAndPreviousOrder = getCorrespondanceBetweenNextOrderAndPreviousOrder(elementsFromPreviousOrder, elementsFromNextOrder);
int value = nodeTextIndexOfPreviousElements.get(i);
if (value != -1) {
nodeTextIndexToPreviousCSMIndex.put(value, i);
}
}
int lastNodeTextIndex = nodeTextIndexOfPreviousElements.stream().max(Integer::compareTo).orElse(-1);


// Elements to be added at the end // We now find out which Node Text elements corresponds to the elements in the original CSM
List<CsmElement> elementsToBeAddedAtTheEnd = new LinkedList<>(); List<Integer> nodeTextIndexOfPreviousElements = findIndexOfCorrespondingNodeTextElement(elementsFromPreviousOrder.getElements(), nodeText, originalIndex, node);
List<CsmElement> nextOrderElements = elementsFromNextOrder.getElements();


Map<Integer, List<CsmElement>> elementsToAddBeforeGivenOriginalCSMElement = new HashMap<>(); Map<Integer, Integer> nodeTextIndexToPreviousCSMIndex = new HashMap<>();
for (int ni = 0; ni< nextOrderElements.size(); ni++) { for (int i = 0; i < nodeTextIndexOfPreviousElements.size(); i++) {
// If it has a mapping, then it is kept int value = nodeTextIndexOfPreviousElements.get(i);
if (!correspondanceBetweenNextOrderAndPreviousOrder.containsKey(ni)) { if (value != -1) {
// Ok, it is something new. Where to put it? Let's see what is the first following nodeTextIndexToPreviousCSMIndex.put(value, i);
// element that has a mapping
int originalCsmIndex = -1;
for (int nj = ni + 1; nj< nextOrderElements.size() && originalCsmIndex==-1; nj++) {
if (correspondanceBetweenNextOrderAndPreviousOrder.containsKey(nj)) {
originalCsmIndex = correspondanceBetweenNextOrderAndPreviousOrder.get(nj);
if (!elementsToAddBeforeGivenOriginalCSMElement.containsKey(originalCsmIndex)){
elementsToAddBeforeGivenOriginalCSMElement.put(originalCsmIndex, new LinkedList<>());
}
elementsToAddBeforeGivenOriginalCSMElement.get(originalCsmIndex).add(nextOrderElements.get(ni));
} }
} }
// it does not preceed anything, so it goes at the end int lastNodeTextIndex = nodeTextIndexOfPreviousElements.stream().max(Integer::compareTo).orElse(-1);
if (originalCsmIndex == -1) {
elementsToBeAddedAtTheEnd.add(nextOrderElements.get(ni)); // Elements to be added at the end
List<CsmElement> elementsToBeAddedAtTheEnd = new LinkedList<>();
List<CsmElement> nextOrderElements = elementsFromNextOrder.getElements();

Map<Integer, List<CsmElement>> elementsToAddBeforeGivenOriginalCSMElement = new HashMap<>();
for (int ni = 0; ni < nextOrderElements.size(); ni++) {
// If it has a mapping, then it is kept
if (!correspondanceBetweenNextOrderAndPreviousOrder.containsKey(ni)) {
// Ok, it is something new. Where to put it? Let's see what is the first following
// element that has a mapping
int originalCsmIndex = -1;
for (int nj = ni + 1; nj < nextOrderElements.size() && originalCsmIndex == -1; nj++) {
if (correspondanceBetweenNextOrderAndPreviousOrder.containsKey(nj)) {
originalCsmIndex = correspondanceBetweenNextOrderAndPreviousOrder.get(nj);
if (!elementsToAddBeforeGivenOriginalCSMElement.containsKey(originalCsmIndex)) {
elementsToAddBeforeGivenOriginalCSMElement.put(originalCsmIndex, new LinkedList<>());
}
elementsToAddBeforeGivenOriginalCSMElement.get(originalCsmIndex).add(nextOrderElements.get(ni));
}
}
// it does not preceed anything, so it goes at the end
if (originalCsmIndex == -1) {
elementsToBeAddedAtTheEnd.add(nextOrderElements.get(ni));
}
}
} }
}
}


// We go over the original node text elements, in the order they appear in the NodeText. // We go over the original node text elements, in the order they appear in the NodeText.
// Considering an original node text element (ONE) // Considering an original node text element (ONE)
// * we verify if it corresponds to a CSM element. If it does not we just move on, otherwise // * we verify if it corresponds to a CSM element. If it does not we just move on, otherwise
// we find the correspond OCE (Original CSM Element) // we find the correspond OCE (Original CSM Element)
// * we first add new elements that are marked to be added before OCE // * we first add new elements that are marked to be added before OCE
// * if OCE is marked to be present also in the "after" CSM we add a kept element, // * if OCE is marked to be present also in the "after" CSM we add a kept element,
// otherwise we add a removed element // otherwise we add a removed element


diffElements.remove(diffIndex); // Remove the whole Reshuffled element

diffElements.remove(index);
int diffElIterator = diffIndex;
if (lastNodeTextIndex != -1) { int diffElIterator = index;
for (int ntIndex = originalIndex; ntIndex<=lastNodeTextIndex; ntIndex++) { if (lastNodeTextIndex != -1) {

for (int ntIndex = originalIndex; ntIndex <= lastNodeTextIndex; ntIndex++) {
if (nodeTextIndexToPreviousCSMIndex.containsKey(ntIndex)) {
int indexOfOriginalCSMElement = nodeTextIndexToPreviousCSMIndex.get(ntIndex); if (nodeTextIndexToPreviousCSMIndex.containsKey(ntIndex)) {
if (elementsToAddBeforeGivenOriginalCSMElement.containsKey(indexOfOriginalCSMElement)) { int indexOfOriginalCSMElement = nodeTextIndexToPreviousCSMIndex.get(ntIndex);
for (CsmElement elementToAdd : elementsToAddBeforeGivenOriginalCSMElement.get(indexOfOriginalCSMElement)) { if (elementsToAddBeforeGivenOriginalCSMElement.containsKey(indexOfOriginalCSMElement)) {
diffElements.add(diffElIterator++, new Added(elementToAdd)); for (CsmElement elementToAdd : elementsToAddBeforeGivenOriginalCSMElement.get(indexOfOriginalCSMElement)) {
diffElements.add(diffElIterator++, new Added(elementToAdd));
}
}

CsmElement originalCSMElement = elementsFromPreviousOrder.getElements().get(indexOfOriginalCSMElement);
boolean toBeKept = correspondanceBetweenNextOrderAndPreviousOrder.containsValue(indexOfOriginalCSMElement);
if (toBeKept) {
diffElements.add(diffElIterator++, new Kept(originalCSMElement));
} else {
diffElements.add(diffElIterator++, new Removed(originalCSMElement));
}
} }
// else we have a simple node text element, without associated csm element, just keep ignore it
} }
}


CsmElement originalCSMElement = elementsFromPreviousOrder.getElements().get(indexOfOriginalCSMElement); // Finally we look for the remaining new elements that were not yet added and
boolean toBeKept = correspondanceBetweenNextOrderAndPreviousOrder.containsValue(indexOfOriginalCSMElement); // add all of them
if (toBeKept) { for (CsmElement elementToAdd : elementsToBeAddedAtTheEnd) {
diffElements.add(diffElIterator++, new Kept(originalCSMElement)); diffElements.add(diffElIterator++, new Added(elementToAdd));
} else {
diffElements.add(diffElIterator++, new Removed(originalCSMElement));
}
} }
// else we have a simple node text element, without associated csm element, just keep ignore it
} }
} }

// Finally we look for the remaining new elements that were not yet added and
// add all of them
for (CsmElement elementToAdd : elementsToBeAddedAtTheEnd) {
diffElements.add(diffElIterator++, new Added(elementToAdd));
}
} }


private void applyRemovedDiffElement(Removed removed, TextElement originalElement, boolean originalElementIsChild, boolean originalElementIsToken) { private void applyRemovedDiffElement(Removed removed, TextElement originalElement, boolean originalElementIsChild, boolean originalElementIsToken) {
Expand Down

0 comments on commit 996b784

Please sign in to comment.