Struct git_index::extension::Tree

pub struct Tree {
    pub name: SmallVec<[u8; 23]>,
    pub id: ObjectId,
    pub num_entries: Option<u32>,
    pub children: Vec<Tree>,
}

A structure to associate object ids of a tree with sections in the index entries list.

It allows to more quickly build trees by avoiding as it can quickly re-use portions of the index and its associated tree ids if there was no change to them. Portions of this tree are invalidated as the index is changed.

Fields

name: SmallVec<[u8; 23]>

The name of the tree/directory, or empty if it’s the root tree.

id: ObjectId

The id of the directory tree of the associated tree object.

num_entries: Option<u32>

The amount of non-tree items in this directory tree, including sub-trees, recursively. The value of the top-level tree is thus equal to the value of the total amount of entries. If None, the tree is considered invalid and needs to be refreshed

children: Vec<Tree>

The child-trees below the current tree.

Implementations

impl Tree

pub fn verify<F>(&self, use_find: bool, find: F) -> Result<(), Error>where
    F: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Option<TreeRefIter<'a>>,

Examples found in repository

src/verify.rs (line 68)

    pub fn verify_extensions<F>(&self, use_find: bool, find: F) -> Result<(), extensions::Error>
    where
        F: for<'a> FnMut(&git_hash::oid, &'a mut Vec<u8>) -> Option<git_object::TreeRefIter<'a>>,
    {
        self.tree().map(|t| t.verify(use_find, find)).transpose()?;
        // TODO: verify links by running the whole set of tests on the index
        //       - do that once we load it as well, or maybe that's lazy loaded? Too many questions for now.
        Ok(())
    }

impl Tree

pub fn write_to(&self, out: impl Write) -> Result<(), Error>

Serialize this instance to out.

Examples found in repository

src/write.rs (line 102)

    fn write_extensions<T>(
        &self,
        mut write: CountBytes<T>,
        offset_to_extensions: u32,
        extensions: Extensions,
    ) -> std::io::Result<(Vec<(extension::Signature, u32)>, T)>
    where
        T: std::io::Write,
    {
        type WriteExtFn<'a> = &'a dyn Fn(&mut dyn std::io::Write) -> Option<std::io::Result<extension::Signature>>;
        let extensions: &[WriteExtFn<'_>] = &[
            &|write| {
                extensions
                    .should_write(extension::tree::SIGNATURE)
                    .and_then(|signature| self.tree().map(|tree| tree.write_to(write).map(|_| signature)))
            },
            &|write| {
                self.is_sparse()
                    .then(|| extension::sparse::write_to(write).map(|_| extension::sparse::SIGNATURE))
            },
        ];

        let mut offset_to_previous_ext = offset_to_extensions;
        let mut out = Vec::with_capacity(5);
        for write_ext in extensions {
            if let Some(signature) = write_ext(&mut write).transpose()? {
                let offset_past_ext = write.count;
                let ext_size = offset_past_ext - offset_to_previous_ext - (extension::MIN_SIZE as u32);
                offset_to_previous_ext = offset_past_ext;
                out.push((signature, ext_size));
            }
        }
        Ok((out, write.inner))
    }

Trait Implementations

impl Clone for Tree

fn clone(&self) -> Tree

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Tree

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<Tree> for Tree

fn eq(&self, other: &Tree) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Tree

impl StructuralEq for Tree

impl StructuralPartialEq for Tree