All Classes and Interfaces

Class
Description
A prefix abbreviation of an LongObjectId.
A prefix abbreviation of an ObjectId.
Exception thrown when a hook returns a process result with a value different from 0.
Implementation of AdvertiseRefsHook that advertises the same refs for upload-pack and receive-pack.
Abstract base class for AuthenticationHandlers encapsulating basic common things.
Basic common functionality for a StatefulProxyConnector.
 
 
Base class for default methods as AbstractMatcher.toString() and such.
Basic commit graph renderer for graphical user interfaces.
 
 
Walks a Git tree (directory) in Git sort order.
Custom argument handler AbstractTreeIterator from string values.
A single request made through AppServer.
 
A class used to execute a Add command.
Add object notes.
A RevFilter that adds the visited commits to bitmap as a side effect.
A RevFilter that adds the visited commits to bitmap as a side effect.
A RevFilter that adds the visited commits to bitmap as a side effect.
Hook to allow callers to take over advertising refs to the client.
AdvertiseRefsHook that delegates to a list of other hooks.
A simple HTTP REST client for the Amazon S3 service.
KeyInfo enables sorting of keys by lastModified time
Property names used in amazon connection configuration file.
 
An AbbreviatedObjectId cannot be extended.
Includes a commit only if all subfilters include the same commit.
 
 
Includes a tree entry only if all subfilters include the same tree entry.
 
 
A (possibly mutable) SHA-256 abstraction.
A (possibly mutable) SHA-1 abstraction.
Apply a patch to files and/or to the index.
A wrapper for returning both the applied tree ID and the applied files list, as well as file specific errors.
A wrapper for a patch applying error that affects a given file.
Encapsulates the result of a ApplyCommand
Tiny web application server for unit testing.
 
 
Create an archive of files from a named tree.
Archival format.
 
Signals an attempt to use an archival format that ArchiveCommand doesn't know about (for example due to a typo).
Registers all format types from the org.eclipse.jgit.archive package for use via the ArchiveCommand API.
Translation bundle for archivers
 
Controls access to bare files in a repository.
 
Assertion class
Queue to open objects asynchronously.
Queue to examine object sizes asynchronously.
Asynchronous operation handle.
Queue to lookup and parse objects asynchronously.
Output stream writing content to a LockFile which is committed on close().
Represents an attribute.
The attribute value state see also https://www.kernel.org/pub/software/scm/git/docs/gitattributes.html
Represents a set of attributes for a path
The attributes handler knows how to retrieve, parse and merge attributes from the various gitattributes files.
Represents a bundle of attributes inherited from a base directory.
An interface used to retrieve the global and info AttributesNodes.
Interface for classes which provide git attributes
A single attributes rule corresponding to one line in a .gitattributes file.
An exception to report that the user canceled the SSH authentication.
A simple representation of an authentication challenge as sent in a "WWW-Authenticate" or "Proxy-Authenticate" header.
An AuthenticationHandler encapsulates a possibly multi-step authentication protocol.
Matches only commits whose author name matches the pattern.
 
 
An InputStream that expands LF to CRLF.
An OutputStream that expands LF to CRLF.
An InputStream that normalizes CRLF to LF.
A special exception thrown when AutoLFInputStream is told to throw an exception when attempting to read a binary file.
Flags for controlling auto-detection of binary vs.
An OutputStream that reduces CRLF to LF.
Basic network prompt for username/password when using AWT.
Interacts with the user during authentication by using AWT/Swing dialogs.
 
Encodes and decodes to and from Base64 notation.
Base helper class for implementing operations connections.
Generic update/editing support for DirCache.
Base helper class for fetch connection implementations.
Base format class
Base implementation of the PackBitmapIndex.
Data representation of the bitmap entry restored from a pack index.
 
Base helper class for pack-based operations implementations.
Fetch implementation using the native Git pack transfer service.
 
 
 
Push implementation using the native Git pack transfer service.
 
Base builder to customize repository construction.
 
 
An abstract implementation of a username-password authentication.
ProgressMonitor that batches update events.
 
Batch of reference updates to be applied to a repository.
Externalized text messages for localization.
Describes the DfsPackFile just before its index is loaded.
 
 
BinaryBlobException is used to signal that binary data was found in a context that requires text (eg.
Recreate a stream from a base stream and a GIT pack delta.
Part of a "GIT binary patch" to describe the pre-image or post-image
Type of information stored in a binary hunk.
A commit object for which a bitmap index should be built.
Builder of BitmapCommit.
A compressed bitmap representation of the entire object graph.
A bitmap representation of ObjectIds that can be iterated to return the underlying ObjectIds or operated on with other Bitmaps.
A builder for a bitmap.
A compressed bitmap representation of the entire object graph.
 
 
Wrapper for a EWAHCompressedBitmap and PackBitmapIndex.
 
 
 
Base object type accessed during bitmap expansion.
Checks if all objects are reachable from certain starting points using bitmaps.
Checks the reachability using bitmaps.
This filter emits commits that were not bitmap-reachable from anything visited before.
Helper class to do ObjectWalks with pack index bitmaps.
Filter that excludes objects already in the given bitmap.
A random access BitSet to supports efficient conversions to EWAHCompressedBitmap.
 
Blame command for building a BlameResult for a file path.
Generate author information for lines based on a provided file.
Collects line annotations for inspection by applications.
Configuration file based on the blobs stored in the repository.
Verifies that a blob object is a valid object.
Block based file stored in DfsBlockCache.
A supplier of readable channel that opens the channel lazily.
Random access list that allocates entries in blocks.
 
 
 
Reads a single block for ReftableReader.
 
 
 
Thrown if ReftableWriter cannot fit a reference.
Provides content blocks of file.
Formats and writes blocks for ReftableWriter.
 
 
 
 
 
 
Container which holds a BouncyCastleGpgKey.getSecretKey() together with the path it was loaded from.
Locates GPG keys from either ~/.gnupg/private-keys-v1.d or ~/.gnupg/secring.gpg
Thrown if a keybox file exists but doesn't contain an OpenPGP key.
Prompts for a passphrase and caches it until cleared.
A GpgSignatureVerifier to verify GPG signatures using BouncyCastle.
 
A GpgSignatureVerifierFactory that creates GpgSignatureVerifier instances that verify GPG signatures using BouncyCastle and that do cache public keys.
GPG Signer using the BouncyCastle library.
Factory for creating a GpgSigner based on Bouncy Castle.
 
 
Branch section of a Git configuration file.
Config values for branch.[name].rebase (and pull.rebase).
Status of a branch's relation to its remote-tracking branch.
Implementation of LfsFactory, using built-in (optional) LFS support.
Fetch connection for bundle based classes.
Creates a Git bundle file, for sneaker-net transport to another system.
Specialized set for byte arrays, interpreted as strings for use in PathFilterGroup.Group.
An incremental hash function.
A ByteWindow with an underlying byte array for storage.
A window for accessing git packs using a ByteBuffer for storage.
A window of data currently stored within a cache.
Abstract authenticator which remembers prior authentications.
Authentication data to remember and reuse.
The cached instance of an ObjectDirectory.
 
Describes a pack file ObjectReuseAsIs can append onto a stream.
Provider of URIs corresponding to cached packs.
Information about a packfile.
A FileKeyPairProvider that uses an external KeyCache.
Exception thrown when an operation was canceled
Thrown when an operation was canceled
A source that may have supplied some (or all) of the result file.
Candidate loaded from a file source, and not a commit.
A Candidate to blame a working tree file in conflict state.
Special candidate type used for reverse blame.
Thrown when trying to delete a branch which is currently checked out
Parses raw Git trees from the canonical semi-text/semi-binary format.
Capabilities protocol v2 request.
A builder for CapabilitiesV2Request.
A credentials provider chaining multiple credentials providers
Utilities for creating and working with Change-Id's, like the one used by Gerrit Code Review.
A WorkingTreeModifiedListener that can be used in tests to check expected events.
 
An object that can be used to check out many files.
 
Checkout a branch to the working tree.
Stage to check out, see CheckoutCommand.setStage(Stage).
Exception thrown when a command can't succeed because of unresolved conflicts.
Exception thrown if a conflict occurs during a merge checkout.
Parsed information about a checkout.
Parsed information about a checkout.
Encapsulates the result of a CheckoutCommand
The status
A class used to execute a cherry-pick command.
Encapsulates the result of a CherryPickCommand.
The cherry-pick status
 
Remove untracked files from the working tree
Built-in LFS clean filter When new content is about to be added to the git repository and this filter is configured for that content, then this filter will replace the original content with content of a so-called LFS pointer file.
Parses Git client User-Agent strings.
 
 
 
Translation bundle for JGit command line interface
Formats text strings using Localizable.
 
Clone a repository into a new working directory
Callback for status of clone operation.
 
Extended command line parser which handles --foo=value arguments.
A file in the Git "diff --cc" or "diff --combined" format.
Hunk header for a hunk appearing in a "diff --cc" style patch.
 
Annotation to document a TextBuiltin.
List of all commands known by jgit's command line tools.
Thrown when an external command failed
Description of a command (a TextBuiltin subclass).
 
Mutable builder to construct a commit recording the state of a project.
A class used to execute a Commit command.
Draws a commit graph in a JTable.
 
 
 
The commit-msg hook implementation.
Matches only commits whose committer name matches the pattern.
 
 
Selects commits based upon the commit time field.
 
 
 
An exception detailing multiple reasons for failure.
Exception thrown when a command wants to update a ref but failed because another process is accessing (or even also updating) the ref.
Git style .config, .gitconfig, .gitmodules file.
 
Converts enumeration values into configuration options and vice-versa, allowing to match a config option with an enum value.
Parses a section of the configuration into an application model object.
 
Describes a change to one or more keys in the configuration.
Constants for use with the Configuration classes: section names, configuration keys
Indicates a text string is not a valid Git style configuration.
A line in a Git Config file.
 
 
 
 
Represent connection for operation on a remote repository.
Checks that a received pack only depends on objects which are reachable from a defined set of references.
POJO which is used to pass all information which is needed to perform connectivity check.
Basic network prompt for username/password when using the console.
Interacts with the user during authentication by using the text console.
Misc.
Misc.
Supplies the content of a file for DiffFormatter.
 
A pair of sources to access the old and new sides of a DiffEntry.
 
 
This class keeps git repository core parameters.
Permissible values for core.autocrlf.
Permissible values for core.checkstat.
Permissible values for core.eol.
EOL stream conversion protocol.
Options for hiding files whose names start with a period.
Permissible values for core.logAllRefUpdates.
Options for symlink handling
Thrown when an object id is given that doesn't match the hash of the object's content
Thrown when a LFS mediafile is found which doesn't have the expected size
Exception thrown when an object cannot be read from Git.
Exception thrown when encounters a corrupt pack index file.
The error type of a corrupt index file.
Counts the number of bytes written.
Used to create a local branch.
The modes available for setting up the upstream configuration (corresponding to the --set-upstream, --track, --no-track options
A credential requested from a CredentialsProvider.
An item whose value is stored as a char[] and is therefore clearable.
An advice message presented to the user, with no response required.
Prompt for a password, which is masked on input.
An item whose value is stored as a string.
Prompt for a username, which is not masked on input.
An item whose value is a boolean choice, presented as Yes/No.
Provide credentials for use in connecting to Git repositories.
A JSch UserInfo adapter for a CredentialsProvider.
 
Basic daemon for the anonymous git:// transport protocol.
Active network client of Daemon.
A service exposed by Daemon over anonymous git://.
 
A queue of commits sorted by commit time order.
 
Default implementation of the NoteMerger.
A default implementation of a ProxyDataFactory based on the standard ProxySelector.
Create and configure ReceivePack service instance.
 
An TypedConfigGetter that throws IllegalArgumentException on invalid values.
Create and configure UploadPack service instance.
 
Delays commits to be at least PendingGenerator.OVER_SCAN late.
An SSLSocketFactory that delegates to another factory and allows configuring the created socket via DelegatingSSLSocketFactory.configure(SSLSocket) before it is returned.
Used to delete one or several branches.
Used to delete one or several tags.
Caches recently used objects for DfsReader.
 
 
 
 
 
 
Encodes an instruction stream for BinaryDelta.
Index of blocks in a source file.
Supports DeltaIndex by performing a partial scan of the content.
 
 
 
 
 
 
 
 
Only produce commits which are below a specified depth.
Interface for revision walkers that perform depth filtering.
RevCommit with a depth (in commits) from a root.
Subclass of ObjectWalk that performs depth filtering.
Subclass of RevWalk that performs depth filtering.
 
Given a commit, show the most recent tag that is reachable from a commit.
Exception thrown when a command expected a non-detached HEAD reference
A cached slice of a BlockBasedFile.
Caches slices of a BlockBasedFile in memory for faster read access.
 
Supplier for readable channel
 
 
Configuration parameters for DfsBlockCache.
Writes DfsRepository to a Git bundle.
A DfsPackFile available for reuse as-is.
Config implementation used by DFS repositories.
Verify the validity and connectivity of a DFS repository.
Repack and garbage collect a repository.
Inserts objects into the DFS.
Manages objects stored in DfsPackFile on a storage system.
Snapshot of packs scanned in a single pass.
 
Sources for a pack file.
Builder for describing DfsObjDatabase.PackSource ordering where some values are explicitly considered equal to others.
 
 
Output stream to create a file on the DFS.
Combine several pack files into one pack.
 
Description of a DFS stored pack/index file.
A Git version 2 pack file representation.
 
Parses a pack stream into the DFS, by creating a new pack and index.
Describes a change to the list of packs in a DfsRepository.
Reader to access repository content through.
 
IO statistics for a DfsReader.
POJO to accumulate IO statistics.
Options controlling how objects are read from a DFS stored repository.
Abstract DfsRefDatabase class.
Collection of references managed by this database.
 
A reftable stored in DfsBlockCache.
 
A DfsRefDatabase that uses reftable for storage.
Tracks multiple open ReftableReader instances.
 
A Git repository on a DFS.
 
 
Constructs a DfsRepository.
A description of a Git repository on a DFS.
Key used by DfsBlockCache to disambiguate streams.
 
 
Translation bundle for the DFS storage implementation.
Indicates a TextBuiltin implementation has failed during execution.
 
Compares two Sequences to create an EditList of changes.
Supported diff algorithm
 
 
 
 
Show changes between commits, commit and working tree, etc.
Keeps track of diff related configuration options.
Permissible values for diff.renames.
A value class representing a change to a file
General type of change a single file-level patch describes.
Specify the old or new side for more generalized access.
Format a Git style patch script.
 
Thrown when a thread executing a diff is interrupted
 
Support for the Git dircache (aka index file).
 
 
Updates a DirCache by adding individual DirCacheEntrys.
Iterate and update a DirCache as part of a TreeWalk.
This class handles checking out one or two trees merging with the index.
Metadata used in checkout process
Updates a DirCache by supplying discrete edit commands.
Deletes a single file entry from the index.
Recursively deletes all paths under a subtree.
Any index record update.
A single file (or stage of a file) in a DirCache.
Iterate a DirCache as part of a TreeWalk.
AttributesNode implementation that provides lazy loading facilities.
Thrown by DirCache code when entries overlap in impossible way.
Single tree record from the 'TREE' DirCache extension.
An OutputStream which always throws IllegalStateExeption during write.
A modified region detected between two versions of roughly the same content.
Type of edit
Specialized list of Edits in a document.
Exception thrown when a newly created commit does not contain any changes
Empty LogCursor with no results.
A convenient base class which provides empty method bodies for all ProgressMonitor methods.
Iterator over an empty tree (a directory with no files).
 
Attempt to add an entry to a tree that already exists.
An output stream which is aware of newlines and can be asked to begin a new line if not already in one.
Utility used to create input and output stream wrappers for CoreConfig.EolStreamType
Send a fixed status code to the client.
A note tree holding only note subtrees, each named using a 2 digit hex name.
"Fast" (compared with IgnoreRule) git ignore rule implementation supporting also double star ** pattern.
 
A class used to execute a Fetch command.
Callback for status of fetch operation.
Lists known refs from the remote and copies objects of selected refs.
 
 
Common fields between v0/v1/v2 fetch requests.
Final status after a successful fetch from a remote repository.
Fetch request in the V0/V1 protocol.
 
Fetch request from git protocol v2.
A builder for FetchV2Request.
A queue of commits in FIFO order.
The configuration file that is stored in the file of the file system.
Patch header describing an action for a single file path.
Type of patch used by this file.
Repository storing large objects in the file system
Servlet supporting upload and download of large objects as defined by the GitHub Large File Storage extension API extending git to allow separate storage of large files (https://github.com/github/git-lfs/tree/master/docs/api).
Constants describing various file modes recognized by GIT.
A hierarchical cache of FileModes per git path.
An item from a FileModeCache, recording information about a git path (known from context).
This class can be used to match filenames against fnmatch like patterns.
 
 
Implements RefDatabase using reftable for storage.
A mutable stack of reftables on local filesystem storage.
 
Thrown if the update indices in the stack are not monotonic
A segment is a consecutive list of reftables of the same approximate size.
 
Writer is a callable that writes data to a reftable under construction.
Represents a Git repository.
Implementation a AttributesNodeProvider for a FileRepository.
Constructs a FileRepository.
Default resolver serving from the local filesystem.
Dumps a file over HTTP GET (or its information via HEAD).
Caches when a file was last read, making it possible to detect future edits.
Working directory iterator for standard Java IO.
A default implementation of a FileModeStrategy; defaults to treating nested .git directories as gitlinks, etc.
Wrapper for a standard Java IO file
An interface representing the methods used to determine the FileMode for a FileEntry.
A FileModeStrategy that implements native git's DIR_NO_GITLINKS behavior.
File Utilities
An abstraction for JGit's builtin implementations for hooks and filters.
The factory responsible for creating instances of FilterCommand.
Registry for built-in filters
Exception thrown when the execution of a filter command failed
Represents either a filter specified in a protocol "filter" line, or a placeholder to indicate no filtering.
Immutable bit-set representation of a set of Git object types.
In a push, the client sends a list of commands.
In the pack negotiation phase (protocol v0/v1), the client sends a list of wants.
Filters out commits marked RevWalk.UNINTERESTING.
Updates the internal path filter to follow copy/renames.
Case insensitive key for a FooterLine.
Single line at the end of a message, such as a "Signed-off-by: someone".
This activator registers all format types from the org.eclipse.jgit.archive package for use via the ArchiveCommand API.
An error in a patch script
Classification of an error.
Abstraction to support various file system operations not in Java.
Base FS for POSIX based systems
 
FS implementation for Windows
FS implementation for Cygwin on Windows
File attributes we typically care for.
Result of an executed process.
Attributes of FileStores on this system
This class creates FS instances.
 
 
A token representing a file created by FS.createNewFileAtomic(File).
This runnable will consume an input stream's content into an output stream as soon as it gets available.
Holds all fsck errors of a git repository.
Represents a corrupt pack index file.
Represents a corrupt object.
A read-only pack parser for object validity checking.
 
An interface providing FTP operations over a RemoteSession.
Simplified remote directory entry.
An Exception for reporting SFTP errors.
A connectivity checker that uses the entire reference database to perform reachability checks when checking the connectivity of objects.
A class used to execute a gc command.
 
A garbage collector for git FileRepository.
A class holding statistical data for a FileRepository regarding how many objects are stored as loose or packed objects
This class manages the gc.log file for a FileRepository.
Produces commits for RevWalk to return to applications.
Offers a "GitPorcelain"-like API to interact with a git repository.
Adds a file to the git index.
Superclass of all exceptions thrown by the API classes in org.eclipse.jgit.api
Checkout a branch or paths to the working tree.
Clone a repository into a new directory.
Common superclass of all commands in the package org.eclipse.jgit.api
A utility for formatting dates according to the Git log.date formats plus extensions.
Git and JGit formats
Parses strings with time and date specifications into Date.
 
Handles Git repository access over HTTP.
Git can fire off custom scripts when certain important actions occur.
Create an empty git repository.
A .gitmodules file found in the pack.
Wire constants for the native Git protocol.
 
Handles Git repository access over HTTP.
Utility functions for handling the Git-over-HTTP protocol.
Attribute node loaded from global system-wide file.
Global cache of translation bundles.
 
Typed access to GPG related configuration options.
Config values for gpg.format.
Creates GPG signatures for Git objects.
A structure for holding GPG signature together with additional related data.
A GpgVerifier can verify GPG signatures on git commits and tags.
A SignatureVerification returns data about a (positively or negatively) verified signature.
The owner's trust in a public key.
A GpgSignatureVerifierFactory creates GpgSignatureVerifier instances.
Creates GPG signatures for Git objects.
Special handler for the --gpg-sign option of the commit command.
 
 
 
 
 
 
 
 
 
 
An abstract implementation of a GSS-API multi-round authentication.
Global repository of GSS-API mechanisms that we can use.
GSSAPI-with-MIC authentication handler (Kerberos 5).
 
Factory to create GssApiWithMicAuthentication handlers.
Factory to detect which GSSManager implementation should be used.
DefaultGSSManagerFactory uses @link GSSManager.getInstance() but you might need to set javax.security.auth.useSubjectCredsOnly system property to false for authentication to work.
 
Wraps a Sequence to assign hash codes to elements.
Wrap another comparator for use with HashedSequence.
Wraps two Sequence instances to cache their element hash codes.
 
Encodes and decodes to and from hexadecimal notation.
An extended form of Bram Cohen's patience diff algorithm.
Support HistogramDiff by computing occurrence counts of elements.
The nonce generator which was first introduced to git-core.
Holder of an object.
Factory class for instantiating supported hooks.
Translation bundle for archivers
Support class to populate user authentication data on a connection.
Performs HTTP basic authentication (plaintext username/password).
Performs HTTP digest authentication.
 
Performs no user authentication.
Enum listing the http authentication method types supported by jgit.
A HttpConnection which uses HttpClient
A factory returning instances of HttpClientConnection.
 
Simple HTTP proxy connector using Basic Authentication.
 
A representation of the "http.*" config values in a git Config.
Config values for http.followRedirect.
The interface of connections used during HTTP communication.
The interface of a factory returning HttpConnection
A HttpConnectionFactory that supports client-side sessions that can maintain state and configure connections.
A GitSession groups the multiple HTTP connections TransportHttp uses for the requests it makes during a git fetch or push.
A basic parser for HTTP response headers.
An exception indicating some problem parsing HTPP headers.
Translation bundle for JGit http server
Extra utilities to support usage of HTTP.
Base class for HTTP related transport testing.
The base class for transports that use HTTP as underlying protocol.
Hunk header describing the layout of a single block of lines
Details about an old image of the file.
A simple state object for repeated attempts to get a password for a resource.
Represents a bundle of ignore rules inherited from a base directory.
Attempt to modify a rebase-todo file in an unsupported way
Generic path matcher.
An inconsistency with respect to handling different object types.
Describes a change to one or more paths in the index file.
Compares the index, a tree, and the working directory Ignored files are not taken into account.
 
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).
A factory to producing WorkingTreeIterators
A performance optimized variant of TreeFilter.ANY_DIFF which should be used when among the walked trees there is a DirCacheIterator and a WorkingTreeIterator.
 
Cannot read the index.
Cannot write a modified index.
Creates zlib based inflaters as necessary for object decompression.
A wrapper around the EWAHCompressedBitmap optimized for the contains operation.
Attribute node loaded from the $GIT_DIR/info/attributes file.
Sends the current list of pack files, sorted most recent first.
Send a complete list of current refs, including peeled values for tags.
 
Create an empty git repository or reinitalize an existing one
A note bucket that has been loaded into the process.
Git repository stored entirely in the local process memory.
Builder for in-memory repositories.
 
DfsObjDatabase used by InMemoryRepository.
 
 
DO NOT USE Factory to create any cipher.
Installs all required LFS properties for the current user, analogous to 'git lfs install', but defaulting to using JGit builtin hooks.
Specialized comparator for Instants.
A filter for extracting changes between two versions of the dircache.
 
Internal API to assist org.eclipse.jgit.http.server.
 
Triggers an interrupt on the calling thread if it doesn't complete a block.
 
 
 
A more efficient List<Integer> using a primitive integer array.
 
Exception thrown when a command fails due to an invalid configuration
Thrown when an invalid long object id is passed in as an argument.
Exception thrown when a merge command was called without specifying the proper amount/type of merge heads.
Thrown when an invalid object id is passed in as an argument.
Thrown when JGit detects and refuses to use an invalid path
Thrown when a pattern passed in an argument was wrong.
Exception thrown if a rebase step is invalid.
Exception thrown when an invalid Ref name was encountered
Exception thrown when a fetch command was called with an invalid remote
Exception thrown when a tag command was called with an invalid tag name (or null), such as bad~tag.
Input/Output utilities
Requires the target Repository to be available via local filesystem.
OutputStream isolated from interrupts.
 
Implementation of connectivity checker which tries to do check with smaller set of references first and if it fails will fall back to check against all advertised references.
A HttpConnection which simply delegates every call to a HttpURLConnection.
A factory returning instances of JDKHttpConnection
 
A ClientSession that can be associated with the HostConfigEntry the session was created for.
An AttributeRepository that chains together two other attribute sources in a hierarchy.
A JGitClientSession.ChainingAttributes repository that doubles as a PropertyResolver.
A HostConfigEntry that provides access to the multi-valued keys as lists of strings.
Exception thrown when during command execution a low-level exception from the JGit library is thrown.
A simple KeyCache.
A password authentication handler that uses the JGitUserInteraction to ask the user for the password.
A customized UserAuthPasswordFactory that creates instance of JGitPasswordAuthentication.
A bridge between the ServerKeyVerifier from Apache MINA sshd and our ServerKeyDatabase.
 
Customized SshClient for JGit.
A KeyIdentityProvider that iterates over the Iterables returned by other KeyIdentityProviders.
A SessionFactory to create our own specialized JGitClientSessions.
A bridge between a JGit SshConfigStore and the Apache MINA sshd HostConfigEntryResolver.
Abstract test util class
 
Translation bundle for JGit core
A UserInteraction callback implementation based on a CredentialsProvider.
A SessionListener that removes itself from the session when authentication is done or the session is closed.
The base session factory that loads known hosts and private keys from $HOME/.ssh.
 
A ConfigRepository.Config that transforms some values from the config file into the format Jsch 0.1.54 expects.
Run remote commands using Jsch.
Externalized text messages for localization.
A cache for KeyPairs.
Utilities to compute the keygrip of a key.
A KeyPasswordProvider provides passwords for encrypted private keys.
Apache MINA sshd 2.0.0 KnownHostEntry cannot read a host entry line like "host:port ssh-rsa "; it complains about an illegal character in the host name (correct would be "[host]:port").
Abstraction of a repository for storing large objects
An object is too big to load into memory as a single byte array.
Object size exceeds JVM limit of 2 GiB per byte array.
Object size exceeds the caller's upper limit.
An error caused by the JVM being out of heap space.
 
 
 
Lazily loads a set of ObjectIds, one per line.
 
Matcher for simple regex patterns starting with an asterisk, e.g.
A note tree holding only notes, with no subtrees.
Class which represents the lfs folder hierarchy inside a .git folder
Thrown when the bandwidth limit for the user or repository has been exceeded.
Provides transparently either a stream to the blob or a LFS media file if managed by LFS.
An ObjectLoader implementation that reads a media file from the LFS storage.
Thrown when a LFS configuration problem has been detected (i.e.
Provides means to get a valid LFS connection for a given repository.
 
Thrown when an error occurs during LFS operation.
Represents an optionally present LFS support implementation
Encapsulate a potentially exchanged InputStream along with the expected stream content length.
A command to enable LFS.
Wrapper for Gson used by LFS servlets.
Wrapper class only used for serialization of error messages.
Thrown when there is insufficient storage on the server.
LFS object.
Represents an LFS pointer file
Detects Large File pointers, as described in [1] in Git repository.
Pre-push hook that handles uploading LFS artefacts.
LFS protocol handler implementing the LFS batch API [1] [1] https://github.com/github/git-lfs/blob/master/docs/api/v1/http-v1-batch.md
LFS request.
Thrown when the user has hit a rate limit with the server.
Thrown when the repository does not exist for the user.
Thrown when the user has read, but not write access.
Translation bundle for JGit LFS server
 
Tiny web application server for testing
 
 
Translation bundle for JGit LFS server
Thrown when authorization was refused for an LFS operation.
Thrown when LFS is not available.
Thrown when there is a validation error with one or more of the objects in the request.
A queue of commits in LIFO order.
Wraps a InputStream, limiting the number of bytes which can be read.
Used to obtain a list of branches.
The modes available for listing branches (corresponding to the -r and -a options)
Tracks a previously registered RepositoryListener.
Manages a thread-safe list of RepositoryListeners.
List object notes.
Used to obtain a list of tags.
 
JUnit TestCase with specialized support for temporary local repository.
 
 
 
An exception occurring when a file cannot be locked
Git style file locking and replacement.
 
A class used to execute a Log command.
Iterator over logs inside a Reftable.
A more efficient List<Long> using a primitive long array.
Simple Map<long, Object>.
 
A SHA-256 abstraction.
 
Traditional file system based loose objects handler.
Compares two sequences primarily based upon hash codes.
Map with only up to n entries.
 
ls-refs protocol v2 request.
A builder for LsRefsV2Request.
 
The ls-remote command
 
Command line entry point.
Parser for subcommands which doesn't stop parsing on help options and so proceeds all specified options
 
Repo XML manifest parser.
A callback to read included xml files.
 
Limits the number of commits output.
 
Provides the merge algorithm which does a three-way merge on content provided as RawText.
 
Computes the merge base(s) of the starting commits.
 
One chunk from a merge result.
A state telling whether a MergeChunk belongs to a conflict or not.
A class used to execute a Merge command.
The modes available for fast forward merges corresponding to the --ff, --no-ff and --ff-only options under branch.<name>.mergeoptions.
The modes available for fast forward merges corresponding to the options under merge.ff.
Holds configuration for merging into a given branch
 
Merges multiple reference tables together.
 
 
A class to convert merge results into a Git conformant textual presentation
 
Formatter for constructing the commit message for a merge commit.
Instance of a specific MergeStrategy for a single Repository.
Encapsulates the result of a MergeCommand.
The result of merging a number of Sequence objects.
The status the merge resulted in.
A method of combining two or more trees together to form an output tree.
Matches only commits whose message matches the pattern.
 
 
Combines messages from an OutputStream (hopefully in UTF-8) and a Writer.
Generic container filter to manage routing to different pipelines.
Generic container servlet to manage routing to different pipelines.
Indicates a base/common object was required, but is not found.
An expected object is missing.
Mock ServletConfig
Mock SystemReader for tests.
 
Enables monitoring JGit via JMX
A provider of time.
Fake MonotonicClock for testing code that uses Clock.
A MonotonicClock based on System.currentTimeMillis.
The commit to be cherry-pick'ed did not have exactly one parent
A boxed integer that can be modified.
A mutable SHA-256 abstraction.
A mutable SHA-1 abstraction.
Diff algorithm, based on "An O(ND) Difference Algorithm and its Variations", by Eugene Myers.
Specialized TreeWalk to detect directory-file (D/F) name conflicts.
Matcher built from patterns for file names (single path segments).
Command to find human-readable names of revisions.
 
Conversion utilities for network byte order handling.
NetRC file parser.
.netrc file entry
 
Simple .netrc credentials provider.
Wraps all cookies persisted in a Netscape Cookie File Format being referenced via the git config http.cookieFile.
A cache of all known cookie files (NetscapeCookieFile).
The purpose of this class is to provide NLS (National Language Support) configurable per thread.
Add HTTP response headers to prevent caching by proxies/browsers.
A X509TrustManager that doesn't verify anything.
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.
Exception thrown when the options given to a command don't include a file pattern which is mandatory for processing.
Exception thrown when a command expected the HEAD reference to exist but couldn't find such a reference
Exception thrown if a merge fails because no merge base could be determined.
An enum listing the different reason why no merge base could be determined.
Exception thrown when the options given to a command don't include a specification of a message text (e.g.
A NonceGenerator is used to create a nonce to be sent out to the pusher who will sign the nonce to prove it is not a replay attack on the push certificate.
A tree entry found in a note branch that isn't a valid note.
JGit's replacement for the javax.annotation.Nonnull.
Thrown when a Pack is found not to contain the pack signature defined by git.
 
Indicates a remote repository does not exist.
In-memory representation of a single note attached to one object.
A tree that stores note objects.
Index of notes from a note branch.
Three-way note tree merge.
Three-way note merge operation.
Custom tree parser to select note bucket type and load it.
This exception will be thrown from the NoteMerger when a conflict on Notes content is found during merge.
Skip WorkingTreeIterator entries that appear in gitignore files.
Thrown when branch deletion fails due to unmerged data
Includes a commit only if the subfilter does not include the commit.
JGit encountered a case that it knows it cannot yet handle.
Includes an entry only if the subfilter does not include the entry.
Indicates a Repository has no working directory, and is thus bare.
Marks types that can hold the value null at run time.
An OutputStream which ignores everything written to it.
A NullProgressMonitor does not report progress anywhere.
Common base class for CommitBuilder and TagBuilder.
Verifies that an object is formatted correctly.
Potential issues identified by the checker.
A callback to tell caller the count of objects ASAP.
Abstraction of arbitrary object storage.
Traditional file system based ObjectDatabase.
 
 
 
Creates loose objects in a ObjectDirectory.
 
Consumes a pack stream and stores as a pack file in ObjectDirectory.
Handle asynchronous large object download.
Sends any object from GIT_DIR/objects/??/0 38, or any pack file.
 
 
 
 
Selects interesting objects when walking.
 
A SHA-1 abstraction.
Custom argument handler ObjectId from string values.
Fast, efficient map for ObjectId subclasses in only one map.
Type of entry stored in the ObjectIdOwnerMap.
A Ref that points directly at an ObjectId.
A reference to a non-tag object coming from a cached source.
An annotated tag whose peeled object has been cached.
Any reference whose peeled value is not yet known.
Helper to serialize ObjectId instances.
Simple set of ObjectIds.
Fast, efficient map specifically for ObjectId subclasses.
Inserts objects into an existing ObjectDatabase.
Wraps a delegate ObjectInserter.
An inserter that can be used for formatting and id generation only.
Base class for a set of loaders for different representations of Git objects.
Wraps a delegate ObjectLoader.
Simple loader around the cached byte array.
Checks if all objects are reachable from certain starting points.
Reads an ObjectDatabase for a single thread.
Wraps a delegate ObjectReader.
Extension of ObjectReader that supports reusing objects in packs.
Stream of data coming from an object loaded by ObjectLoader.
Simple filter stream around another stream.
Simple stream around the cached byte array created by a loader.
Per-object state used by PackWriter.
Handle asynchronous object upload.
Callback invoked after object upload completed.
Specialized subclass of RevWalk to include trees, blobs and tags.
 
When walking over a tree and blob graph, objects are usually marked as seen as they are visited and this "seen" status is checked upon the next visit.
Cannot store an object in the object database.
A PBEProtectionRemoverFactory using AES/OCB/NoPadding for decryption.
Fairly complete configuration parser for the OpenSSH ~/.ssh/config file.
Configuration of one "Host" block in the configuration file.
Fairly complete configuration parser for the openssh ~/.ssh/config file.
A host entry from the ssh config file.
 
Encapsulates entries read out of the configuration file, and a cache of fully resolved entries created from that.
A sever host key verifier that honors the StrictHostKeyChecking and UserKnownHostsFile values from the ssh configuration.
 
 
 
 
 
Class holding result of operation on remote repository.
Handler which allows to parse option with few values
Includes a commit if any subfilters include the same commit.
 
 
Includes a tree entry if any subfilters include the same tree entry.
 
 
A Git version 2 pack file representation.
 
Logical representation of the bitmap data stored in the pack index.
Helper for constructing PackBitmapIndexes.
 
Data object for the on disk representation of a bitmap entry.
A PackBitmapIndex that remaps the bitmaps in the previous index to the positions in the new pack index.
An entry in the old PackBitmapIndex.
Support for the pack bitmap index v1 format.
Creates the version 1 pack bitmap index files.
Configuration used by a pack writer when constructing the stream.
Traditional file system packed objects directory handler.
 
Implementation of BatchRefUpdate that uses the packed-refs file to support atomically updating multiple refs.
Description of an object stored in a pack file, including offset.
Read Git style pkt-line formatting from an input stream.
 
IOException thrown by read when the configured input limit is exceeded.
Iterator over packet lines.
Write Git style pkt-line formatting to an output stream.
A pack file extension.
A pack file (or pack related) File.
 
Access path to locate objects by ObjectId in a Pack.
Represent mutable entry of pack index consisting of object id and offset in pack (both mutable).
 
Support for the pack index v2 format.
Creates a table of contents to support random access by Pack.
Creates the version 1 (old style) pack table of contents files.
Creates the version 2 pack table of contents files.
 
 
Object inserter that inserts one pack per call to PackInserter.flush(), and never inserts loose objects.
Thrown when a Pack previously failed and is known to be unusable
Keeps track of a Pack's associated .keep file.
Thrown when a Pack no longer matches the PackIndex.
Custom output stream to support PackWriter.
Parses a pack stream and imports it for an ObjectInserter.
 
 
Type and size information about an object in the database buffer.
Location data is being obtained from.
Information about an unresolved delta in this pack stream.
Indicates a protocol error has occurred while fetching/pushing objects.
Reverse index for forward pack index.
Statistics about PackWriter pack creation.
POJO for accumulating the statistics.
Statistics about a single type of object (commits, tags, trees and blobs).
POJO for accumulating the ObjectType statistics.
Marker interface an object transport using Git pack transfers.
PackWriter class is responsible for generating pack files from specified set of objects from repository.
A visitation policy which uses the depth at which the object is seen to decide if re-traversal is necessary.
Configuration related to the packfile URI feature.
Possible states that a PackWriter can be in.
Helper class for the PackWriter to select commits for which to build pack index bitmaps.
Container for state used in the first phase of selecting commits, which walks all of the reachable commits via the branch tips that are not covered by a previous pack's bitmaps (newWants) and stores them in newCommitsByOldest.
A RevFilter that excludes the commits named in a bitmap from the walk.
A bridge from sshd's FilePasswordProvider to our per-session KeyPasswordProvider API.
 
A parsed collection of FileHeaders from a unified diff patch file
Exception thrown when applying a patch fails
Exception thrown when applying a patch fails due to an invalid format
A DiffFormatter used to calculate the patch-id of the diff.
Includes tree entries only if they match the configured path.
Includes tree entries only if they match one or more configured paths.
 
 
Matcher built by patterns consists of multiple path segments.
Utility functions for paths inside of a Git repository.
Includes tree entries only if they end with the configured path (suffix match).
Create a TreeFilter to patch math names.
Abstract filter that searches text using extended regular expressions.
Checks if all objects are reachable from certain starting points doing a walk.
Checks the reachability walking the graph from the starters towards the target.
Default (and first pass) RevCommit Generator implementation for RevWalk.
Singleton that collects performance logs.
Class to register a performance log record.
A combination of a person identity and time in Git.
A commit reference to a commit in the DAG.
An ordered list of PlotCommit subclasses.
A line space within the graph.
Specialized RevWalk for visualization of a commit graph.
The post-commit hook implementation.
Hook invoked by ReceivePack after all updates are executed.
PostReceiveHook that delegates to a list of other hooks.
Hook invoked by UploadPack after the pack has been uploaded.
PostUploadHook that delegates to a list of other hooks.
The pre-commit hook implementation.
The pre-push hook implementation.
Hook invoked by ReceivePack before any updates are executed.
PreReceiveHook that delegates to a list of other hooks.
Hook invoked by UploadPack before during critical phases.
PreUploadHook that delegates to a list of other hooks.
Describes the result of running an external process.
Status of a process' execution.
A progress reporting interface.
A simple spinner connected to an OutputStream.
A timestamp generated by MonotonicClock.propose().
This interface describes the network protocol used between lfs client and lfs server
Describes in a Response a single action the client can execute on a single object
Describes an error to be returned by the LFS batch API
An action with an additional expiration timestamp
Describes in a response all actions the LFS server offers for a single object
MetaData of an LFS object.
A request sent to an LFS server
A response received from an LFS server
Parser for git protocol versions 0 and 1.
Hook to allow callers to be notified on Git protocol v2 requests.
ProtocolV2Hook that delegates to a list of other hooks.
Parse the incoming git protocol lines from the wire and translate them into a Request object.
A DTO encapsulating the data needed to connect through a proxy server.
Interface for obtaining ProxyData to connect through some proxy.
The Pull command
Encapsulates the result of a PullCommand
 
The required information to verify the push.
Verification result of the nonce returned during push.
Identity in a push certificate.
Parser for signed push certificates.
 
 
 
Storage for recorded push certificates.
 
A class used to execute a Push command.
Push section of a Git configuration file.
Config values for push.recurseSubmodules.
Lists known refs from the remote and sends objects to the remote.
Class performing push operation on remote repository.
Result of push operation to the remote repository.
Utility functions related to quoted string handling.
Quoting style used by the Bourne shell.
Bourne style, but permits ~user at the start of the string.
Quoting style that obeys the rules Git applies to file names
A rough character sequence around a raw byte buffer.
Utility class for character functions on raw bytes
Handy utility functions to parse raw object contents.
Searches text using only substring search.
A Sequence supporting UNIX formatted text in byte[] format.
Equivalence function for RawText.
Check if a commit is reachable from a collection of starting commits.
Readable random access byte channel from a file.
 
 
A class used to execute a Rebase command.
Allows configure rebase interactive process and modify commit message
The available operations
 
The result of a RebaseCommand execution
The overall status
Offers methods to read and write files formatted like the git-rebase-todo file
Describes a single line in a file formatted like the git-rebase-todo file.
Describes rebase actions
Recreates a repository from another one's commit graph.
 
A command being processed by ReceivePack.
Result of the update command.
Type of operation requested.
Exception handler for processing ReceiveCommand.
Statistics about PackParser.
A builder for ReceivedPackStatistics.
 
Implements the server side of a push connection, receiving objects.
Deprecated.
Use FirstCommand instead.
Configuration for receive operations.
Interface for reporting status messages.
Handle git-receive-pack errors.
Process a git-receive-pack request.
Create and configure ReceivePack service instance.
Server side implementation of smart push over HTTP.
 
 
Log warnings into an array for later inspection.
 
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
Pairing of a name and the ObjectId it currently has.
Location where a Ref is stored.
Support for the start of UploadPack and ReceivePack.
Advertiser which frames lines in a PacketLineOut format.
Thrown when trying to create a Ref with the same name as an existing one
Util for sorting (or comparing) Ref instances by name.
Iterator over references inside a Reftable.
Abstraction of name to ObjectId mapping.
Traditional file system based RefDatabase.
 
 
 
 
 
 
Rename any reference stored by RefDirectory.
Updates any reference stored by RefDirectory.
Utility methods for object references
Filters the list of refs that are advertised to the client.
Describes the expected value for a ref being pushed.
Specialized variant of an ArrayList to support a RefDatabase.
Builder to facilitate fast construction of an immutable RefList.
 
The reflog command
Parsed reflog entry
Parsed reflog entry
Utility for reading reflog entries
Utility for reading reflog entries
Utility for writing reflog entries using the traditional one-file-per-log format.
Specialized Map to present a RefDatabase namespace.
Thrown when a ref is not found in advertised refs
Thrown when a Ref can not be resolved
A RefUpdate combination for renaming a reference.
Describes a change to one or more references of a repository.
Receives RefsChangedEvents.
Describes how refs in one repository copy into another repository.
How strict to be about wildcards.
Custom argument handler RefSpec from string values.
An InMemoryRepository whose refs can be made unreadable for testing purposes.
Abstract table of references.
BatchRefUpdate for Reftable based RefDatabase.
Merges reftables and compacts them into a single output.
Configuration used by a reftable writer when constructing the stream.
 
Operations on MergedReftable that is common to various reftable-using subclasses of RefDatabase.
Wrapper to assist formatting a reftable to an OutputStream.
Reads a reftable formatted file.
Implement the ReflogReader interface for a reflog stored in reftable.
Writes a reftable formatted file.
 
Statistics about a written reftable.
Creates, updates or deletes any reference.
Status of an update request.
Handle the abstraction of storing a ref update.
Writes out refs to the Constants.INFO_REFS and Constants.PACKED_REFS files.
Switch servlet path and path info to use another regex match group.
Selects requests by matching the URI against a regular expression.
 
Region of the result that still needs to be computed.
Formatter to format timestamps relative to the current time using time units in the format defined by git log --relative-date.
 
Used to add a new remote.
A remembered remote repository, including URLs and RefSpecs.
Used to obtain the list of remotes.
Represent request and status of a remote ref update.
Represent current status of a remote ref update.
Used to remove an existing remote.
Contains a message from the remote repository indicating a problem.
An abstraction of a remote "session" for executing remote commands.
A RemoteSession that supports passing environment variables to commands.
Used to change the URL of a remote.
The available URI types for the remote.
Remove object notes.
Used to rename branches.
An instance of this class can be used in conjunction with a FollowFilter.
Detect and resolve object renames.
Annotation enabling to run tests repeatedly
TestRule which enables to run the same JUnit test repeatedly.
Exception thrown if repeated execution of a test annotated with @Repeat failed.
 
 
A class used to execute a repo command.
A default implementation of RepoCommand.RemoteReader callback.
 
Read-only view of contents and file mode (i.e.
A callback to get ref sha1 of a repository from its uri.
 
The representation of a repo sub project.
The representation of a copy file configuration.
The representation of a link file configuration.
The representation of a reference file configuration.
Represents a Git repository.
Base class to support constructing a Repository.
A factory for BaseRepositoryBuilders.
Cache of active Repository instances.
Location of a Repository, using the standard java.io.File API.
Abstract hash key for RepositoryCache entries.
 
Configuration parameters for JVM-wide repository cache used by JGit.
Describes a modification made to a repository.
Open a repository named by the path info through RepositoryResolver.
A listener can register for event delivery.
Indicates a local repository does not exist.
Locate a Git Repository by name from the URL.
Important state of the repository that affects what can and cannot bed done.
Base class for most JGit unit tests.
Translation bundle for repo command
Indicates that a client request has not yet been read from the wire.
 
A class used to execute a Reset command.
Kind of reset
A three-way merger performing a content-merge if necessary
If the merge fails (means: not stopped because of unresolved conflicts) this enum is used to explain why it failed
POJOs for Gson serialization/de-serialization.
Describes an action the client can execute on a single object
Describes the body of a LFS batch API response
Describes an error to be returned by the LFS batch API
Describes the actions the LFS server offers for a single object
 
A binary file, or a symbolic link.
A commit reference to a commit in the DAG.
Custom argument handler RevCommit from string values.
An ordered list of RevCommit subclasses.
 
 
A class used to execute a revert command.
Selects interesting revisions during walking.
 
 
 
 
 
Application level mark bit for RevObjects.
 
Matches only commits with some/all RevFlags already set.
 
 
Multiple application level mark bits for RevObjects.
This signals a revision or object reference was not properly formatted.
 
Base object type accessed during revision walking.
An ordered list of RevObject subclasses.
One level of contents, either an intermediate level or a leaf level.
 
Sorting strategies supported by RevWalk and ObjectWalk.
An annotated tag.
A reference to a tree of subtrees/files.
Custom argument handler RevTree from string values.
Walks a commit graph and produces the matching commits in order.
Indicates a checked exception was thrown inside of RevWalk.
 
Utility methods for RevWalk.
Replaces a RevCommit's parents until not colored with REWRITE.
 
Remove files from the index and working directory (or optionally only from the index).
Configuration for an Amazon AWS S3 bucket
Repository storing LFS objects in Amazon S3
Utilities for reading GPG secret keys from a gpg-agent key file.
Something that can supply a passphrase to decrypt an encrypted secret key.
This class is used when it's required to load jgit classes in separate classloader for each test class.
Arbitrary sequence of elements.
Equivalence function for a Sequence compared by difference algorithm.
An interface for a database of known server keys, supporting finding all known keys and also deciding whether a server key is to be accepted.
A simple provider for ssh config settings related to host key checking.
The possible values for the "StrictHostKeyChecking" ssh config.
Offers operations to retrieve server keys from known_hosts files.
Indicates a transport service may not continue execution.
Indicates that the requested service requires authentication that the current user has not provided.
Indicates the request service is not enabled on a repository.
Exception thrown when an optional service is not available
Binds a servlet to a URL.
 
Common utility functions for servlets.
A SessionCloseListener is invoked when a SshdSession is closed.
 
A parser for secret keys stored in s-expressions.
Pure Java implementation of SHA-1 from FIPS 180-1 / RFC 3174.
 
Thrown by SHA1 if it detects a likely hash collision.
 
 
 
 
 
Show an object note.
 
 
Unmultiplexes the data portion of a side-band channel.
Multiplexes data and progress messages.
Write progress messages out to the sideband channel.
Utilities for signature verification.
Configuration for server-side signed push verification.
Signing support for Amazon AWS signing V4
An implementation of FileInputStream that ignores any exceptions on close().
Index structure of lines/blocks in one file.
Thrown by create() when file is too large.
 
An implementation of DataInput that only handles readInt() and readLong() using the Git conversion utilities for network byte order handling.
An implementation of DataOutput that only handles SimpleDataOutput.writeInt(int) and SimpleDataOutput.writeLong(long) using the Git conversion utilities for network byte order handling.
Simple http server for testing http access to Git repositories.
Simple limited size cache based on ConcurrentHashMap purging entries in LRU order when reaching size limit
 
Filter that includes commits after a configured number are skipped.
To be used in combination with a DirCacheIterator: includes only tree entries for which 'skipWorkTree' flag is not set.
Buffers a response, trying to gzip it if the user agent supports that.
Filter in front of InfoRefsServlet to catch smart service requests.
Built-in LFS smudge filter When content is read from git's object-database and written to the filesystem and this filter is configured for that content, then this filter will replace the content of LFS pointer files with the original content.
A AbstractClientProxyConnector to connect through a SOCKS5 proxy.
 
Authentication methods for SOCKS5.
Formatter for constructing the commit message for a squashed commit.
Some minimal cloning and fetching tests.
An abstraction for a SSH config storage, like the OpenSSH ~/.ssh/config file.
A host entry from the ssh config.
Constants relating to ssh.
Simple enumeration for the available built-in ssh clients.
An implementation of RemoteSession based on Apache MINA sshd.
Helper interface like Supplier, but possibly raising an IOException.
 
A SshSessionFactory that uses Apache MINA sshd.
A simple general map key.
A builder API to configure SshdSessionFactories.
A factory interface for creating a @link SshConfigStore}.
 
Externalized text messages for localization.
Creates and destroys SSH connections to a remote system.
Extra utilities to support usage of SSH.
The ssh tests.
A simple ssh/sftp git test server based on Apache MINA sshd.
Simple echo command that echoes back the command string.
 
Root class for ssh tests.
 
 
The base class for transports that use SSH protocol.
Initial RevWalk generator that bootstraps a new walk.
Command class to apply a stashed commit.
Thrown from StashApplyCommand when stash apply fails
Command class to stash changes in the working directory and index in a commit.
Command class to delete a stashed commit reference
Command class to list the stashed commits in a repository.
Some proxy connections are stateful and require the exchange of multiple request-reply messages.
Simple double statistics, computed incrementally, variance and standard deviation using Welford's online algorithm, see https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm
A class telling where the working-tree, the index and the current HEAD differ from each other.
Status command
A class used to execute a Status command.
A very simple representation of a HTTP status line.
Stops the driver loop of walker and finish with current results.
Persistent configuration that can be stored and loaded from a location.
An object representation PackWriter can consider for packing.
A previously selected representation is no longer available.
Trivial merge strategy to make the resulting tree exactly match an input.
 
A three-way merge strategy performing a content-merge if necessary
A three-way merge strategy performing a content-merge if necessary
Merges two commits together in-memory, ignoring any working directory.
 
Thread to copy from an input stream to an output stream.
Strict work monitor
Various String related utility methods, written mostly to avoid generation of new String objects (e.g.
 
Miscellaneous string comparison utility methods.
Custom Argument handler for jgit command selection.
A class used to execute a submodule add command.
Submodule section of a Git configuration file.
Config values for submodule.[name].fetchRecurseSubmodules.
Merges expect that conflicts will consist of Sequences, but that doesn't really make sense for submodules.
A class used to execute a submodule deinit command.
The user tried to deinitialize a submodule that doesn't exist in the index.
The effect of a submodule deinit command for a given path
The result of a submodule deinit command for a particular path
A class used to execute a submodule init command.
Status class containing the type, path, and commit id of the submodule.
A class used to execute a submodule status command.
Enumeration of different statuses that a submodule can be in
A class used to execute a submodule sync command.
A class used to execute a submodule update command.
Validations for the git submodule fields (name, path, uri).
Error validating a git submodule declaration
Walker that visits all submodule entries found in a tree
The values for the config parameter submodule.<name>.ignore
Wraps a Sequence to have a narrower range of elements.
Wrap another comparator for use with Subsequence.
Abstract filter that searches text using only substring search.
Selects requests by matching the suffix of the URI.
 
 
 
Utility functions for looking a S-expression keys.
A reference that indirectly points at another Ref.
An exception thrown when a symlink entry is found and cannot be handled.
Interface to read values from the system.
 
 
Mutable builder to construct an annotated tag recording a project state.
Create/update an annotated tag object or a simple unannotated tag
Specification of annotated tag behavior during fetch.
Unix TAR format (ustar + some PAX extensions).
bzip2-compressed tarball (tar.bz2) format.
The base class for transports based on TCP sockets.
Input stream that copies data read to another output stream.
An output stream that writes all data to two streams.
A fully buffered output stream.
 
A temporary buffer that will never exceed its in-memory limit.
A fully buffered output stream using local disk storage for large data.
A HttpEntity which takes its content from a TemporaryBuffer
Protocol for transport between manually-specified repositories in tests.
Wrapper to make creating test data easier.
A simple repository resolver for tests.
Logs request made through AppServer.
Toy RNG to ensure we get predictable numbers during unit tests.
Abstract command which can be invoked from the command line.
Exception thrown by TextBuiltin if it proceeds 'help' option
Sends a small text meta file from the repository.
Scan repository to compute maximum number of collisions for hash functions.
Base class for any hashCode folding function to be tested.
 
Base class for any hashCode function to be tested.
Utility to help us identify unique lines in a file.
A simple progress reporter printing on a stream.
gzip-compressed tarball (tar.gz) format.
 
Wrapper around the general ProgressMonitor to make it thread safe.
A merge of 2 trees, using a common base ancestor tree.
A merge strategy to merge 2 trees, using a common base ancestor tree.
An alternative PrintWriter that doesn't catch exceptions.
InputStream with a configurable timeout.
OutputStream with a configurable timeout.
Utility methods for handling timestamps
Exception thrown when PackParser finds an object larger than a predefined limit
Thrown when PackParser finds an object larger than a predefined limit
Exception thrown when the server rejected a too large pack
Thrown when a pack exceeds a given size limit
Sorts commits in topological order without intermixing lines of history.
Sorts commits in topological order.
Update of a locally stored tracking branch.
Matcher for simple patterns ending with an asterisk, e.g.
The standard "transfer", "fetch", "protocol", "receive", and "uploadpack" configuration parameters.
 
A git configuration value for how to handle a fsck failure of a particular kind.
A git configuration variable for which versions of the Git protocol to prefer.
 
 
 
Base class for all translation bundles that provides injection of translated texts into public String fields.
Common base class for all translation bundle related exceptions.
This exception will be thrown when a translation bundle loading fails.
This exception will be thrown when a translation string for a translation bundle and locale is missing.
Connects two Git repositories together and copies objects between them.
Type of operation a Transport is being opened for.
Transport over the non-Git aware Amazon S3 protocol.
Marker interface for transports that supports fetching from a git bundle (sneaker-net object transport).
 
Single shot fetch from a streamed Git bundle.
Base class for commands that use a Transport during execution.
Receives a callback allowing type-specific configuration to be set on the Transport instance after it's been created.
Exception thrown when transport operation failed
Indicates a protocol error has occurred while fetching/pushing objects.
Transport through a git-daemon waiting for anonymous TCP connections.
Transport through an SSH tunnel.
Transport over HTTP and FTP protocols.
Accept-Encoding header in the HTTP request (https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).
 
Transport to access a local directory as though it were a remote peer.
Describes a way to connect to another Git repository.
Fields within a URIish that a transport uses.
Transport over the non-Git aware SFTP (SSH based FTP) protocol.
Selects interesting tree entries during walking.
 
 
For testing an array of TreeFilter during a TreeWalk for each entry and returning the result as a bitmask.
Mutable formatter to construct a single tree object.
Filter applying a TreeFilter against changed paths in each commit.
Walks one or more AbstractTreeIterators in parallel.
 
Xz-compressed tar (tar.xz) format.
Something that knows how to convert plain strings from a git Config to typed values.
 
 
Translation bundle for JGit UI
An InputStream which reads from one or more InputStreams.
Indicates one or more paths in a DirCache have non-zero stages present.
Thrown when branch deletion fails due to unmerged data
Loose object loader.
 
Remembers objects that are currently unpacked.
 
Exception handler for processing an incoming pack file.
Indicates a ReceivePack failure while scanning the pack stream.
An exception thrown when a CredentialItem is requested from a CredentialsProvider which is not supported by this provider.
Thrown when a PackIndex uses an index version not supported by JGit.
Thrown when a Pack uses a pack version not supported by JGit.
Exception thrown when the configured gpg.format is not supported.
Special handler for the --untracked-files option of the status command.
 
Implements the server side of a fetch connection, transmitting objects.
Validator corresponding to UploadPack.RequestPolicy.ADVERTISED.
Validator corresponding to UploadPack.RequestPolicy.ANY.
 
Deprecated.
Use FirstWant instead
 
Validator corresponding to UploadPack.RequestPolicy.REACHABLE_COMMIT.
Policy the server uses to validate client requests
Validator for client requests.
 
Validator corresponding to UploadPack.RequestPolicy.TIP.
Handle git-upload-pack errors.
Process a git-upload-pack request.
Create and configure UploadPack service instance.
UploadPack has already reported an error to the client.
Server side implementation of smart fetch over HTTP.
 
 
This URI like construct used for referencing Git archives over the net, as well as locally stored archives.
Encapsulates the entire serving stack for a single URL.
 
User agent to be reported by this JGit client and server on the network.
The standard "user" configuration parameters.
Simple CredentialsProvider that always uses the same information.
A VerificationResult describes the outcome of a signature verification.
Utilities for signature verification.
 
A command to verify GPG signatures on tags or commits.
 
Describes what kind of objects shall be handled by a VerifySignatureCommand.
 
 
JetS3t compatibility reference: EncryptionUtil.java
Provides JetS3t-like encryption with AES support.
Supports both PBE and non-PBE algorithms.
Encryption property names.
 
Base implementation of JGit symmetric encryption.
Encryption constants and defaults.
Generic fetch support for dumb transport protocols.
Generic push support for dumb transport protocols.
Transfers object data through a dumb transport.
 
Marker interface for an object transport walking transport.
Indicates client requested an object the server does not want to serve.
 
Matcher built from path segments containing wildcards.
Wildmatch matcher for "double star" (**) pattern only.
Caches slices of a Pack in memory for faster read access.
 
 
 
 
 
A soft reference wrapped around a cached object.
Record statistics for a cache
 
 
A strong reference wrapped around a cached object.
Configuration parameters for JVM-wide buffer cache used by JGit.
Cache statistics for WindowCache.
Active handle to a ByteWindow.
Walks a working directory tree as part of a TreeWalk.
A single entry within a working directory tree.
 
The result of a metadata-comparison between the current entry and a DirCacheEntry
Magic type indicating we know rules exist, but they aren't loaded.
Magic type indicating we know rules exist, but they aren't loaded.
Magic type indicating there may be rules for the top level.
A RepositoryEvent describing changes to the working tree.
Receives WorkingTreeModifiedEvents, which are fired whenever a DirCacheCheckout modifies (adds/deletes/updates) files in the working tree.
Options used by the WorkingTreeIterator.
Simple work queue to run tasks in the background
Overrides the path and path info.
An exception to be thrown when the write operation is aborted.
 
 
 
 
A given object is not of an expected object type.
Exception thrown when the state of the repository doesn't allow the execution of a certain command.
PKWARE's ZIP format.