1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
/*
* Copyright (C) 2010, Google Inc. and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Distribution License v. 1.0 which is available at
* https://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
package org.eclipse.jgit.diff;
/**
* Wraps a {@link org.eclipse.jgit.diff.Sequence} to have a narrower range of
* elements.
* <p>
* This sequence acts as a proxy for the real sequence, translating element
* indexes on the fly by adding {@code begin} to them. Sequences of this type
* must be used with a {@link org.eclipse.jgit.diff.SubsequenceComparator}.
*
* @param <S>
* the base sequence type.
*/
public final class Subsequence<S extends Sequence> extends Sequence {
/**
* Construct a subsequence around the A region/base sequence.
*
* @param a
* the A sequence.
* @param region
* the region of {@code a} to create a subsequence around.
* @return subsequence of {@code base} as described by A in {@code region}.
*/
public static <S extends Sequence> Subsequence<S> a(S a, Edit region) {
return new Subsequence<>(a, region.beginA, region.endA);
}
/**
* Construct a subsequence around the B region/base sequence.
*
* @param b
* the B sequence.
* @param region
* the region of {@code b} to create a subsequence around.
* @return subsequence of {@code base} as described by B in {@code region}.
*/
public static <S extends Sequence> Subsequence<S> b(S b, Edit region) {
return new Subsequence<>(b, region.beginB, region.endB);
}
/**
* Adjust the Edit to reflect positions in the base sequence.
*
* @param e
* edit to adjust in-place. Prior to invocation the indexes are
* in terms of the two subsequences; after invocation the indexes
* are in terms of the base sequences.
* @param a
* the A sequence.
* @param b
* the B sequence.
*/
public static <S extends Sequence> void toBase(Edit e, Subsequence<S> a,
Subsequence<S> b) {
e.beginA += a.begin;
e.endA += a.begin;
e.beginB += b.begin;
e.endB += b.begin;
}
/**
* Adjust the Edits to reflect positions in the base sequence.
*
* @param edits
* edits to adjust in-place. Prior to invocation the indexes are
* in terms of the two subsequences; after invocation the indexes
* are in terms of the base sequences.
* @param a
* the A sequence.
* @param b
* the B sequence.
* @return always {@code edits} (as the list was updated in-place).
*/
public static <S extends Sequence> EditList toBase(EditList edits,
Subsequence<S> a, Subsequence<S> b) {
for (Edit e : edits)
toBase(e, a, b);
return edits;
}
final S base;
final int begin;
private final int size;
/**
* Construct a subset of another sequence.
*
* The size of the subsequence will be {@code end - begin}.
*
* @param base
* the real sequence.
* @param begin
* First element index of {@code base} that will be part of this
* new subsequence. The element at {@code begin} will be this
* sequence's element 0.
* @param end
* One past the last element index of {@code base} that will be
* part of this new subsequence.
*/
public Subsequence(S base, int begin, int end) {
this.base = base;
this.begin = begin;
this.size = end - begin;
}
/** {@inheritDoc} */
@Override
public int size() {
return size;
}
}
|
