# All Classes

All Classes Interface Summary Class Summary Enum Summary Exception Summary
AbbreviatedObjectId: A prefix abbreviation of an `ObjectId`.
AbstractAdvertiseRefsHook: Implementation of `AdvertiseRefsHook` that advertises the same refs for upload-pack and receive-pack.
AbstractMatcher: Base class for default methods as `AbstractMatcher.toString()` and such.
AbstractPlotRenderer<TLane extends PlotLane,​TColor>: Basic commit graph renderer for graphical user interfaces.
AbstractTreeIterator: Walks a Git tree (directory) in Git sort order.
AddCommand: A class used to execute a `Add` command.
AddNoteCommand: Add object notes.
AdvertiseRefsHook: Hook to allow callers to take over advertising refs to the client.
AdvertiseRefsHookChain: `AdvertiseRefsHook` that delegates to a list of other hooks.
AmazonS3: A simple HTTP REST client for the Amazon S3 service.
AmbiguousObjectException: An `AbbreviatedObjectId` cannot be extended.
AndRevFilter: Includes a commit only if all subfilters include the same commit.
AndTreeFilter: Includes a tree entry only if all subfilters include the same tree entry.
AnyObjectId: A (possibly mutable) SHA-1 abstraction.
ApplyCommand: Apply a patch to files and/or to the index.
ApplyResult: Encapsulates the result of a `ApplyCommand`
ArchiveCommand: Create an archive of files from a named tree.
ArchiveCommand.Format<T extends Closeable>: Archival format.
ArchiveCommand.UnsupportedFormatException: Signals an attempt to use an archival format that ArchiveCommand doesn't know about (for example due to a typo).
AsyncObjectLoaderQueue<T extends ObjectId>: Queue to open objects asynchronously.
AsyncObjectSizeQueue<T extends ObjectId>: Queue to examine object sizes asynchronously.
AsyncOperation: Asynchronous operation handle.
AsyncRevObjectQueue: Queue to lookup and parse objects asynchronously.
Attribute: Represents an attribute.
Attribute.State: The attribute value state
AttributesNode: Represents a bundle of attributes inherited from a base directory.
AttributesRule: A single attributes rule corresponding to one line in a .gitattributes file.
AuthorRevFilter: Matches only commits whose author name matches the pattern.
AutoCRLFInputStream: An OutputStream that expands LF to CRLF.
AutoCRLFOutputStream: An OutputStream that expands LF to CRLF.
Base64: Encodes and decodes to and from Base64 notation.
BaseConnection: Base helper class for implementing operations connections.
BasePackFetchConnection: Fetch implementation using the native Git pack transfer service.
BasePackPushConnection: Push implementation using the native Git pack transfer service.
BaseReceivePack: Base implementation of the side of a push connection that receives objects.
BaseReceivePack.FirstLine: Data in the first line of a request, the line itself plus capabilities.
BaseReceivePack.ReceiveConfig: Configuration for receive operations.
BaseRepositoryBuilder<B extends BaseRepositoryBuilder,​R extends Repository>: Base builder to customize repository construction.
BatchingProgressMonitor: ProgressMonitor that batches update events.
BatchRefUpdate: Batch of reference updates to be applied to a repository.
BeforeDfsPackIndexLoadedEvent: Describes the `DfsPackFile` just before its index is loaded.
BeforeDfsPackIndexLoadedListener: Receives `BeforeDfsPackIndexLoadedEvent`s.
BinaryDelta: Recreate a stream from a base stream and a GIT pack delta.
BinaryHunk: Part of a "GIT binary patch" to describe the pre-image or post-image
BinaryHunk.Type: Type of information stored in a binary hunk.
BitmapIndex: A compressed bitmap representation of the entire object graph.
BitmapIndex.Bitmap: A bitmap representation of ObjectIds that can be iterated to return the underlying `ObjectId`s or operated on with other `Bitmap`s.
BitmapIndex.BitmapBuilder: A builder for a bitmap.
BitmapIndexImpl: A compressed bitmap representation of the entire object graph.
BitmapObject: Base object type accessed during bitmap expansion.
BlameCommand: Blame command for building a `BlameResult` for a file path.
BlameGenerator: Generate author information for lines based on a provided file.
BlameResult: Collects line annotations for inspection by applications.
BlobBasedConfig: Configuration file based on the blobs stored in the repository.
BlockList<T>: Random access list that allocates entries in blocks.
BranchConfig: Branch section of a Git configuration file.
BranchTrackingStatus: Status of a branch's relation to its remote-tracking branch.
BundleWriter: Creates a Git bundle file, for sneaker-net transport to another system.
CachedAuthenticator: Abstract authenticator which remembers prior authentications.
CachedAuthenticator.CachedAuthentication: Authentication data to remember and reuse.
CachedPack: Describes a pack file `ObjectReuseAsIs` can append onto a stream.
CanceledException: Exception thrown when an operation was canceled
CannotDeleteCurrentBranchException: Thrown when trying to delete a branch which is currently checked out
CanonicalTreeParser: Parses raw Git trees from the canonical semi-text/semi-binary format.
ChainingCredentialsProvider: A credentials provider chaining multiple credentials providers
ChangeIdUtil: Utilities for creating and working with Change-Id's, like the one used by Gerrit Code Review.
CheckoutCommand: Checkout a branch to the working tree.
CheckoutCommand.Stage: Stage to check out, see `CheckoutCommand.setStage(Stage)`.
CheckoutConflictException: Exception thrown when a command can't succeed because of unresolved conflicts.
CheckoutConflictException: Exception thrown if a conflict occurs during a merge checkout.
CheckoutEntry: Parsed information about a checkout.
CheckoutEntryImpl: Parsed information about a checkout.
CheckoutResult: Encapsulates the result of a `CheckoutCommand`
CheckoutResult.Status: The status
CherryPickCommand: A class used to execute a `cherry-pick` command.
CherryPickResult: Encapsulates the result of a `CherryPickCommand`.
CherryPickResult.CherryPickStatus: The cherry-pick status
CleanCommand: Remove untracked files from the working tree
CloneCommand: Clone a repository into a new working directory
CombinedFileHeader: A file in the Git "diff --cc" or "diff --combined" format.
CombinedHunkHeader: Hunk header for a hunk appearing in a "diff --cc" style patch.
CommitBuilder: Mutable builder to construct a commit recording the state of a project.
CommitCommand: A class used to execute a `Commit` command.
CommitterRevFilter: Matches only commits whose committer name matches the pattern.
CommitTimeRevFilter: Selects commits based upon the commit time field.
CompoundException: An exception detailing multiple reasons for failure.
ConcurrentRefUpdateException: Exception thrown when a command wants to update a ref but failed because another process is accessing (or even also updating) the ref.
Config: Git style `.config`, `.gitconfig`, `.gitmodules` file.
Config.ConfigEnum: Converts enumeration values into configuration options and vice-versa, allowing to match a config option with an enum value.
Config.SectionParser<T>: Parses a section of the configuration into an application model object.
ConfigChangedEvent: Describes a change to one or more keys in the configuration.
ConfigChangedListener: Receives `ConfigChangedEvent`s.
ConfigConstants: Constants for use with the Configuration classes: section names, configuration keys
ConfigInvalidException: Indicates a text string is not a valid Git style configuration.
Connection: Represent connection for operation on a remote repository.
Constants: Misc.
ContentSource: Supplies the content of a file for `DiffFormatter`.
ContentSource.Pair: A pair of sources to access the old and new sides of a DiffEntry.
CoreConfig: This class keeps git repository core parameters.
CoreConfig.AutoCRLF: Permissible values for `core.autocrlf`.
CoreConfig.CheckStat: Permissible values for `core.checkstat`
CoreConfig.HideDotFiles: Options for hiding files whose names start with a period
CoreConfig.SymLinks: Options for symlink handling
CorruptObjectException: Exception thrown when an object cannot be read from Git.
CountingOutputStream: Counts the number of bytes written.
CreateBranchCommand: Used to create a local branch.
CreateBranchCommand.SetupUpstreamMode: The modes available for setting up the upstream configuration (corresponding to the --set-upstream, --track, --no-track options
CredentialItem: A credential requested from a `CredentialsProvider`.
CredentialItem.CharArrayType: An item whose value is stored as a char[] and is therefore clearable.
CredentialItem.InformationalMessage: An advice message presented to the user, with no response required.
CredentialItem.Password: Prompt for a password, which is masked on input.
CredentialItem.StringType: An item whose value is stored as a string.
CredentialItem.Username: Prompt for a username, which is not masked on input.
CredentialItem.YesNoType: An item whose value is a boolean choice, presented as Yes/No.
CredentialsProvider: Provide credentials for use in connecting to Git repositories.
CredentialsProviderUserInfo: A JSch `UserInfo` adapter for a `CredentialsProvider`.
Daemon: Basic daemon for the anonymous `git://` transport protocol.
DaemonClient: Active network client of `Daemon`.
DaemonService: A service exposed by `Daemon` over anonymous `git://`.
DateRevQueue: A queue of commits sorted by commit time order.
DefaultNoteMerger: Default implementation of the `NoteMerger`.
DeleteBranchCommand: Used to delete one or several branches.
DeleteTagCommand: Used to delete one or several tags.
DeltaEncoder: Encodes an instruction stream for `BinaryDelta`.
DeltaIndex: Index of blocks in a source file.
DepthWalk: Interface for revision walkers that perform depth filtering.
DepthWalk.Commit: RevCommit with a depth (in commits) from a root.
DepthWalk.ObjectWalk: Subclass of ObjectWalk that performs depth filtering.
DepthWalk.RevWalk: Subclass of RevWalk that performs depth filtering.
DescribeCommand: Given a commit, show the most recent tag that is reachable from a commit.
DetachedHeadException: Exception thrown when a command expected a non-detached `HEAD` reference
DfsBlockCache: Caches slices of a `DfsPackFile` in memory for faster read access.
DfsBlockCacheConfig: Configuration parameters for `DfsBlockCache`.
DfsCachedPack: A DfsPackFile available for reuse as-is.
DfsGarbageCollector: Repack and garbage collect a repository.
DfsInserter: Inserts objects into the DFS.
DfsObjDatabase: Manages objects stored in `DfsPackFile` on a storage system.
DfsObjDatabase.PackSource: Sources for a pack file.
DfsOutputStream: Output stream to create a file on the DFS.
DfsPackCompactor: Combine several pack files into one pack.
DfsPackDescription: Description of a DFS stored pack/index file.
DfsPackFile: A Git version 2 pack file representation.
DfsPackParser: Parses a pack stream into the DFS, by creating a new pack and index.
DfsPacksChangedEvent: Describes a change to the list of packs in a `DfsRepository`.
DfsPacksChangedListener: Receives `DfsPacksChangedEvent`s.
DfsReader: Reader to access repository content through.
DfsReaderOptions: Options controlling how objects are read from a DFS stored repository.
DfsRefDatabase
DfsRefDatabase.RefCache: Collection of references managed by this database.
DfsRepository: A Git repository on a DFS.
DfsRepositoryBuilder<B extends DfsRepositoryBuilder,​R extends DfsRepository>: Constructs a `DfsRepository`.
DfsRepositoryDescription: A description of a Git repository on a DFS.
DfsText: Translation bundle for the DFS storage implementation.
DiffAlgorithm: Compares two `Sequence`s to create an `EditList` of changes.
DiffAlgorithm.SupportedAlgorithm: Supported diff algorithm
DiffCommand: Show changes between commits, commit and working tree, etc.
DiffConfig: Keeps track of diff related configuration options.
DiffConfig.RenameDetectionType: Permissible values for `diff.renames`.
DiffEntry: A value class representing a change to a file
DiffEntry.ChangeType: General type of change a single file-level patch describes.
DiffEntry.Side: Specify the old or new side for more generalized access.
DiffFormatter: Format a Git style patch script.
DirCache: Support for the Git dircache (aka index file).
DirCacheBuilder: Updates a `DirCache` by adding individual `DirCacheEntry`s.
DirCacheBuildIterator: Iterate and update a `DirCache` as part of a `TreeWalk`.
DirCacheCheckout: This class handles checking out one or two trees merging with the index.
DirCacheEditor: Updates a `DirCache` by supplying discrete edit commands.
DirCacheEditor.DeletePath: Deletes a single file entry from the index.
DirCacheEditor.DeleteTree: Recursively deletes all paths under a subtree.
DirCacheEditor.PathEdit: Any index record update.
DirCacheEntry: A single file (or stage of a file) in a `DirCache`.
DirCacheIterator: Iterate a `DirCache` as part of a `TreeWalk`.
DirCacheTree: Single tree record from the 'TREE' `DirCache` extension.
DisabledOutputStream: An OutputStream which always throws IllegalStateExeption during write.
Edit: A modified region detected between two versions of roughly the same content.
Edit.Type: Type of edit
EditList: Specialized list of `Edit`s in a document.
EmptyProgressMonitor: A convenient base class which provides empty method bodies for all ProgressMonitor methods.
EmptyTreeIterator: Iterator over an empty tree (a directory with no files).
EntryExistsException: Attempt to add an entry to a tree that already exists.
EolCanonicalizingInputStream: An input stream which canonicalizes EOLs bytes on the fly to '\n'.
EolCanonicalizingInputStream.IsBinaryException: A special exception thrown when `EolCanonicalizingInputStream` is told to throw an exception when attempting to read a binary file.
FastIgnoreRule: "Fast" (compared with IgnoreRule) git ignore rule implementation supporting also double star `**`pattern.``
FetchCommand: A class used to execute a `Fetch` command.
FetchConnection: Lists known refs from the remote and copies objects of selected refs.
FetchResult: Final status after a successful fetch from a remote repository.
FIFORevQueue: A queue of commits in FIFO order.
FileBasedConfig: The configuration file that is stored in the file of the file system.
FileHeader: Patch header describing an action for a single file path.
FileHeader.PatchType: Type of patch used by this file.
FileMode: Constants describing various file modes recognized by GIT.
FileNameMatcher: This class can be used to match filenames against fnmatch like patterns.
FileRepository: Represents a Git repository.
FileRepositoryBuilder: Constructs a `FileRepository`.
FileResolver<C>: Default resolver serving from the local filesystem.
FileSnapshot: Caches when a file was last read, making it possible to detect future edits.
FileTreeEntry: Deprecated. To look up information about a single path, use `TreeWalk.forPath(Repository, String, org.eclipse.jgit.revwalk.RevTree)`.
FileTreeIterator: Working directory iterator for standard Java IO.
FileTreeIterator.FileEntry: Wrapper for a standard Java IO file
FileUtils: File Utilities
FollowFilter: Updates the internal path filter to follow copy/renames.
FooterKey: Case insensitive key for a `FooterLine`.
FooterLine: Single line at the end of a message, such as a "Signed-off-by: someone".
FormatError: An error in a patch script
FormatError.Severity: Classification of an error.
FS: Abstraction to support various file system operations not in Java.
FS_POSIX: Base FS for POSIX based systems
FS_POSIX_Java5: FS implementaton for Java5
FS_POSIX_Java6: FS implementation for POSIX systems using Java6
FS_Win32: FS implementation for Windows
FS_Win32_Cygwin: FS implementation for Cygwin on Windows
FS.Attributes: File attributes we typically care for.
FS.FSFactory: This class creates FS instances.
GarbageCollectCommand: A class used to execute a `gc` command.
GC: A garbage collector for git `FileRepository`.
Git: Offers a "GitPorcelain"-like API to interact with a git repository.
GitAPIException: Superclass of all exceptions thrown by the API classes in `org.eclipse.jgit.api`
GitCommand<T>: Common superclass of all commands in the package `org.eclipse.jgit.api`
GitDateFormatter: A utility for formatting dates according to the Git log.date formats plus extensions.
GitDateFormatter.Format: Git and JGit formats
GitDateParser: Parses strings with time and date specifications into `Date`.
GitlinkTreeEntry: Deprecated. To look up information about a single path, use `TreeWalk.forPath(Repository, String, org.eclipse.jgit.revwalk.RevTree)`.
GitProtocolConstants: Wire constants for the native Git protocol.
GSSManagerFactory: Factory to detect which GSSManager implementation should be used.
HashedSequence<S extends Sequence>: Wraps a `Sequence` to assign hash codes to elements.
HashedSequenceComparator<S extends Sequence>: Wrap another comparator for use with `HashedSequence`.
HashedSequencePair<S extends Sequence>: Wraps two `Sequence` instances to cache their element hash codes.
HistogramDiff: An extended form of Bram Cohen's patience diff algorithm.
Hook: An enum describing the different hooks a user can implement to customize his repositories.
HttpConnection: The interface of connections used during HTTP communication.
HttpConnectionFactory: The interface of a factory returning `HttpConnection`
HttpSupport: Extra utilities to support usage of HTTP.
HttpTransport: The base class for transports that use HTTP as underlying protocol.
HunkHeader: Hunk header describing the layout of a single block of lines
HunkHeader.OldImage: Details about an old image of the file.
IgnoreNode: Represents a bundle of ignore rules inherited from a base directory.
IgnoreNode.MatchResult: Result from `IgnoreNode.isIgnored(String, boolean)`.
IgnoreRule: Deprecated. this rule does not support double star pattern and is slow parsing glob expressions.
IllegalTodoFileModification: Attempt to modify a rebase-todo file in an unsupported way
IMatcher: Generic string matcher
IncorrectObjectTypeException: An inconsistency with respect to handling different object types.
IndexChangedEvent: Describes a change to one or more paths in the index file.
IndexChangedListener: Receives `IndexChangedEvent`s.
IndexDiff: Compares the index, a tree, and the working directory Ignored files are not taken into account.
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).
IndexDiff.WorkingTreeIteratorFactory: A factory to producing WorkingTreeIterators
IndexDiffFilter: A performance optimized variant of `TreeFilter.ANY_DIFF` which should be used when among the walked trees there is a `DirCacheIterator` and a `WorkingTreeIterator`.
IndexWriteException: Cannot write a modified index.
InflaterCache: Creates zlib based inflaters as necessary for object decompression.
InitCommand: Create an empty git repository or reinitalize an existing one
InMemoryRepository: Git repository stored entirely in the local process memory.
InterIndexDiffFilter: A filter for extracting changes between two versions of the dircache.
InterruptTimer: Triggers an interrupt on the calling thread if it doesn't complete a block.
IntList: A more efficient List<Integer> using a primitive integer array.
InvalidConfigurationException: Exception thrown when a command fails due to an invalid configuration
InvalidMergeHeadsException: Exception thrown when a merge command was called without specifying the proper amount/type of merge heads.
InvalidObjectIdException: Thrown when an invalid object id is passed in as an argument.
InvalidPathException: Thrown when JGit detects and refuses to use an invalid path
InvalidPatternException: Thrown when a pattern passed in an argument was wrong.
InvalidRebaseStepException: Exception thrown if a rebase step is invalid.
InvalidRefNameException: Exception thrown when an invalid Ref name was encountered
InvalidRemoteException: Exception thrown when a fetch command was called with an invalid remote
InvalidTagNameException: Exception thrown when a tag command was called with an invalid tag name (or null), such as bad~tag.
IO: Input/Output utilities
JDKHttpConnection: A `HttpConnection` which simply delegates every call to a `HttpURLConnection`.
JDKHttpConnectionFactory: A factory returning instances of `JDKHttpConnection`
JGitInternalException: Exception thrown when during command execution a low-level exception from the JGit library is thrown.
JGitText: Translation bundle for JGit core
JschConfigSessionFactory: The base session factory that loads known hosts and private keys from `$HOME/.ssh`.
JschSession: Run remote commands using Jsch.
LargeObjectException: An object is too big to load into memory as a single byte array.
LargeObjectException.ExceedsByteArrayLimit: Object size exceeds JVM limit of 2 GiB per byte array.
LargeObjectException.ExceedsLimit: Object size exceeds the caller's upper limit.
LargeObjectException.OutOfMemory: An error caused by the JVM being out of heap space.
LeadingAsteriskMatcher: Matcher for simple regex patterns starting with an asterisk, e.g.
LIFORevQueue: A queue of commits in LIFO order.
LimitedInputStream: Wraps a `InputStream`, limiting the number of bytes which can be read.
ListBranchCommand: Used to obtain a list of branches.
ListBranchCommand.ListMode: The modes available for listing branches (corresponding to the -r and -a options)
ListenerHandle: Tracks a previously registered `RepositoryListener`.
ListenerList: Manages a thread-safe list of `RepositoryListener`s.
ListNotesCommand: List object notes.
ListTagCommand: Used to obtain a list of tags.
LockFailedException: An exception occurring when a file cannot be locked
LockFile: Git style file locking and replacement.
LogCommand: A class used to execute a `Log` command.
LongList: A more efficient List<Long> using a primitive long array.
LowLevelDiffAlgorithm: Compares two sequences primarily based upon hash codes.
LsRemoteCommand: The ls-remote command
MaxCountRevFilter: Limits the number of commits output.
MergeAlgorithm: Provides the merge algorithm which does a three-way merge on content provided as RawText.
MergeChunk: One chunk from a merge result.
MergeChunk.ConflictState: A state telling whether a MergeChunk belongs to a conflict or not.
MergeCommand: A class used to execute a `Merge` command.
MergeCommand.FastForwardMode: The modes available for fast forward merges corresponding to the `--ff`, `--no-ff` and `--ff-only` options under `branch.<name>.mergeoptions`.
MergeCommand.FastForwardMode.Merge: The modes available for fast forward merges corresponding to the options under `merge.ff`.
MergeConfig: Holds configuration for merging into a given branch
MergeFormatter: A class to convert merge results into a Git conformant textual presentation
MergeMessageFormatter: Formatter for constructing the commit message for a merge commit.
Merger: Instance of a specific `MergeStrategy` for a single `Repository`.
MergeResult: Encapsulates the result of a `MergeCommand`.
MergeResult<S extends Sequence>: The result of merging a number of `Sequence` objects.
MergeResult.MergeStatus: The status the merge resulted in.
MergeStrategy: A method of combining two or more trees together to form an output tree.
MessageRevFilter: Matches only commits whose message matches the pattern.
MessageWriter: Combines messages from an OutputStream (hopefully in UTF-8) and a Writer.
MissingBundlePrerequisiteException: Indicates a base/common object was required, but is not found.
MissingObjectException: An expected object is missing.
MultipleParentsNotAllowedException: The commit to be cherry-pick'ed did not have exactly one parent
MutableInteger: A boxed integer that can be modified.
MutableObjectId: A mutable SHA-1 abstraction.
MyersDiff<S extends Sequence>: Diff algorithm, based on "An O(ND) Difference Algorithm and its Variations", by Eugene Myers.
NameConflictTreeWalk: Specialized TreeWalk to detect directory-file (D/F) name conflicts.
NameMatcher: Matcher built from patterns for file names (single path segments).
NameRevCommand: Command to find human-readable names of revisions.
NB: Conversion utilities for network byte order handling.
NetRC: NetRC file parser.
NetRC.NetRCEntry: .netrc file entry
NetRCCredentialsProvider: Simple .netrc credentials provider.
NLS: The purpose of this class is to provide NLS (National Language Support) configurable per thread.
NoClosingBracketException: Thrown when a pattern contains a character group which is open to the right side or a character class which is open to the right side.
NoFilepatternException: Exception thrown when the options given to a command don't include a file pattern which is mandatory for processing.
NoHeadException: Exception thrown when a command expected the `HEAD` reference to exist but couldn't find such a reference
NoMergeBaseException: Exception thrown if a merge fails because no merge base could be determined.
NoMergeBaseException.MergeBaseFailureReason: An enum listing the different reason why no merge base could be determined.
NoMessageException: Exception thrown when the options given to a command don't include a specification of a message text (e.g.
NoRemoteRepositoryException: Indicates a remote repository does not exist.
Note: In-memory representation of a single note attached to one object.
NoteMap: Index of notes from a note branch.
NoteMapMerger: Three-way note tree merge.
NoteMerger: Three-way note merge operation.
NotesMergeConflictException: This exception will be thrown from the `NoteMerger` when a conflict on Notes content is found during merge.
NotIgnoredFilter: Skip `WorkingTreeIterator` entries that appear in gitignore files.
NotMergedException: Thrown when branch deletion fails due to unmerged data
NotRevFilter: Includes a commit only if the subfilter does not include the commit.
NotSupportedException: JGit encountered a case that it knows it cannot yet handle.
NotTreeFilter: Includes an entry only if the subfilter does not include the entry.
NoWorkTreeException: Indicates a `Repository` has no working directory, and is thus bare.
NullOutputStream: An OutputStream which ignores everything written to it.
NullProgressMonitor: A NullProgressMonitor does not report progress anywhere.
ObjectChecker: Verifies that an object is formatted correctly.
ObjectDatabase: Abstraction of arbitrary object storage.
ObjectDirectory: Traditional file system based `ObjectDatabase`.
ObjectDirectoryPackParser: Consumes a pack stream and stores as a pack file in `ObjectDirectory`.
ObjectId: A SHA-1 abstraction.
ObjectIdOwnerMap<V extends ObjectIdOwnerMap.Entry>: Fast, efficient map for `ObjectId` subclasses in only one map.
ObjectIdOwnerMap.Entry: Type of entry stored in the `ObjectIdOwnerMap`.
ObjectIdRef: A `Ref` that points directly at an `ObjectId`.
ObjectIdRef.PeeledNonTag: A reference to a non-tag object coming from a cached source.
ObjectIdRef.PeeledTag: An annotated tag whose peeled object has been cached.
ObjectIdRef.Unpeeled: Any reference whose peeled value is not yet known.
ObjectIdSubclassMap<V extends ObjectId>: Fast, efficient map specifically for `ObjectId` subclasses.
ObjectInserter: Inserts objects into an existing `ObjectDatabase`.
ObjectInserter.Filter: Wraps a delegate ObjectInserter.
ObjectInserter.Formatter: An inserter that can be used for formatting and id generation only.
ObjectLoader: Base class for a set of loaders for different representations of Git objects.
ObjectLoader.SmallObject: Simple loader around the cached byte array.
ObjectReader: Reads an `ObjectDatabase` for a single thread.
ObjectReuseAsIs: Extension of `ObjectReader` that supports reusing objects in packs.
ObjectStream: Stream of data coming from an object loaded by `ObjectLoader`.
ObjectStream.Filter: Simple filter stream around another stream.
ObjectStream.SmallStream: Simple stream around the cached byte array created by a loader.
ObjectToPack: Per-object state used by `PackWriter`.
ObjectWalk: Specialized subclass of RevWalk to include trees, blobs and tags.
ObjectWritingException: Cannot store an object in the object database.
OpenSshConfig: Simple configuration parser for the OpenSSH ~/.ssh/config file.
OpenSshConfig.Host: Configuration of one "Host" block in the configuration file.
OperationResult: Class holding result of operation on remote repository.
OrRevFilter: Includes a commit if any subfilters include the same commit.
OrTreeFilter: Includes a tree entry if any subfilters include the same tree entry.
PackBitmapIndex: Logical representation of the bitmap data stored in the pack index.
PackBitmapIndexBuilder: Helper for constructing `PackBitmapIndex`es.
PackBitmapIndexBuilder.StoredEntry: Data object for the on disk representation of a bitmap entry.
PackBitmapIndexRemapper: A PackBitmapIndex that remaps the bitmaps in the previous index to the positions in the new pack index.
PackBitmapIndexWriterV1: Creates the version 1 pack bitmap index files.
PackConfig: Configuration used by a pack writer when constructing the stream.
PackedObjectInfo: Description of an object stored in a pack file, including offset.
PacketLineIn: Read Git style pkt-line formatting from an input stream.
PacketLineOut: Write Git style pkt-line formatting to an output stream.
PackExt: A pack file extension.
PackFile: A Git version 2 pack file representation.
PackIndex: Access path to locate objects by `ObjectId` in a `PackFile`.
PackIndex.MutableEntry: Represent mutable entry of pack index consisting of object id and offset in pack (both mutable).
PackIndexWriter: Creates a table of contents to support random access by `PackFile`.
PackInvalidException: Thrown when a PackFile previously failed and is known to be unusable
PackLock: Keeps track of a `PackFile`'s associated `.keep` file.
PackMismatchException: Thrown when a PackFile no longer matches the PackIndex.
PackOutputStream: Custom output stream to support `PackWriter`.
PackParser: Parses a pack stream and imports it for an `ObjectInserter`.
PackParser.ObjectTypeAndSize: Type and size information about an object in the database buffer.
PackParser.Source: Location data is being obtained from.
PackParser.UnresolvedDelta: Information about an unresolved delta in this pack stream.
PackProtocolException: Indicates a protocol error has occurred while fetching/pushing objects.
PackReverseIndex: Reverse index for forward pack index.
PackTransport: Marker interface an object transport using Git pack transfers.
PackWriter: PackWriter class is responsible for generating pack files from specified set of objects from repository.
PackWriter.ObjectIdSet: A collection of object ids.
PackWriter.PackingPhase: Possible states that a PackWriter can be in.
PackWriter.Statistics: Summary of how PackWriter created the pack.
PackWriter.Statistics.ObjectType: Statistics about a single class of object.
Patch: A parsed collection of `FileHeader`s from a unified diff patch file
PatchApplyException: Exception thrown when applying a patch fails
PatchFormatException: Exception thrown when applying a patch fails due to an invalid format
PatchIdDiffFormatter: A DiffFormatter used to calculate the patch-id of the diff.
PathFilter: Includes tree entries only if they match the configured path.
PathFilterGroup: Includes tree entries only if they match one or more configured paths.
PathMatcher: Matcher built by patterns consists of multiple path segments.
PathSuffixFilter: Includes tree entries only if they end with the configured path (suffix match).
PatternMatchRevFilter: Abstract filter that searches text using extended regular expressions.
PersonIdent: A combination of a person identity and time in Git.
PlotCommit<L extends PlotLane>: A commit reference to a commit in the DAG.
PlotCommitList<L extends PlotLane>: An ordered list of `PlotCommit` subclasses.
PlotLane: A line space within the graph.
PlotWalk: Specialized RevWalk for visualization of a commit graph.
PostReceiveHook: Hook invoked by `ReceivePack` after all updates are executed.
PostReceiveHookChain: `PostReceiveHook` that delegates to a list of other hooks.
PreReceiveHook: Hook invoked by `ReceivePack` before any updates are executed.
PreReceiveHookChain: `PreReceiveHook` that delegates to a list of other hooks.
PreUploadHook: Hook invoked by `UploadPack` before during critical phases.
PreUploadHookChain: `PreUploadHook` that delegates to a list of other hooks.
ProcessResult: Describes the result of running an external process.
ProcessResult.Status: Status of a process' execution.
ProgressMonitor: A progress reporting interface.
PullCommand: The Pull command
PullResult: Encapsulates the result of a `PullCommand`
PushCommand: A class used to execute a `Push` command.
PushConnection: Lists known refs from the remote and sends objects to the remote.
PushResult: Result of push operation to the remote repository.
QuotedString: Utility functions related to quoted string handling.
QuotedString.BourneStyle: Quoting style used by the Bourne shell.
QuotedString.BourneUserPathStyle: Bourne style, but permits `~user` at the start of the string.
QuotedString.GitPathStyle: Quoting style that obeys the rules Git applies to file names
RawCharSequence: A rough character sequence around a raw byte buffer.
RawCharUtil: Utility class for character functions on raw bytes
RawParseUtils: Handy utility functions to parse raw object contents.
RawSubStringPattern: Searches text using only substring search.
RawText: A Sequence supporting UNIX formatted text in byte[] format.
RawTextComparator: Equivalence function for `RawText`.
ReadableChannel: Readable random access byte channel from a file.
RebaseCommand: A class used to execute a `Rebase` command.
RebaseCommand.InteractiveHandler: Allows configure rebase interactive process and modify commit message
RebaseCommand.Operation: The available operations
RebaseResult: The result of a `RebaseCommand` execution
RebaseResult.Status: The overall status
RebaseTodoFile: Offers methods to read and write files formatted like the git-rebase-todo file
RebaseTodoLine: Describes a single line in a file formatted like the git-rebase-todo file.
RebaseTodoLine.Action: Describes rebase actions
ReceiveCommand: A command being processed by `BaseReceivePack`.
ReceiveCommand.Result: Result of the update command.
ReceiveCommand.Type: Type of operation requested.
ReceivePack: Implements the server side of a push connection, receiving objects.
ReceivePackFactory<C>: Create and configure `ReceivePack` service instance.
RecursiveMerger: A three-way merger performing a content-merge if necessary across multiple bases using recursion This merger extends the resolve merger and does several things differently: - allow more than one merge base, up to a maximum - uses "Lists" instead of Arrays for chained types - recursively merges the merge bases together to compute a usable base
Ref: Pairing of a name and the `ObjectId` it currently has.
Ref.Storage: Location where a `Ref` is stored.
RefAdvertiser: Support for the start of `UploadPack` and `ReceivePack`.
RefAdvertiser.PacketLineOutRefAdvertiser: Advertiser which frames lines in a `PacketLineOut` format.
RefAlreadyExistsException: Thrown when trying to create a `Ref` with the same name as an existing one
RefComparator: Util for sorting (or comparing) Ref instances by name.
RefDatabase: Abstraction of name to `ObjectId` mapping.
RefDirectory: Traditional file system based `RefDatabase`.
RefFilter: Filters the list of refs that are advertised to the client.
RefList<T extends Ref>: Specialized variant of an ArrayList to support a `RefDatabase`.
RefList.Builder<T extends Ref>: Builder to facilitate fast construction of an immutable RefList.
ReflogCommand: The reflog command
ReflogEntry: Parsed reflog entry
ReflogEntryImpl: Parsed reflog entry
ReflogReader: Utility for reading reflog entries
ReflogWriter: Utility for writing reflog entries
RefMap: Specialized Map to present a `RefDatabase` namespace.
RefNotFoundException: Thrown when a Ref can not be resolved
RefRename: A RefUpdate combination for renaming a reference.
RefsChangedEvent: Describes a change to one or more references of a repository.
RefsChangedListener: Receives `RefsChangedEvent`s.
RefSpec: Describes how refs in one repository copy into another repository.
RefUpdate: Creates, updates or deletes any reference.
RefUpdate.Result: Status of an update request.
RefWriter: Writes out refs to the `Constants.INFO_REFS` and `Constants.PACKED_REFS` files.
RejectCommitException: Exception thrown when a commit is rejected by a hook (either `pre-commit` or `commit-msg`).
RelativeDateFormatter: Formatter to format timestamps relative to the current time using time units in the format defined by `git log --relative-date`.
RemoteConfig: A remembered remote repository, including URLs and RefSpecs.
RemoteRefUpdate: Represent request and status of a remote ref update.
RemoteRefUpdate.Status: Represent current status of a remote ref update.
RemoteRepositoryException: Contains a message from the remote repository indicating a problem.
RemoteSession: Create a remote "session" for executing remote commands.
RemoveNoteCommand: Remove object notes.
RenameBranchCommand: Used to rename branches.
RenameCallback: An instance of this class can be used in conjunction with a `FollowFilter`.
RenameDetector: Detect and resolve object renames.
RepoCommand: A class used to execute a repo command.
RepoCommand.DefaultRemoteReader: A default implementation of `RepoCommand.RemoteReader` callback.
RepoCommand.IncludedFileReader: A callback to read included xml files.
RepoCommand.RemoteReader: A callback to get ref sha1 of a repository from its uri.
Repository: Represents a Git repository.
RepositoryBuilder: Base class to support constructing a `Repository`.
RepositoryCache: Cache of active `Repository` instances.
RepositoryCache.FileKey: Location of a Repository, using the standard java.io.File API.
RepositoryCache.Key: Abstract hash key for `RepositoryCache` entries.
RepositoryEvent<T extends RepositoryListener>: Describes a modification made to a repository.
RepositoryListener: A listener can register for event delivery.
RepositoryNotFoundException: Indicates a local repository does not exist.
RepositoryResolver<C>: Locate a Git `Repository` by name from the URL.
RepositoryState: Important state of the repository that affects what can and cannot bed done.
RepoText: Translation bundle for repo command
RequestNotYetReadException: Indicates that a client request has not yet been read from the wire.
ResetCommand: A class used to execute a `Reset` command.
ResetCommand.ResetType: Kind of reset
ResolveMerger: A three-way merger performing a content-merge if necessary
ResolveMerger.MergeFailureReason: If the merge fails (means: not stopped because of unresolved conflicts) this enum is used to explain why it failed
RevBlob: A binary file, or a symbolic link.
RevCommit: A commit reference to a commit in the DAG.
RevCommitList<E extends RevCommit>: An ordered list of `RevCommit` subclasses.
RevertCommand: A class used to execute a `revert` command.
RevFilter: Selects interesting revisions during walking.
RevFlag: Application level mark bit for `RevObject`s.
RevFlagFilter: Matches only commits with some/all RevFlags already set.
RevFlagSet: Multiple application level mark bits for `RevObject`s.
RevisionSyntaxException: This signals a revision or object reference was not properly formatted.
RevObject: Base object type accessed during revision walking.
RevObjectList<E extends RevObject>: An ordered list of `RevObject` subclasses.
RevObjectList.Block: One level of contents, either an intermediate level or a leaf level.
RevSort: Sorting strategies supported by `RevWalk` and `ObjectWalk`.
RevTag: An annotated tag.
RevTree: A reference to a tree of subtrees/files.
RevWalk: Walks a commit graph and produces the matching commits in order.
RevWalkException: Indicates a checked exception was thrown inside of `RevWalk`.
RevWalkUtils: Utility methods for `RevWalk`.
RmCommand: Remove files from the index and working directory (or optionally only from the index).
SafeBufferedOutputStream: A BufferedOutputStream that throws an error if the final flush fails on close.
Sequence: Arbitrary sequence of elements.
SequenceComparator<S extends Sequence>: Equivalence function for a `Sequence` compared by difference algorithm.
ServiceMayNotContinueException: Indicates a transport service may not continue execution.
ServiceNotAuthorizedException: Indicates the request service is not authorized for current user.
ServiceNotEnabledException: Indicates the request service is not enabled on a repository.
ShowNoteCommand: Show an object note.
SideBandOutputStream: Multiplexes data and progress messages.
SkipRevFilter: Filter that includes commits after a configured number are skipped.
SkipWorkTreeFilter: To be used in combination with a DirCacheIterator: includes only tree entries for which 'skipWorkTree' flag is not set.
SquashMessageFormatter: Formatter for constructing the commit message for a squashed commit.
SshSessionFactory: Creates and destroys SSH connections to a remote system.
SshTransport: The base class for transports that use SSH protocol.
StashApplyCommand: Command class to apply a stashed commit.
StashApplyFailureException: Thrown from StashApplyCommand when stash apply fails
StashCreateCommand: Command class to stash changes in the working directory and index in a commit.
StashDropCommand: Command class to delete a stashed commit reference
StashListCommand: Command class to list the stashed commits in a repository.
Status: A class telling where the working-tree, the index and the current HEAD differ from each other.
StatusCommand: A class used to execute a `Status` command.
StopWalkException: Stops the driver loop of walker and finish with current results.
StoredConfig: Persistent configuration that can be stored and loaded from a location.
StoredObjectRepresentation: An object representation `PackWriter` can consider for packing.
StoredObjectRepresentationNotAvailableException: A previously selected representation is no longer available.
StrategyOneSided: Trivial merge strategy to make the resulting tree exactly match an input.
StrategyRecursive: A three-way merge strategy performing a content-merge if necessary
StrategyResolve: A three-way merge strategy performing a content-merge if necessary
StrategySimpleTwoWayInCore: Merges two commits together in-memory, ignoring any working directory.
StreamCopyThread: Thread to copy from an input stream to an output stream.
Strings: Various `String` related utility methods, written mostly to avoid generation of new String objects (e.g.
StringUtils: Miscellaneous string comparison utility methods.
SubmoduleAddCommand: A class used to execute a submodule add command.
SubmoduleInitCommand: A class used to execute a submodule init command.
SubmoduleStatus: Status class containing the type, path, and commit id of the submodule.
SubmoduleStatusCommand: A class used to execute a submodule status command.
SubmoduleStatusType: Enumeration of different statuses that a submodule can be in
SubmoduleSyncCommand: A class used to execute a submodule sync command.
SubmoduleUpdateCommand: A class used to execute a submodule update command.
SubmoduleWalk: Walker that visits all submodule entries found in a tree
SubmoduleWalk.IgnoreSubmoduleMode: The values for the config param submodule.<name>.ignore
Subsequence<S extends Sequence>: Wraps a `Sequence` to have a narrower range of elements.
SubsequenceComparator<S extends Sequence>: Wrap another comparator for use with `Subsequence`.
SubStringRevFilter: Abstract filter that searches text using only substring search.
SymbolicRef: A reference that indirectly points at another `Ref`.
SymlinksNotSupportedException: An exception thrown when a symlink entry is found and cannot be handled.
SymlinkTreeEntry: Deprecated. To look up information about a single path, use `TreeWalk.forPath(Repository, String, org.eclipse.jgit.revwalk.RevTree)`.
SystemReader: Interface to read values from the system.
TagBuilder: Mutable builder to construct an annotated tag recording a project state.
TagCommand: Create/update an annotated tag object or a simple unannotated tag
TagOpt: Specification of annotated tag behavior during fetch.
TcpTransport: The base class for transports based on TCP sockets.
TeeInputStream: Input stream that copies data read to another output stream.
TemporaryBuffer: A fully buffered output stream.
TemporaryBuffer.Heap: A temporary buffer that will never exceed its in-memory limit.
TemporaryBuffer.LocalFile: A fully buffered output stream using local disk storage for large data.
TextProgressMonitor: A simple progress reporter printing on a stream.
ThreadSafeProgressMonitor: Wrapper around the general `ProgressMonitor` to make it thread safe.
ThreeWayMerger: A merge of 2 trees, using a common base ancestor tree.
ThreeWayMergeStrategy: A merge strategy to merge 2 trees, using a common base ancestor tree.
ThrowingPrintWriter: An alternative PrintWriter that doesn't catch exceptions.
TimeoutInputStream: InputStream with a configurable timeout.
TimeoutOutputStream: OutputStream with a configurable timeout.
TooLargeObjectInPackException: Thrown when PackParser finds an object larger than a predefined limit
TooLargePackException: Thrown when a pack exceeds a given size limit
TrackingRefUpdate: Update of a locally stored tracking branch.
TrailingAsteriskMatcher: Matcher for simple patterns ending with an asterisk, e.g.
TransferConfig: The standard "transfer", "fetch", "receive", and "uploadpack" configuration parameters.
TranslationBundle: Base class for all translation bundles that provides injection of translated texts into public String fields.
TranslationBundleException: Common base class for all translation bundle related exceptions.
TranslationBundleLoadingException: This exception will be thrown when a translation bundle loading fails.
TranslationStringMissingException: This exception will be thrown when a translation string for a translation bundle and locale is missing.
Transport: Connects two Git repositories together and copies objects between them.
Transport.Operation: Type of operation a Transport is being opened for.
TransportAmazonS3: Transport over the non-Git aware Amazon S3 protocol.
TransportBundle: Marker interface for transports that supports fetching from a git bundle (sneaker-net object transport).
TransportBundleStream: Single shot fetch from a streamed Git bundle.
TransportCommand<C extends GitCommand,​T>: Base class for commands that use a `Transport` during execution.
TransportConfigCallback: Receives a callback allowing type-specific configuration to be set on the Transport instance after it's been created.
TransportException: Exception thrown when transport operation failed
TransportException: Indicates a protocol error has occurred while fetching/pushing objects.
TransportGitSsh: Transport through an SSH tunnel.
TransportHttp: Transport over HTTP and FTP protocols.
TransportProtocol: Describes a way to connect to another Git repository.
TransportProtocol.URIishField: Fields within a `URIish` that a transport uses.
TransportSftp: Transport over the non-Git aware SFTP (SSH based FTP) protocol.
Tree: Deprecated. To look up information about a single path, use `TreeWalk.forPath(Repository, String, org.eclipse.jgit.revwalk.RevTree)`.
TreeEntry: Deprecated. To look up information about a single path, use `TreeWalk.forPath(Repository, String, org.eclipse.jgit.revwalk.RevTree)`.
TreeFilter: Selects interesting tree entries during walking.
TreeFilterMarker: For testing an array of `TreeFilter` during a `TreeWalk` for each entry and returning the result as a bitmask.
TreeFormatter: Mutable formatter to construct a single tree object.
TreeRevFilter: Filter applying a `TreeFilter` against changed paths in each commit.
TreeWalk: Walks one or more `AbstractTreeIterator`s in parallel.
UnionInputStream: An InputStream which reads from one or more InputStreams.
UnmergedPathException: Indicates one or more paths in a DirCache have non-zero stages present.
UnmergedPathsException: Thrown when branch deletion fails due to unmerged data
UnpackedObject: Loose object loader.
UnpackException: Indicates a ReceivePack failure while scanning the pack stream.
UnsupportedCredentialItem: An exception thrown when a `CredentialItem` is requested from a `CredentialsProvider` which is not supported by this provider.
UploadPack: Implements the server side of a fetch connection, transmitting objects.
UploadPack.AdvertisedRequestValidator: Validator corresponding to `UploadPack.RequestPolicy.ADVERTISED`.
UploadPack.AnyRequestValidator: Validator corresponding to `UploadPack.RequestPolicy.ANY`.
UploadPack.FirstLine: Data in the first line of a request, the line itself plus options.
UploadPack.ReachableCommitRequestValidator: Validator corresponding to `UploadPack.RequestPolicy.REACHABLE_COMMIT`.
UploadPack.ReachableCommitTipRequestValidator: Validator corresponding to `UploadPack.RequestPolicy.REACHABLE_COMMIT_TIP`.
UploadPack.RequestPolicy: Policy the server uses to validate client requests
UploadPack.RequestValidator: Validator for client requests.
UploadPack.TipRequestValidator: Validator corresponding to `UploadPack.RequestPolicy.TIP`.
UploadPackFactory<C>: Create and configure `UploadPack` service instance.
UploadPackInternalServerErrorException: UploadPack has already reported an error to the client.
UploadPackLogger: Logs activity that occurred within `UploadPack`.
UploadPackLoggerChain: `UploadPackLogger` that delegates to a list of other loggers.
UploadPackMayNotContinueException: Deprecated. use `ServiceMayNotContinueException` instead.
URIish: This URI like construct used for referencing Git archives over the net, as well as locally stored archives.
UserConfig: The standard "user" configuration parameters.
UsernamePasswordCredentialsProvider: Simple `CredentialsProvider` that always uses the same information.
WalkTransport: Marker interface for an object transport walking transport.
WildCardMatcher: Matcher built from path segments containing wildcards.
WildMatcher: Wildmatch matcher for "double star" (`**`) pattern only.
WindowCache: Caches slices of a `PackFile` in memory for faster read access.
WindowCacheConfig: Configuration parameters for JVM-wide buffer cache used by JGit.
WorkingTreeIterator: Walks a working directory tree as part of a `TreeWalk`.
WorkingTreeIterator.Entry: A single entry within a working directory tree.
WorkingTreeIterator.MetadataDiff: The result of a metadata-comparison between the current entry and a `DirCacheEntry`
WorkingTreeOptions: Options used by the `WorkingTreeIterator`.
WrongRepositoryStateException: Exception thrown when the state of the repository doesn't allow the execution of a certain command.