org.eclipse.jgit.diff

## Class Edit

- java.lang.Object
- - org.eclipse.jgit.diff.Edit

    public class Edit
    extends Object

A modified region detected between two versions of roughly the same content.

An edit covers the modified region only. It does not cover a common region.

Regions should be specified using 0 based notation, so add 1 to the start and end marks for line numbers in a file.

An edit where `beginA == endA && beginB < endB` is an insert edit, that is sequence B inserted the elements in region `[beginB, endB)` at `beginA`.

An edit where `beginA < endA && beginB == endB` is a delete edit, that is sequence B has removed the elements between `[beginA, endA)`.

An edit where `beginA < endA && beginB < endB` is a replace edit, that is sequence B has replaced the range of elements between `[beginA, endA)` with those found in `[beginB, endB)`.

### Nested Class Summary

Nested Classes
`static class` `Edit.Type` Type of edit

### Constructor Summary

Constructors
Constructor and Description
`Edit(int as, int bs)` Create a new empty edit.
`Edit(int as, int ae, int bs, int be)` Create a new edit.

### Method Summary

All Methods Instance Methods Concrete Methods
`Edit` `after(Edit cut)` Construct a new edit representing the region after cut.
`Edit` `before(Edit cut)` Construct a new edit representing the region before cut.
`boolean` `equals(Object o)`
`void` `extendA()` Increase `getEndA()` by 1.
`void` `extendB()` Increase `getEndB()` by 1.
`int` `getBeginA()`
`int` `getBeginB()`
`int` `getEndA()`
`int` `getEndB()`
`int` `getLengthA()`
`int` `getLengthB()`
`Edit.Type` `getType()`
`int` `hashCode()`
`boolean` `isEmpty()`
`void` `swap()` Swap A and B, so the edit goes the other direction.
`String` `toString()`

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

`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

### Constructor Detail

#### Edit

    public Edit(int as,
                int bs)

Create a new empty edit.

Parameters:
  `as` - beginA: start and end of region in sequence A; 0 based.
  `bs` - beginB: start and end of region in sequence B; 0 based.

#### Edit

    public Edit(int as,
                int ae,
                int bs,
                int be)

Create a new edit.

Parameters:
  `as` - beginA: start of region in sequence A; 0 based.
  `ae` - endA: end of region in sequence A; must be >= as.
  `bs` - beginB: start of region in sequence B; 0 based.
  `be` - endB: end of region in sequence B; must be > = bs.

### Method Detail

#### getType

    public final Edit.Type getType()

Returns:
  the type of this region

#### isEmpty

    public final boolean isEmpty()

Returns:
  true if the edit is empty (lengths of both a and b is zero).

#### getBeginA

    public final int getBeginA()

Returns:
  start point in sequence A.

#### getEndA

    public final int getEndA()

Returns:
  end point in sequence A.

#### getBeginB

    public final int getBeginB()

Returns:
  start point in sequence B.

#### getEndB

    public final int getEndB()

Returns:
  end point in sequence B.

#### getLengthA

    public final int getLengthA()

Returns:
  length of the region in A.

#### getLengthB

    public final int getLengthB()

Returns:
  length of the region in B.

#### before

    public final Edit before(Edit cut)

Construct a new edit representing the region before cut.

Parameters:
  `cut` - the cut point. The beginning A and B points are used as the end points of the returned edit.
Returns:
  an edit representing the slice of `this` edit that occurs before `cut` starts.

#### after

    public final Edit after(Edit cut)

Construct a new edit representing the region after cut.

Parameters:
  `cut` - the cut point. The ending A and B points are used as the starting points of the returned edit.
Returns:
  an edit representing the slice of `this` edit that occurs after `cut` ends.

#### extendA

    public void extendA()

Increase `getEndA()` by 1.

#### extendB

    public void extendB()

Increase `getEndB()` by 1.

#### swap

    public void swap()

Swap A and B, so the edit goes the other direction.

#### hashCode

    public int hashCode()

Overrides:
  `hashCode` in class `Object`

#### equals

    public boolean equals(Object o)

Overrides:
  `equals` in class `Object`

#### toString

    public String toString()

Overrides:
  `toString` in class `Object`