1 /*
2 * Copyright (C) 2009, Christian Halstrick <christian.halstrick@sap.com>
3 * and other copyright owners as documented in the project's IP log.
4 *
5 * This program and the accompanying materials are made available
6 * under the terms of the Eclipse Distribution License v1.0 which
7 * accompanies this distribution, is reproduced below, and is
8 * available at http://www.eclipse.org/org/documents/edl-v10.php
9 *
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or
13 * without modification, are permitted provided that the following
14 * conditions are met:
15 *
16 * - Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 *
19 * - Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials provided
22 * with the distribution.
23 *
24 * - Neither the name of the Eclipse Foundation, Inc. nor the
25 * names of its contributors may be used to endorse or promote
26 * products derived from this software without specific prior
27 * written permission.
28 *
29 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
30 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
31 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
32 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
33 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
34 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
35 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
36 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
37 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
38 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
40 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
41 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42 */
43
44 package org.eclipse.jgit.merge;
45
46 import java.util.Iterator;
47 import java.util.List;
48
49 import org.eclipse.jgit.diff.Sequence;
50 import org.eclipse.jgit.merge.MergeChunk.ConflictState;
51 import org.eclipse.jgit.util.IntList;
52
53 /**
54 * The result of merging a number of {@link Sequence} objects. These sequences
55 * have one common predecessor sequence. The result of a merge is a list of
56 * MergeChunks. Each MergeChunk contains either a range (a subsequence) from
57 * one of the merged sequences, a range from the common predecessor or a
58 * conflicting range from one of the merged sequences. A conflict will be
59 * reported as multiple chunks, one for each conflicting range. The first chunk
60 * for a conflict is marked specially to distinguish the border between two
61 * consecutive conflicts.
62 * <p>
63 * This class does not know anything about how to present the merge result to
64 * the end-user. MergeFormatters have to be used to construct something human
65 * readable.
66 *
67 * @param <S>
68 * type of sequence.
69 */
70 public class MergeResult<S extends Sequence> implements Iterable<MergeChunk> {
71 private final List<S> sequences;
72
73 private final IntList chunks = new IntList();
74
75 private boolean containsConflicts = false;
76
77 /**
78 * Creates a new empty MergeResult
79 *
80 * @param sequences
81 * contains the common predecessor sequence at position 0
82 * followed by the merged sequences. This list should not be
83 * modified anymore during the lifetime of this {@link MergeResult}.
84 */
85 public MergeResult(List<S> sequences) {
86 this.sequences = sequences;
87 }
88
89 /**
90 * Adds a new range from one of the merged sequences or from the common
91 * predecessor. This method can add conflicting and non-conflicting ranges
92 * controlled by the conflictState parameter
93 *
94 * @param srcIdx
95 * determines from which sequence this range comes. An index of
96 * x specifies the x+1 element in the list of sequences
97 * specified to the constructor
98 * @param begin
99 * the first element from the specified sequence which should be
100 * included in the merge result. Indexes start with 0.
101 * @param end
102 * specifies the end of the range to be added. The element this
103 * index points to is the first element which not added to the
104 * merge result. All elements between begin (including begin) and
105 * this element are added.
106 * @param conflictState
107 * when set to NO_CONLICT a non-conflicting range is added.
108 * This will end implicitly all open conflicts added before.
109 */
110 public void add(int srcIdx, int begin, int end, ConflictState conflictState) {
111 chunks.add(conflictState.ordinal());
112 chunks.add(srcIdx);
113 chunks.add(begin);
114 chunks.add(end);
115 if (conflictState != ConflictState.NO_CONFLICT)
116 containsConflicts = true;
117 }
118
119 /**
120 * Returns the common predecessor sequence and the merged sequence in one
121 * list. The common predecessor is is the first element in the list
122 *
123 * @return the common predecessor at position 0 followed by the merged
124 * sequences.
125 */
126 public List<S> getSequences() {
127 return sequences;
128 }
129
130 private static final ConflictState[] states = ConflictState.values();
131
132 /**
133 * @return an iterator over the MergeChunks. The iterator does not support
134 * the remove operation
135 */
136 public Iterator<MergeChunk> iterator() {
137 return new Iterator<MergeChunk>() {
138 int idx;
139
140 public boolean hasNext() {
141 return (idx < chunks.size());
142 }
143
144 public MergeChunk next() {
145 ConflictState state = states[chunks.get(idx++)];
146 int srcIdx = chunks.get(idx++);
147 int begin = chunks.get(idx++);
148 int end = chunks.get(idx++);
149 return new MergeChunk(srcIdx, begin, end, state);
150 }
151
152 public void remove() {
153 throw new UnsupportedOperationException();
154 }
155 };
156 }
157
158 /**
159 * @return true if this merge result contains conflicts
160 */
161 public boolean containsConflicts() {
162 return containsConflicts;
163 }
164
165 /**
166 * Sets explicitly whether this merge should be seen as containing a
167 * conflict or not. Needed because during RecursiveMerger we want to do
168 * content-merges and take the resulting content (even with conflict
169 * markers!) as new conflict-free content
170 *
171 * @param containsConflicts
172 * @since 3.5
173 */
174 protected void setContainsConflicts(boolean containsConflicts) {
175 this.containsConflicts = containsConflicts;
176 }
177 }