public static <T extends EObject> void refreshList(
@Nullable List<? super T> oldElements, @Nullable List<? extends T> newElements) {
if (oldElements == null) {
return; // Never happens but avoids need for null validation in caller
}
if (newElements == null) {
if (oldElements.size() > 0) {
oldElements.clear();
}
return;
}
for (int k = newElements.size(); k-- > 0; ) {
T newElement = newElements.get(k);
if ((newElement != null) && newElement.eIsProxy()) {
oldElements.remove(newElement); // Lose oldContent before adding possible 'duplicates'
}
}
for (int k = oldElements.size(); k-- > 0; ) {
Object oldElement = oldElements.get(k);
if (!newElements.contains(oldElement)) {
oldElements.remove(k); // Lose oldContent before adding possible 'duplicates'
}
}
int newMax = newElements.size();
for (int i = 0; i < newMax; i++) { // Invariant: lists are equal up to index i
T newElement = newElements.get(i);
int oldMax = oldElements.size();
boolean reused = false;
;
for (int j = i; j < oldMax; j++) {
Object oldElement = oldElements.get(j);
if (oldElement == newElement) {
if (j != i) {
oldElements.remove(j);
oldElements.add(i, newElement);
}
reused = true;
break;
}
}
if (!reused) {
if (i < oldMax) {
oldElements.add(i, newElement);
} else {
oldElements.add(newElement);
}
}
assert newElements.get(i) == oldElements.get(i);
}
for (int k = oldElements.size(); k > newMax; ) {
oldElements.remove(--k);
}
assert newElements.size() == oldElements.size();
}
public static <T extends EObject> void refreshSet(
List<? super T> oldElements, Collection<? extends T> newElements) {
for (int i = oldElements.size(); i-- > 0; ) { // Remove any oldElements not in newElements
Object oldElement = oldElements.get(i);
if (!newElements.contains(oldElement)) {
oldElements.remove(i);
}
}
for (T newElement : newElements) { // Add any newElements not in oldElements
if (!newElement.eIsProxy() && !oldElements.contains(newElement)) {
oldElements.add(newElement);
}
}
}
public static <T extends EObject> void refreshList(
List<? super T> elements, List<? extends T> newElements) {
for (int k = newElements.size(); k-- > 0; ) {
T newElement = newElements.get(k);
if (newElement.eIsProxy()) {
elements.remove(newElement); // Lose oldContent before adding possible 'duplicates'
}
}
for (int k = elements.size(); k-- > 0; ) {
Object oldElement = elements.get(k);
if (!newElements.contains(oldElement)) {
elements.remove(k); // Lose oldContent before adding possible 'duplicates'
}
}
int newMax = newElements.size();
for (int i = 0; i < newMax; i++) { // Invariant: lists are equal up to index i
T newElement = newElements.get(i);
int oldMax = elements.size();
boolean reused = false;
;
for (int j = i; j < oldMax; j++) {
Object oldElement = elements.get(j);
if (oldElement == newElement) {
if (j != i) {
elements.remove(j);
elements.add(i, newElement);
}
reused = true;
break;
}
}
if (!reused) {
if (i < oldMax) {
elements.add(i, newElement);
} else {
elements.add(newElement);
}
}
assert newElements.get(i) == elements.get(i);
}
for (int k = elements.size(); k > newMax; ) {
elements.remove(--k);
}
assert newElements.size() == elements.size();
}
public static <T extends EObject> void refreshSet(
@Nullable List<? super T> oldElements, @Nullable Collection<? extends T> newElements) {
if (oldElements == null) {
return; // Never happens but avoids need for null validation in caller
}
if (newElements == null) {
oldElements.clear();
return;
}
for (int i = oldElements.size(); i-- > 0; ) { // Remove any oldElements not in newElements
Object oldElement = oldElements.get(i);
if (!newElements.contains(oldElement)) {
oldElements.remove(i);
}
}
for (T newElement : newElements) { // Add any newElements not in oldElements
if (!newElement.eIsProxy() && !oldElements.contains(newElement)) {
oldElements.add(newElement);
}
}
}
