Class DfsRefDatabase

java.lang.Object
org.eclipse.jgit.lib.RefDatabase
org.eclipse.jgit.internal.storage.dfs.DfsRefDatabase
Direct Known Subclasses:
DfsReftableDatabase

public abstract class DfsRefDatabase extends RefDatabase
Abstract DfsRefDatabase class.
  • Field Details

  • Constructor Details

    • DfsRefDatabase

      protected DfsRefDatabase(DfsRepository repository)
      Initialize the reference database for a repository.
      Parameters:
      repository - the repository this database instance manages references for.
  • Method Details

    • getRepository

      protected DfsRepository getRepository()
      Get the repository the database holds the references of.
      Returns:
      the repository the database holds the references of.
    • exists

      boolean exists() throws IOException
      Throws:
      IOException
    • exactRef

      public Ref exactRef(String name) throws IOException
      Read a single reference.

      Unlike RefDatabase.findRef(java.lang.String), this method expects an unshortened reference name and does not search using the standard RefDatabase.SEARCH_PATH.

      Specified by:
      exactRef in class RefDatabase
      Parameters:
      name - the unabbreviated name of the reference.
      Returns:
      the reference (if it exists); else null.
      Throws:
      IOException - the reference space cannot be accessed.
    • getAdditionalRefs

      public List<Ref> getAdditionalRefs()
      Get the additional reference-like entities from the repository.

      The result list includes non-ref items such as MERGE_HEAD and FETCH_RESULT cast to be refs. The names of these refs are not returned by getRefs() but are accepted by RefDatabase.findRef(String) and RefDatabase.exactRef(String).

      Specified by:
      getAdditionalRefs in class RefDatabase
      Returns:
      a list of additional refs
    • getRefs

      public Map<String,Ref> getRefs(String prefix) throws IOException
      Get a section of the reference namespace.
      Specified by:
      getRefs in class RefDatabase
      Parameters:
      prefix - prefix to search the namespace with; must end with /. If the empty string (RefDatabase.ALL), obtain a complete snapshot of all references.
      Returns:
      modifiable map that is a complete snapshot of the current reference namespace, with prefix removed from the start of each key. The map can be an unsorted map.
      Throws:
      IOException - the reference space cannot be accessed.
    • resolve

      private Ref resolve(Ref ref, int depth, RefList<Ref> loose) throws IOException
      Throws:
      IOException
    • peel

      public Ref peel(Ref ref) throws IOException
      Peel a possibly unpeeled reference by traversing the annotated tags.

      If the reference cannot be peeled (as it does not refer to an annotated tag) the peeled id stays null, but Ref.isPeeled() will be true.

      Implementors should check Ref.isPeeled() before performing any additional work effort.

      Specified by:
      peel in class RefDatabase
      Parameters:
      ref - The reference to peel
      Returns:
      ref if ref.isPeeled() is true; otherwise a new Ref object representing the same data as Ref, but isPeeled() will be true and getPeeledObjectId() will contain the peeled object (or null).
      Throws:
      IOException - the reference space or object space cannot be accessed.
    • doPeel

      Ref doPeel(Ref leaf) throws MissingObjectException, IOException
      Throws:
      MissingObjectException
      IOException
    • recreate

      static Ref recreate(Ref old, Ref leaf, boolean hasVersioning)
    • newUpdate

      public RefUpdate newUpdate(String refName, boolean detach) throws IOException
      Create a new update command to create, modify or delete a reference.
      Specified by:
      newUpdate in class RefDatabase
      Parameters:
      refName - the name of the reference.
      detach - if true and name is currently a SymbolicRef, the update will replace it with an ObjectIdRef. Otherwise, the update will recursively traverse SymbolicRefs and operate on the leaf ObjectIdRef.
      Returns:
      a new update for the requested name; never null.
      Throws:
      IOException - the reference space cannot be accessed.
    • newRename

      public RefRename newRename(String fromName, String toName) throws IOException
      Create a new update command to rename a reference.
      Specified by:
      newRename in class RefDatabase
      Parameters:
      fromName - name of reference to rename from
      toName - name of reference to rename to
      Returns:
      an update command that knows how to rename a branch to another.
      Throws:
      IOException - the reference space cannot be accessed.
    • isNameConflicting

      public boolean isNameConflicting(String refName) throws IOException
      Determine if a proposed reference name overlaps with an existing one.

      Reference names use '/' as a component separator, and may be stored in a hierarchical storage such as a directory on the local filesystem.

      If the reference "refs/heads/foo" exists then "refs/heads/foo/bar" must not exist, as a reference cannot have a value and also be a container for other references at the same time.

      If the reference "refs/heads/foo/bar" exists than the reference "refs/heads/foo" cannot exist, for the same reason.

      Specified by:
      isNameConflicting in class RefDatabase
      Parameters:
      refName - proposed name.
      Returns:
      true if the name overlaps with an existing reference; false if using this name right now would be safe.
      Throws:
      IOException - the database could not be read to check for conflicts.
      See Also:
    • create

      public void create()
      Initialize a new reference database at this location.
      Specified by:
      create in class RefDatabase
    • refresh

      public void refresh()
      Triggers a refresh of all internal data structures.

      In case the RefDatabase implementation has internal caches this method will trigger that all these caches are cleared.

      Implementors should overwrite this method if they use any kind of caches.

      Overrides:
      refresh in class RefDatabase
    • close

      public void close()
      Close any resources held by this database.
      Specified by:
      close in class RefDatabase
    • clearCache

      void clearCache()
    • stored

      void stored(Ref ref)
    • removed

      void removed(String refName)
    • read

      private DfsRefDatabase.RefCache read() throws IOException
      Throws:
      IOException
    • scanAllRefs

      protected abstract DfsRefDatabase.RefCache scanAllRefs() throws IOException
      Read all known references in the repository.
      Returns:
      all current references of the repository.
      Throws:
      IOException - references cannot be accessed.
    • compareAndPut

      protected abstract boolean compareAndPut(Ref oldRef, Ref newRef) throws IOException
      Compare a reference, and put if it matches.

      Two reference match if and only if they satisfy the following:

      • If one reference is a symbolic ref, the other one should be a symbolic ref.
      • If both are symbolic refs, the target names should be same.
      • If both are object ID refs, the object IDs should be same.
      Parameters:
      oldRef - old value to compare to. If the reference is expected to not exist the old value has a storage of Ref.Storage.NEW and an ObjectId value of null.
      newRef - new reference to store.
      Returns:
      true if the put was successful; false otherwise.
      Throws:
      IOException - the reference cannot be put due to a system error.
    • compareAndRemove

      protected abstract boolean compareAndRemove(Ref oldRef) throws IOException
      Compare a reference, and delete if it matches.
      Parameters:
      oldRef - the old reference information that was previously read.
      Returns:
      true if the remove was successful; false otherwise.
      Throws:
      IOException - the reference could not be removed due to a system error.
    • cachePeeledState

      protected void cachePeeledState(Ref oldLeaf, Ref newLeaf)
      Update the cached peeled state of a reference

      The ref database invokes this method after it peels a reference that had not been peeled before. This allows the storage to cache the peel state of the reference, and if it is actually peelable, the target that it peels to, so that on-the-fly peeling doesn't have to happen on the next reference read.

      Parameters:
      oldLeaf - the old reference.
      newLeaf - the new reference, with peel information.