Java tutorial
/******************************************************************************* * Copyright (c) 2013, 2016 SAP AG and others * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * Tobias Pfeifer (SAP AG) - initial implementation * Thomas Wolf <thomas.wolf@paranor.ch> - Bug 485511 *******************************************************************************/ package org.eclipse.egit.core.internal.rebase; import java.io.File; import java.io.IOException; import java.lang.ref.WeakReference; import java.util.AbstractList; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.concurrent.CopyOnWriteArrayList; import org.eclipse.core.runtime.Assert; import org.eclipse.egit.core.Activator; import org.eclipse.egit.core.internal.CoreText; import org.eclipse.egit.core.internal.indexdiff.IndexDiffCacheEntry; import org.eclipse.egit.core.internal.indexdiff.IndexDiffChangedListener; import org.eclipse.egit.core.internal.indexdiff.IndexDiffData; import org.eclipse.jgit.errors.IllegalTodoFileModification; import org.eclipse.jgit.events.ListenerHandle; import org.eclipse.jgit.events.RefsChangedEvent; import org.eclipse.jgit.events.RefsChangedListener; import org.eclipse.jgit.lib.AbbreviatedObjectId; import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.PersonIdent; import org.eclipse.jgit.lib.RebaseTodoFile; import org.eclipse.jgit.lib.RebaseTodoLine; import org.eclipse.jgit.lib.RebaseTodoLine.Action; import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.RepositoryState; import org.eclipse.jgit.revwalk.RevCommit; import org.eclipse.jgit.revwalk.RevWalk; import org.eclipse.jgit.util.GitDateFormatter; /** * Representation of the {@link RebaseTodoFile} for Rebase-Todo and * Rebase-Done-File of a {@link Repository}. * * Reparses the rebase plan when the index changes or when a {@code Ref} is * moving in order to keep the in-memory plan in sync with the one on disk. */ public class RebaseInteractivePlan implements IndexDiffChangedListener, RefsChangedListener { /** * Classes that implement this interface provide methods that deal with * changes made to a {@link RebaseInteractivePlan} * <p> * An Instance that implements this interface it can be added to a * {@link RebaseInteractivePlan} by using the * {@link RebaseInteractivePlan#addRebaseInteractivePlanChangeListener(RebaseInteractivePlanChangeListener) * addRebaseInteractivePlanChangeListener} method and removed using the * {@link RebaseInteractivePlan#removeRebaseInteractivePlanChangeListener(RebaseInteractivePlanChangeListener) * removeRebaseInteractivePlanChangeListener} method. When a change is made * to an {@link PlanElement} in this {@link RebaseInteractivePlan} (including * structural changes) the appropriate method will be invoked. */ public static interface RebaseInteractivePlanChangeListener { /** * Will be invoked if the order of either the Rebase-Todo-File or * Rebase-Done-File changes (structural change). * * @param rebaseInteractivePlan * @param element * @param oldIndex * @param newIndex */ public void planElementsOrderChanged(RebaseInteractivePlan rebaseInteractivePlan, PlanElement element, int oldIndex, int newIndex); /** * Will be invoked if the {@link ElementType} of an {@link PlanElement} * changes. * * @param rebaseInteractivePlan * @param element * @param oldType * @param newType */ public void planElementTypeChanged(RebaseInteractivePlan rebaseInteractivePlan, PlanElement element, ElementAction oldType, ElementAction newType); /** * Will be invoked after the list of {@link PlanElement Elements} has been * parsed from the {@link Repository} * * @param plan */ public void planWasUpdatedFromRepository(RebaseInteractivePlan plan); } private CopyOnWriteArrayList<RebaseInteractivePlanChangeListener> planChangeListeners = new CopyOnWriteArrayList<RebaseInteractivePlanChangeListener>(); private List<PlanElement> todoList; private List<PlanElement> doneList; private JoinedList<List<PlanElement>, PlanElement> planList; private final WeakReference<Repository> repositoryRef; private final File myGitDir; private ListenerHandle refsChangedListener; private static final Map<File, RebaseInteractivePlan> planRegistry = new HashMap<File, RebaseInteractivePlan>(); private static final String REBASE_TODO = "rebase-merge/git-rebase-todo"; //$NON-NLS-1$ private static final String REBASE_DONE = "rebase-merge/done"; //$NON-NLS-1$ /** * Provides a singleton instance of {@link RebaseInteractivePlan} for a * given {@link Repository} * <p> * If a {@link RebaseInteractivePlan} for the given {@link Repository} has * already been created and has not been disposed yet, this instance is * returned, otherwise a newly created instance is returned. * * @param repo * @return the {@link RebaseInteractivePlan} for the given * {@link Repository} */ public static RebaseInteractivePlan getPlan(Repository repo) { RebaseInteractivePlan plan = planRegistry.get(repo.getDirectory()); if (plan == null) { plan = new RebaseInteractivePlan(repo); planRegistry.put(repo.getDirectory(), plan); } return plan; } private RebaseInteractivePlan(Repository repo) { this.repositoryRef = new WeakReference<>(repo); this.myGitDir = repo.getDirectory().getAbsoluteFile(); reparsePlan(repo); registerIndexDiffChangeListener(repo); registerRefChangedListener(); } private void registerIndexDiffChangeListener(Repository repository) { IndexDiffCacheEntry entry = org.eclipse.egit.core.Activator.getDefault().getIndexDiffCache() .getIndexDiffCacheEntry(repository); if (entry != null) { entry.addIndexDiffChangedListener(this); } } private void unregisterIndexDiffChangeListener() { Repository repository = getRepository(); if (repository != null) { IndexDiffCacheEntry entry = org.eclipse.egit.core.Activator.getDefault().getIndexDiffCache() .getIndexDiffCacheEntry(repository); if (entry != null) { entry.removeIndexDiffChangedListener(this); } } } private void registerRefChangedListener() { refsChangedListener = Repository.getGlobalListenerList().addRefsChangedListener(this); } /** * Reparse plan when {@code IndexDiff} changed */ @Override public void indexDiffChanged(Repository repo, IndexDiffData indexDiffData) { if (getRepository() == repo) reparsePlan(repo); } /** * Reparse plan when a {@code Ref} changed * * @param event */ @Override public void onRefsChanged(RefsChangedEvent event) { Repository repo = event.getRepository(); if (getRepository() == repo) reparsePlan(repo); } /** * Dispose the plan. * <p> * The next invocation of {@link RebaseInteractivePlan#getPlan(Repository)} * will create a new {@link RebaseInteractivePlan} instance. */ public void dispose() { reparsePlan(getRepository()); notifyPlanWasUpdatedFromRepository(); planRegistry.remove(myGitDir); planList.clear(); planChangeListeners.clear(); unregisterIndexDiffChangeListener(); refsChangedListener.remove(); } /** * @return a list representation of the {@link PlanElement Elements} for this * plan. */ public List<PlanElement> getList() { return planList; } /** * @return the repository */ public Repository getRepository() { return repositoryRef.get(); } /** * Adds a {@link RebaseInteractivePlanChangeListener} to this * {@link RebaseInteractivePlan} if it has not been registered yet * * @param listener * the {@link RebaseInteractivePlanChangeListener} to be added * @return true if the listener has been added, otherwise false */ public boolean addRebaseInteractivePlanChangeListener(RebaseInteractivePlanChangeListener listener) { return planChangeListeners.addIfAbsent(listener); } /** * Removes a {@link RebaseInteractivePlanChangeListener} from this * {@link RebaseInteractivePlan} if it has been registered before * * @param listener * the {@link RebaseInteractivePlanChangeListener} to be removed * @return true if the listener has been removed, otherwise false */ public boolean removeRebaseInteractivePlanChangeListener(RebaseInteractivePlanChangeListener listener) { return planChangeListeners.remove(listener); } private void notifyPlanElementsOrderChange(PlanElement element, int oldIndex, int newIndex) { persist(getRepository()); for (RebaseInteractivePlanChangeListener listener : planChangeListeners) listener.planElementsOrderChanged(this, element, oldIndex, newIndex); } private void notifyPlanElementActionChange(PlanElement element, ElementAction oldType, ElementAction newType) { persist(getRepository()); for (RebaseInteractivePlanChangeListener listener : planChangeListeners) listener.planElementTypeChanged(this, element, oldType, newType); } private void notifyPlanWasUpdatedFromRepository() { for (RebaseInteractivePlanChangeListener listener : planChangeListeners) listener.planWasUpdatedFromRepository(this); } private void reparsePlan(Repository repository) { if (repository != null) { try (RevWalk walk = new RevWalk(repository.newObjectReader())) { doneList = parseDone(repository, walk); todoList = parseTodo(repository, walk); } planList = JoinedList.wrap(doneList, todoList); notifyPlanWasUpdatedFromRepository(); } } private List<PlanElement> parseTodo(Repository repository, RevWalk walk) { List<RebaseTodoLine> rebaseTodoLines; try { rebaseTodoLines = repository.readRebaseTodo(REBASE_TODO, true); } catch (IOException e) { rebaseTodoLines = new LinkedList<RebaseTodoLine>(); } List<PlanElement> todoElements = createElementList(rebaseTodoLines, walk); return todoElements; } private List<PlanElement> parseDone(Repository repository, RevWalk walk) { List<RebaseTodoLine> rebaseDoneLines; try { rebaseDoneLines = repository.readRebaseTodo(REBASE_DONE, false); } catch (IOException e) { rebaseDoneLines = new LinkedList<RebaseTodoLine>(); } List<PlanElement> doneElements = createElementList(rebaseDoneLines, walk); return doneElements; } private List<PlanElement> createElementList(List<RebaseTodoLine> rebaseTodoLines, RevWalk walk) { List<PlanElement> planElements = new ArrayList<PlanElement>(rebaseTodoLines.size()); for (RebaseTodoLine todoLine : rebaseTodoLines) { PlanElement element = createElement(todoLine, walk); planElements.add(element); } return planElements; } private PlanElement createElement(RebaseTodoLine todoLine, RevWalk walk) { PersonIdent author = null; PersonIdent committer = null; RevCommit commit = loadCommit(todoLine.getCommit(), walk); if (commit != null) { author = commit.getAuthorIdent(); committer = commit.getCommitterIdent(); } PlanElement element = new PlanElement(todoLine, author, committer); return element; } private RevCommit loadCommit(AbbreviatedObjectId abbreviatedObjectId, RevWalk walk) { if (abbreviatedObjectId != null) { try { Collection<ObjectId> resolved = walk.getObjectReader().resolve(abbreviatedObjectId); if (resolved.size() == 1) { RevCommit commit = walk.parseCommit(resolved.iterator().next()); return commit; } } catch (IOException e) { // ignore, we assume no author/committer then } } return null; } /** * @return true if the rebase has already been started processing the plan, * otherwise false */ public boolean hasRebaseBeenStartedYet() { return isRebasingInteractive() && doneList.size() > 0; } /** * @return true if repository state is * {@link RepositoryState#REBASING_INTERACTIVE} */ public boolean isRebasingInteractive() { Repository repository = getRepository(); return repository != null && repository.getRepositoryState() == RepositoryState.REBASING_INTERACTIVE; } /** * Moves an {@link PlanElement} of Type {@link ElementType#TODO} down if * possible * * @param element * the {@link PlanElement} to move down */ public void moveTodoEntryDown(PlanElement element) { new MoveHelper(todoList, this).moveTodoEntryDown(element); } /** * Moves an {@link PlanElement} of Type {@link ElementType#TODO} up if possible * * @param element * the {@link PlanElement} to move up */ public void moveTodoEntryUp(PlanElement element) { new MoveHelper(todoList, this).moveTodoEntryUp(element); } /** * Moves a given {@link PlanElement sourceElement} of Type * {@link ElementType#TODO} to the current position of a {@link PlanElement * targetElement} in it's list representation (considering that this list * representation may be reversed). If <code>before</code> is true the * {@link PlanElement sourceElement} will be placed just before the * {@link PlanElement targetElement} * * @param sourceElement * @param targetElement * @param before */ public void moveTodoEntry(PlanElement sourceElement, PlanElement targetElement, boolean before) { new MoveHelper(todoList, this).moveTodoEntry(sourceElement, targetElement, before); } /** * Writes the plan to the FS. * <p> * Only {@link PlanElement Elements} of {@link ElementType#TODO} are * persisted. * * @param repository * the plan belongs to * * @return true if the todo file has been written successfully, otherwise * false */ private boolean persist(Repository repository) { if (repository == null || repository.getRepositoryState() != RepositoryState.REBASING_INTERACTIVE) { return false; } List<RebaseTodoLine> todoLines = new LinkedList<RebaseTodoLine>(); for (PlanElement element : planList.getSecondList()) todoLines.add(element.getRebaseTodoLine()); try { repository.writeRebaseTodoFile(REBASE_TODO, todoLines, false); } catch (IOException e) { Activator.logError(CoreText.RebaseInteractivePlan_WriteRebaseTodoFailed, e); throw new RuntimeException(e); } return true; } /** * Parses the plan from the FS by reading the todo-File and the done-File if * in state RebaseInteractive * * @throws IOException */ public void parse() throws IOException { if (!isRebasingInteractive()) return; reparsePlan(getRepository()); } /** * This class wraps a {@link RebaseTodoLine} and holds additional * information about the underlying commit, if available. */ public class PlanElement { private final RebaseTodoLine line; /** author info, may be null */ private final PersonIdent author; /** committer info, may be null */ private final PersonIdent committer; private PlanElement(RebaseTodoLine line, PersonIdent author, PersonIdent committer) { if (line == null) throw new IllegalArgumentException(); this.line = line; this.author = author; this.committer = committer; } /** * @return the {@link ElementType} for this {@link PlanElement} */ public ElementType getElementType() { if (todoList.indexOf(this) != -1) return ElementType.TODO; int indexInDone = doneList.indexOf(this); if (indexInDone != -1) { if (indexInDone == doneList.size() - 1 && isRebasingInteractive()) return ElementType.DONE_CURRENT; return ElementType.DONE; } return null; } private RebaseTodoLine getRebaseTodoLine() { return line; } /** * @return the CommitId of the wrapped {@link RebaseTodoLine} */ public AbbreviatedObjectId getCommit() { return line.getCommit(); } /** * @return the shortMessage of the wrapped {@link RebaseTodoLine} */ public String getShortMessage() { return line.getShortMessage(); } /** * @return the author name of the underlying commit */ public String getAuthor() { if (author == null) return ""; //$NON-NLS-1$ else return author.getName(); } /** * @param dateFormatter * @return the authored date of the underlying commit */ public String getAuthoredDate(GitDateFormatter dateFormatter) { if (author == null) return ""; //$NON-NLS-1$ else return dateFormatter.formatDate(author); } /** * @return the committer name of the underlying commit */ public String getCommitter() { if (committer == null) return ""; //$NON-NLS-1$ else return committer.getName(); } /** * @param dateFormatter * @return the commit date of the underlying commit */ public String getCommittedDate(GitDateFormatter dateFormatter) { if (committer == null) return ""; //$NON-NLS-1$ else return dateFormatter.formatDate(committer); } /** * This method maps the given {@link ElementAction} to the wrapped * {@link RebaseTodoLine RebaseTodoLines} {@link Action}. If the * {@link ElementAction} changes the registered * {@link RebaseInteractivePlanChangeListener * RebaseInteractivePlanChangeListeners} are notified. * * @param newAction * the {@link ElementAction} to be set */ public void setPlanElementAction(ElementAction newAction) { if (isComment()) { if (newAction == null) return; throw new IllegalArgumentException(); } ElementAction oldAction = this.getPlanElementAction(); if (oldAction == newAction) return; try { switch (newAction) { case SKIP: line.setAction(Action.COMMENT); break; case EDIT: line.setAction(Action.EDIT); break; case FIXUP: line.setAction(Action.FIXUP); break; case PICK: line.setAction(Action.PICK); break; case REWORD: line.setAction(Action.REWORD); break; case SQUASH: line.setAction(Action.SQUASH); break; default: throw new IllegalArgumentException(); } } catch (IllegalTodoFileModification e) { // shouldn't happen throw new IllegalArgumentException(e); } notifyPlanElementActionChange(this, oldAction, newAction); } /** * @return the {@link ElementAction} for this {@link PlanElement} */ public ElementAction getPlanElementAction() { if (isSkip()) return ElementAction.SKIP; if (isComment()) return null; switch (line.getAction()) { case EDIT: return ElementAction.EDIT; case FIXUP: return ElementAction.FIXUP; case PICK: return ElementAction.PICK; case SQUASH: return ElementAction.SQUASH; case REWORD: return ElementAction.REWORD; default: throw new IllegalStateException(); } } /** * @return true, if the given line is a pure comment, i.e. a comment * that doesn't hold a valid action line, otherwise false */ public boolean isComment() { return (Action.COMMENT.equals(line.getAction()) && null == line.getCommit()); } /** * @return true if this element is marked for deletion, i.e. a valid * action line has been commented out, otherwise false */ public boolean isSkip() { return (Action.COMMENT.equals(line.getAction()) && null != line.getCommit()); } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; PlanElement other = (PlanElement) obj; if (other.line.getCommit() == null) { if (this.line.getCommit() == null) return true; return false; } if (!other.line.getCommit().equals(this.line.getCommit())) return false; if (!other.getPlanElementAction().equals(this.getPlanElementAction())) return false; return true; } @Override public int hashCode() { return super.hashCode(); } @Override public String toString() { return line.toString(); } } /** * Wraps {@link Action} and additionally provides * {@link ElementAction#SKIP} */ public enum ElementAction { /** * The {@link PlanElement} will not be cherry-picked, i.e. changes are * lost on the new branch. Internally this is mapped to * {@link Action#COMMENT}, to comment out a {@link RebaseTodoLine} */ SKIP, /** * Equivalent to {@link Action#EDIT}; */ EDIT, /** * Equivalent to {@link Action#PICK}; */ PICK, /** * Equivalent to {@link Action#SQUASH}; */ SQUASH, /** * Equivalent to {@link Action#FIXUP}; */ FIXUP, /** * Equivalent to {@link Action#REWORD}; */ REWORD; } /** * The type of an {@link PlanElement} */ public static enum ElementType { /** * The {@link PlanElement} is present in the done-File, i.e. the * {@link RebaseTodoLine} has already been processed. */ DONE, /** * The {@link PlanElement} is present in the todo-File, i.e. the * {@link RebaseTodoLine} has not been processed yet. */ TODO, /** * Special case of {@link ElementType#DONE}. * <p> * The {@link PlanElement} is the last entry in the done-File, i.e. the * {@link RebaseTodoLine} has already been processed and furthermore the * rebase has not been finished yet */ DONE_CURRENT; } /** * Helper class for moving plan elements */ public static class MoveHelper { private List<PlanElement> todoList; private RebaseInteractivePlan plan; /** * @param todoList * @param plan */ public MoveHelper(List<PlanElement> todoList, RebaseInteractivePlan plan) { this.todoList = todoList; this.plan = plan; } /** * Move the element at the given index in the given list up if possible, * otherwise this method has no effect on the list. Moving an element up * is not possible if the list does not contain an element with the * given index or the element at the given index has no next element. * * @param index * @param list * @return true if an element has been moved up, otherwise false */ private static boolean moveUp(final int index, final List<?> list) { if (index <= 0 || index > list.size()) return false; Collections.swap(list, index, index - 1); return true; } /** * Move the element at the given index in the given list down if * possible, otherwise this method has no effect on the list. Moving an * element down is not possible if the list does not contain an element * with the given index or the element at the given index has no * previous element. * * @param index * @param list * @return true if an element has been moved down, otherwise false */ private static boolean moveDown(final int index, final List<?> list) { if (index < 0 || index >= list.size() - 1) return false; Collections.swap(list, index, index + 1); return true; } /** * Moves an {@link PlanElement} of Type {@link ElementType#TODO} down if * possible * * @param element * the {@link PlanElement} to move down */ public void moveTodoEntryDown(PlanElement element) { List<PlanElement> list = todoList; int initialIndex = list.indexOf(element); int oldIndex; do { oldIndex = list.indexOf(element); moveDown(oldIndex, list); } while (list.get(oldIndex).isComment()); int newIndex = list.indexOf(element); if (initialIndex != newIndex) plan.notifyPlanElementsOrderChange(element, initialIndex, newIndex); } /** * Moves an {@link PlanElement} of Type {@link ElementType#TODO} up if * possible * * @param element * the {@link PlanElement} to move up */ public void moveTodoEntryUp(PlanElement element) { List<PlanElement> list = todoList; int initialIndex = list.indexOf(element); int oldIndex; do { oldIndex = list.indexOf(element); moveUp(oldIndex, list); } while (list.get(oldIndex).isComment()); int newIndex = list.indexOf(element); if (initialIndex != newIndex) plan.notifyPlanElementsOrderChange(element, initialIndex, newIndex); } private static void move(int sourceIndex, int targetIndex, final List<PlanElement> list) { if (sourceIndex == targetIndex) return; if (sourceIndex < targetIndex) { Collections.rotate(list.subList(sourceIndex, targetIndex + 1), -1); } else { Collections.rotate(list.subList(targetIndex, sourceIndex + 1), 1); } } /** * Moves a given {@link PlanElement sourceElement} of Type * {@link ElementType#TODO} to the current position of a * {@link PlanElement targetElement} in it's list representation * (considering that this list representation may be reversed). If * <code>before</code> is true the {@link PlanElement sourceElement} * will be placed just before the {@link PlanElement targetElement} * * @param sourceElement * @param targetElement * @param before */ public void moveTodoEntry(PlanElement sourceElement, PlanElement targetElement, boolean before) { if (sourceElement == targetElement) return; Assert.isNotNull(sourceElement); Assert.isNotNull(targetElement); if (ElementType.TODO != sourceElement.getElementType()) throw new IllegalArgumentException(); List<PlanElement> list = todoList; int initialSourceIndex = list.indexOf(sourceElement); int targetIndex = list.indexOf(targetElement); if (targetIndex == -1 || initialSourceIndex == -1) return; if (targetIndex == initialSourceIndex) return; if (targetIndex > initialSourceIndex && before) targetIndex--; if (targetIndex < initialSourceIndex && !before) targetIndex++; move(initialSourceIndex, targetIndex, list); int newIndex = list.indexOf(sourceElement); if (initialSourceIndex != newIndex) plan.notifyPlanElementsOrderChange(sourceElement, initialSourceIndex, newIndex); } } /** * List that provides a view to two joined lists * * @param <L> * The concrete type of the two lists * @param <T> * The type of the elements in the lists */ public static class JoinedList<L extends List<T>, T> extends AbstractList<T> { private final L firstList, secondList; /** * @return the first list */ public L getFirstList() { return firstList; } /** * @return the second list */ public L getSecondList() { return secondList; } /** * @param first * @param second */ private JoinedList(L first, L second) { super(); Assert.isNotNull(first); Assert.isNotNull(second); this.firstList = first; this.secondList = second; } /** * Creates a newly List that provides a view to two joined lists. * * @param first * @param second * @return a new view on a concatenation of both lists */ public static <L extends List<T>, T> JoinedList<L, T> wrap(L first, L second) { return new JoinedList<L, T>(first, second); } private static class RelativeIndex<T> { private final int relativeIndex; private final List<T> list; public final int getRelativeIndex() { return relativeIndex; } public final List<T> getList() { return list; } RelativeIndex(int relativeIndex, List<T> list) { super(); this.relativeIndex = relativeIndex; this.list = list; } } private RelativeIndex<T> mapAbsolutIndex(int index) { if (index < firstList.size()) return new RelativeIndex<T>(index, firstList); return new RelativeIndex<T>(index - firstList.size(), secondList); } /** * if the given index is smaller than the first lists size the element * is added to the first list. if the given index points to the seam of * the joined lists, the given element will be added to the second list. * More precisely a element is added to the second list if the given * index is greater or equals the first lists size, otherwise it's added * to the first list. */ @Override public void add(int index, T element) { RelativeIndex<T> rel = mapAbsolutIndex(index); rel.getList().add(rel.getRelativeIndex(), element); modCount++; } @Override public T get(int index) { RelativeIndex<T> rel = mapAbsolutIndex(index); return rel.getList().get(rel.getRelativeIndex()); } @Override public T remove(int index) { RelativeIndex<T> rel = mapAbsolutIndex(index); modCount++; return rel.getList().remove(rel.getRelativeIndex()); } @Override public T set(int index, T element) { RelativeIndex<T> rel = mapAbsolutIndex(index); return rel.getList().set(rel.getRelativeIndex(), element); } @Override public int size() { return firstList.size() + secondList.size(); } } }