Struct git_repository::Tree

pub struct Tree<'repo> {
    pub id: ObjectId,
    pub data: Vec<u8>,
    /* private fields */
}

A decoded tree object with access to its owning repository.

Fields

id: ObjectId

The id of the tree

data: Vec<u8>

The fully decoded tree data

Implementations

impl<'repo> Tree<'repo>

Diffing

pub fn changes<'a>(&'a self) -> Result<Platform<'a, 'repo>, Error>

Return a platform to see the changes needed to create other trees, for instance.

Performance

It’s highly recommended to set an object cache to avoid extracting the same object multiple times. By default, similar to git diff, rename tracking will be enabled if it is not configured.

impl<'repo> Tree<'repo>

Traversal

pub fn traverse(&self) -> Platform<'_, 'repo>

Obtain a platform for initiating a variety of traversals.

impl<'repo> Tree<'repo>

pub fn iter(&self) -> impl Iterator<Item = Result<EntryRef<'repo, '_>, Error>>

Return an iterator over tree entries to obtain information about files and directories this tree contains.

impl<'repo> Tree<'repo>

Initialization

pub fn from_data( id: impl Into<ObjectId>, data: Vec<u8>, repo: &'repo Repository ) -> Self

Obtain a tree instance by handing in all components that it is made up of.

impl<'repo> Tree<'repo>

Access

pub fn id(&self) -> Id<'repo>

Return this tree’s identifier.

pub fn lookup_entry<I, P>(self, path: I) -> Result<Option<Entry<'repo>>, Error>where I: IntoIterator<Item = P>, P: PartialEq<BStr>,

Follow a sequence of path components starting from this instance, and look them up one by one until the last component is looked up and its tree entry is returned.

Performance Notes

Searching tree entries is currently done in sequence, which allows to the search to be allocation free. It would be possible to re-use a vector and use a binary search instead, which might be able to improve performance over all. However, a benchmark should be created first to have some data and see which trade-off to choose here.

Why is this consuming?

The borrow checker shows pathological behaviour in loops that mutate a buffer, but also want to return from it. Workarounds include keeping an index and doing a separate access to the memory, which seems hard to do here without re-parsing the entries.

pub fn lookup_entry_by_path( self, relative_path: impl AsRef<Path> ) -> Result<Option<Entry<'repo>>, Error>

Like lookup_entry(), but takes a Path directly via relative_path, a path relative to this tree.

Note

If any path component contains illformed UTF-8 and thus can’t be converted to bytes on platforms which can’t do so natively, the returned component will be empty which makes the lookup fail.

Trait Implementations

impl<'r> Debug for Tree<'r>

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

Formats the value using the given formatter.

impl<'a> Drop for Tree<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'repo> TryFrom<Object<'repo>> for Tree<'repo>

type Error = Object<'repo>

The type returned in the event of a conversion error.

fn try_from(value: Object<'repo>) -> Result<Self, Self::Error>

Performs the conversion.