Class RefTree


  • public class RefTree
    extends Object
    Tree of references in the reference graph.

    The root corresponds to the "refs/" subdirectory, for example the default reference "refs/heads/master" is stored at path "heads/master" in a RefTree.

    Normal references are stored as FileMode.GITLINK tree entries. The ObjectId in the tree entry is the ObjectId the reference refers to.

    Symbolic references are stored as FileMode.SYMLINK entries, with the blob storing the name of the target reference.

    Annotated tags also store the peeled object using a GITLINK entry with the suffix " ^" (space carrot), for example "tags/v1.0" stores the annotated tag object, while "tags/v1.0 ^" stores the commit the tag annotates.

    HEAD is a special case and stored as "..HEAD".

    • Field Detail

      • PEELED_SUFFIX

        public static final String PEELED_SUFFIX
        Suffix applied to GITLINK to indicate its the peeled value of a tag.
        See Also:
        Constant Field Values
    • Method Detail

      • newEmptyTree

        public static RefTree newEmptyTree()
        Create an empty reference tree.
        Returns:
        a new empty reference tree.
      • exactRef

        @Nullable
        public Ref exactRef​(ObjectReader reader,
                            String name)
                     throws IOException
        Read one reference.

        References are always returned peeled (Ref.isPeeled() is true). If the reference points to an annotated tag, the returned reference will be peeled and contain Ref.getPeeledObjectId().

        If the reference is a symbolic reference and the chain depth is less than RefDatabase.MAX_SYMBOLIC_REF_DEPTH the returned reference is resolved. If the chain depth is longer, the symbolic reference is returned without resolving.

        Parameters:
        reader - to access objects necessary to read the requested reference.
        name - name of the reference to read.
        Returns:
        the reference; null if it does not exist.
        Throws:
        IOException - cannot read a symbolic reference target.
      • apply

        public boolean apply​(Collection<Command> cmdList)
        Attempt a batch of commands against this RefTree.

        The batch is applied atomically, either all commands apply at once, or they all reject and the RefTree is left unmodified.

        On success (when this method returns true) the command results are left as-is (probably NOT_ATTEMPTED). Result fields are set only when this method returns false to indicate failure.

        Parameters:
        cmdList - to apply. All commands should still have result NOT_ATTEMPTED.
        Returns:
        true if the commands applied; false if they were rejected.
      • refName

        public static String refName​(String path)
        Convert a path name in a RefTree to the reference name known by Git.
        Parameters:
        path - name read from the RefTree structure, for example "heads/master".
        Returns:
        reference name for the path, "refs/heads/master".
      • writeTree

        public ObjectId writeTree​(ObjectInserter inserter)
                           throws IOException
        Write this reference tree.
        Parameters:
        inserter - inserter to use when writing trees to the object database. Caller is responsible for flushing the inserter before trying to read the objects, or exposing them through a reference.
        Returns:
        the top level tree.
        Throws:
        IOException - a tree could not be written.
      • copy

        public RefTree copy()
        Create a deep copy of this RefTree.
        Returns:
        a deep copy of this RefTree.