org.eclipse.jgit.diff

## Class Subsequence<S extends Sequence>

- java.lang.Object
- - org.eclipse.jgit.diff.Sequence
  - - org.eclipse.jgit.diff.Subsequence<S>

Type Parameters:
  `S` - the base sequence type.

    public final class Subsequence<S extends Sequence>
    extends Sequence

Wraps a `Sequence` to have a narrower range of elements.

This sequence acts as a proxy for the real sequence, translating element indexes on the fly by adding `begin` to them. Sequences of this type must be used with a `SubsequenceComparator`.

### Constructor Summary

Constructors
Constructor and Description
`Subsequence(S base, int begin, int end)` Construct a subset of another sequence.

### Method Summary

Methods
`static <S extends Sequence> Subsequence<S>` `a(S a, Edit region)` Construct a subsequence around the A region/base sequence.
`static <S extends Sequence> Subsequence<S>` `b(S b, Edit region)` Construct a subsequence around the B region/base sequence.
`int` `size()`
`static <S extends Sequence> EditList` `toBase(EditList edits, Subsequence<S> a, Subsequence<S> b)` Adjust the Edits to reflect positions in the base sequence.
`static <S extends Sequence> void` `toBase(Edit e, Subsequence<S> a, Subsequence<S> b)` Adjust the Edit to reflect positions in the base sequence.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### Subsequence

    public Subsequence(S base,
               int begin,
               int end)

Construct a subset of another sequence. The size of the subsequence will be `end - begin`.

Parameters:
  `base` - the real sequence.
  `begin` - First element index of `base` that will be part of this new subsequence. The element at `begin` will be this sequence's element 0.
  `end` - One past the last element index of `base` that will be part of this new subsequence.

### Method Detail

#### a

    public static <S extends Sequence> Subsequence<S> a(S a,
                                        Edit region)

Construct a subsequence around the A region/base sequence.

Type Parameters:
  `S` - the base sequence type.
Parameters:
  `a` - the A sequence.
  `region` - the region of `a` to create a subsequence around.
Returns:
  subsequence of `base` as described by A in `region`.

#### b

    public static <S extends Sequence> Subsequence<S> b(S b,
                                        Edit region)

Construct a subsequence around the B region/base sequence.

Type Parameters:
  `S` - the base sequence type.
Parameters:
  `b` - the B sequence.
  `region` - the region of `b` to create a subsequence around.
Returns:
  subsequence of `base` as described by B in `region`.

#### toBase

    public static <S extends Sequence> void toBase(Edit e,
                                   Subsequence<S> a,
                                   Subsequence<S> b)

Adjust the Edit to reflect positions in the base sequence.

Type Parameters:
  `S` - the base sequence type.
Parameters:
  `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.
  `a` - the A sequence.
  `b` - the B sequence.

#### toBase

    public static <S extends Sequence> EditList toBase(EditList edits,
                                       Subsequence<S> a,
                                       Subsequence<S> b)

Adjust the Edits to reflect positions in the base sequence.

Type Parameters:
  `S` - the base sequence type.
Parameters:
  `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.
  `a` - the A sequence.
  `b` - the B sequence.
Returns:
  always `edits` (as the list was updated in-place).

#### size

    public int size()

Specified by:
  `size` in class `Sequence`
Returns:
  total number of items in the sequence.