org.eclipse.jgit.lib

## Class IndexDiff

- java.lang.Object
- - org.eclipse.jgit.lib.IndexDiff

    public class IndexDiff
    extends Object

Compares the index, a tree, and the working directory Ignored files are not taken into account. The following information is retrieved:

- added files
- changed files
- removed files
- missing files
- modified files
- conflicting files
- untracked files
- files with assume-unchanged flag

### Nested Class Summary

Nested Classes
`static class` `IndexDiff.StageState` Represents the state of the index for a certain path regarding the stages - which stages exist for a path and which not (base, ours, theirs).

### Constructor Summary

Constructors
Constructor and Description
`IndexDiff(Repository repository, ObjectId objectId, WorkingTreeIterator workingTreeIterator)` Construct an Indexdiff
`IndexDiff(Repository repository, String revstr, WorkingTreeIterator workingTreeIterator)` Construct an IndexDiff

### Method Summary

Methods
`boolean` `diff()` Run the diff operation.
`boolean` `diff(ProgressMonitor monitor, int estWorkTreeSize, int estIndexSize, String title)` Run the diff operation.
`Set<String>` `getAdded()`
`Set<String>` `getAssumeUnchanged()`
`Set<String>` `getChanged()`
`Set<String>` `getConflicting()`
`Map<String,IndexDiff.StageState>` `getConflictingStageStates()`
`Set<String>` `getIgnoredNotInIndex()` The method returns the list of ignored files and folders.
`FileMode` `getIndexMode(String path)` Get the file mode of the given path in the index
`Set<String>` `getMissing()`
`Set<String>` `getModified()`
`Set<String>` `getRemoved()`
`Set<String>` `getUntracked()`
`Set<String>` `getUntrackedFolders()`
`void` `setFilter(TreeFilter filter)` Sets a filter.

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

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

### Constructor Detail

#### IndexDiff

    public IndexDiff(Repository repository,
             String revstr,
             WorkingTreeIterator workingTreeIterator)
              throws IOException

Construct an IndexDiff

Parameters:
  `repository` -
  `revstr` - symbolic name e.g. HEAD An EmptyTreeIterator is used if `revstr` cannot be resolved.
  `workingTreeIterator` - iterator for working directory
Throws:
  `IOException`

#### IndexDiff

    public IndexDiff(Repository repository,
             ObjectId objectId,
             WorkingTreeIterator workingTreeIterator)
              throws IOException

Construct an Indexdiff

Parameters:
  `repository` -
  `objectId` - tree id. If null, an EmptyTreeIterator is used.
  `workingTreeIterator` - iterator for working directory
Throws:
  `IOException`

### Method Detail

#### setFilter

    public void setFilter(TreeFilter filter)

Sets a filter. Can be used e.g. for restricting the tree walk to a set of files.

Parameters:
  `filter` -

#### diff

    public boolean diff()
                 throws IOException

Run the diff operation. Until this is called, all lists will be empty. Use `diff(ProgressMonitor, int, int, String)` if a progress monitor is required.

Returns:
  if anything is different between index, tree, and workdir
Throws:
  `IOException`

#### diff

    public boolean diff(ProgressMonitor monitor,
               int estWorkTreeSize,
               int estIndexSize,
               String title)
                 throws IOException

Run the diff operation. Until this is called, all lists will be empty.

The operation may be aborted by the progress monitor. In that event it will report what was found before the cancel operation was detected. Callers should ignore the result if monitor.isCancelled() is true. If a progress monitor is not needed, callers should use `diff()` instead. Progress reporting is crude and approximate and only intended for informing the user.

Parameters:
  `monitor` - for reporting progress, may be null
  `estWorkTreeSize` - number or estimated files in the working tree
  `estIndexSize` - number of estimated entries in the cache
  `title` -
Returns:
  if anything is different between index, tree, and workdir
Throws:
  `IOException`

#### getAdded

    public Set<String> getAdded()

Returns:
  list of files added to the index, not in the tree

#### getChanged

    public Set<String> getChanged()

Returns:
  list of files changed from tree to index

#### getRemoved

    public Set<String> getRemoved()

Returns:
  list of files removed from index, but in tree

#### getMissing

    public Set<String> getMissing()

Returns:
  list of files in index, but not filesystem

#### getModified

    public Set<String> getModified()

Returns:
  list of files modified on disk relative to the index

#### getUntracked

    public Set<String> getUntracked()

Returns:
  list of files that are not ignored, and not in the index.

#### getConflicting

    public Set<String> getConflicting()

Returns:
  list of files that are in conflict, corresponds to the keys of `getConflictingStageStates()`

#### getConflictingStageStates

    public Map<String,IndexDiff.StageState> getConflictingStageStates()

Returns:
  the map from each path of `getConflicting()` to its corresponding `IndexDiff.StageState`
Since:
  3.0

#### getIgnoredNotInIndex

    public Set<String> getIgnoredNotInIndex()

The method returns the list of ignored files and folders. Only the root folder of an ignored folder hierarchy is reported. If a/b/c is listed in the .gitignore then you should not expect a/b/c/d/e/f to be reported here. Only a/b/c will be reported. Furthermore only ignored files / folders are returned that are NOT in the index.

Returns:
  list of files / folders that are ignored

#### getAssumeUnchanged

    public Set<String> getAssumeUnchanged()

Returns:
  list of files with the flag assume-unchanged

#### getUntrackedFolders

    public Set<String> getUntrackedFolders()

Returns:
  list of folders containing only untracked files/folders

#### getIndexMode

    public FileMode getIndexMode(String path)

Get the file mode of the given path in the index

Parameters:
  `path` -
Returns:
  file mode