| Name |
Description |
| AbbreviatedObjectId |
|
| AbstractIndexTreeVisitor |
|
| AlternateRepositoryDatabase |
|
| BinaryDelta |
Recreate a stream from a base stream and a GIT pack delta. This entire class is heavily cribbed from patch-delta.c in the GIT project. The original delta patching code was written by Nicolas Pitre (<[email protected]>). |
| BlobBasedConfig |
The configuration file based on the blobs stored in the repository. |
| ByteArrayExtensions |
|
| ByteArrayExtensions.ParsedLine |
|
| ByteArrayWindow |
A ByteWindow with an underlying byte array for storage. |
| ByteBufferWindow |
A window for accessing git packs using a Stream for storage. |
| Codec |
|
| Commit |
Instances of this class represent a Commit object. It represents a snapshot in a Git repository, who created it and when. |
| ConsoleUserInfoProvider |
|
| Constants |
|
| Constants.ObjectTypes |
|
| DeltaOfsPackedObjectLoader |
|
| DeltaPackedObjectLoader |
Reader for a deltified object Stored in a pack file. |
| DeltaRefPackedObjectLoader |
Reads a deltified object which uses an ObjectId to find its base. |
| FileBasedConfig |
|
| FileTreeEntry |
|
| ForceModified |
|
| FormUserInfoProvider |
|
| GitLinkTreeEntry |
|
| IgnoreHandler |
|
| IgnoreHandler.FnMatchPattern |
|
| IgnoreHandler.NegatedPattern |
|
| IndexDiff |
|
| IndexTreeWalker |
|
| LockFile |
Git style file locking and replacement. To modify a ref file Git tries to use an atomic update approach: we write the new data into a brand new file, then rename it in place over the old name. This way we can just delete the temporary file if anything goes wrong, and nothing has been damaged. To coordinate access from multiple processes at once Git tries to atomically create the new temporary file under a well-known name. |
| LockFile.FileLock |
Wraps a FileStream and tracks its locking status |
| LockFile.LockFileOutputStream |
|
| MutableObjectId |
|
| NullProgressMonitor |
|
| ObjectChecker |
Verifies that an object is formatted correctly. Verifications made by this class only check that the fields of an object are formatted correctly. The ObjectId checksum of the object is not verified, and connectivity links between objects are also not verified. Its assumed that the caller can provide both of these validations on its own. Instances of this class are not thread safe, but they may be reused to perform multiple object validations. |
| ObjectDatabase |
Abstraction of arbitrary object storage. An object database stores one or more Git objects, indexed by their unique ObjectId. Optionally an object database can reference one or more alternates; other ObjectDatabase instances that are searched in addition to the current database. Databases are usually divided into two halves: a half that is considered to be fast to search, and a half that is considered to be slow to search. When alternates are present the fast half is fully searched (recursively through all alternates) before the slow half is considered. |
| ObjectDirectory |
Traditional file system based ObjectDatabase. This is the classical object database representation for a Git repository, where objects are stored loose by hashing them into directories by their ObjectId, or are stored in compressed containers known as PackFiles. |
| ObjectDirectory.PackList |
|
| ObjectDirectory.PackList.LongWrapper |
|
| ObjectId |
|
| ObjectWriter |
|
| PackIndexV1 |
|
| PackIndexV1.IndexV1Enumerator |
|
| PackIndexV2 |
Support for the pack index v2 format. |
| PackIndexV2.EntriesEnumeratorV2 |
|
| PackLock |
Keeps track of a PackFile associated .keep file. |
| PersonIdent |
|
| ProgressMonitor |
|
| PromptForm |
|
| Ref |
Pairing of a name and the ObjectId it currently has. A ref in Git is (more or less) a variable that holds a single object identifier. The object identifier can be any valid Git object (blob, tree, commit, annotated tag, ...). The ref name has the attributes of the ref that was asked for as well as the ref it was resolved to for symbolic refs plus the object id it points to and (for tags) the peeled target object id, i.e. the tag resolved recursively until a non-tag object is referenced. |
| Ref.Storage |
Location where a Ref is Stored. |
| RefDatabase |
|
| RefDatabase.CachedRef |
|
| RefDatabase.ExtendedRefWriter |
|
| RefLogWriter |
Utility class to work with reflog files |
| RefUpdate |
|
| RefUpdate.DeleteStore |
|
| RefUpdate.StoreBase |
|
| RefUpdate.UpdateStore |
|
| RefWriter |
Writes out refs to the Constants.INFO_REFS and Constants.PACKED_REFS files. This class is abstract as the writing of the files must be handled by the caller. This is because it is used by transport classes as well. |
| ReflogReader |
Utility for reading reflog entries. |
| ReflogReader.Entry |
|
| Repository |
Represents a Git repository. A repository holds all objects and refs used for managing source code (could by any type of file, but source code is what SCM's are typically used for). In Git terms all data is stored in GIT_DIR, typically a directory called .git. A work tree is maintained unless the repository is a bare repository. Typically the .git directory is located at the root of the work dir. - GIT_DIR
- objects/ - objects
- refs/ - tags and heads
- config - configuration
- info/ - more configurations
This class is thread-safe. This implementation only handles a subtly undocumented subset of git features. |
| RepositoryCache |
|
| RepositoryCache.FileKey |
|
| RepositoryChangedEventArgs |
|
| RepositoryConfig |
|
| RepositoryState |
|
| SubmoduleConfig |
|
| SubmoduleEntry |
|
| SystemReader |
|
| SystemReader.InternalSystemReader |
|
| Tag |
|
| Tree |
A representation of a Git tree entry. A Tree is a directory in Git. |
| TreeIterator |
|
| TreeVisitorWithCurrentDirectory |
Abstract TreeVisitor for visiting all files known by a Tree. |
| UnpackedObjectCache |
|
| UnpackedObjectCache.Entry |
|
| UnpackedObjectCache.Slot |
|
| UnpackedObjectLoader |
Loose object loader. This class loads an object not stored in a pack. |
| WholePackedObjectLoader |
Reader for a non-delta (just deflated) object in a pack file. |
| WorkDirCheckout |
This class handles checking out one or two trees merging with the index (actually a tree too). Three-way merges are no performed. See FailOnConflict. |
| WriteTree |
A tree visitor for writing a directory tree to the git object database. Blob data is fetched from the files, not the cached blobs. |
