Struct gix_dir::EntryRef

pub struct EntryRef<'a> {
    pub rela_path: Cow<'a, BStr>,
    pub status: Status,
    pub property: Option<Property>,
    pub disk_kind: Option<Kind>,
    pub index_kind: Option<Kind>,
    pub pathspec_match: Option<PathspecMatch>,
}

A directory entry, typically obtained using walk().

Fields

rela_path: Cow<'a, BStr>

The repository-relative path at which the file or directory could be found, with unix-style component separators.

To obtain the respective file, join it with the worktree_root passed to walk(). The rationale here is that this is a compressed and normalized version compared to the paths we would otherwise get, which is preferable especially when converted to Entry due to lower memory requirements.

This also means that the original path to be presented to the user needs to be computed separately, as it’s also relative to their prefix, i.e. their current working directory within the repository.

Note that this value can be empty if information about the worktree_root is provided, which is fine as joining with an empty string is a no-op.

Note that depending on the way entries are emitted, even refs might already contain an owned rela_path, for use with into_owned()

status: Status

The status of entry, most closely related to what we know from git status, but not the same.

Note that many entries with status Pruned will not show up as their kind hasn’t yet been determined when they were pruned very early on.

property: Option<Property>

Additional properties of the entry.

disk_kind: Option<Kind>

Further specify what the entry is on disk, similar to a file mode. This is None if we decided it’s not worth it to exit early and avoid trying to obtain this information.

index_kind: Option<Kind>

The kind of entry according to the index, if tracked. Usually the same as disk_kind.

pathspec_match: Option<PathspecMatch>

Determines how the pathspec matched. Note that it can also be Some(PathspecMatch::Excluded) if a negative pathspec matched.

Implementations

impl EntryRef<'_>

Conversion

pub fn to_owned(&self) -> Entry

Strip the lifetime to obtain a fully owned copy.

pub fn into_owned(self) -> Entry

Turn this instance into a fully owned copy.

Trait Implementations

impl<'a> Clone for EntryRef<'a>

fn clone(&self) -> EntryRef<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for EntryRef<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for EntryRef<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> Ord for EntryRef<'a>

fn cmp(&self, other: &EntryRef<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<'a> PartialEq for EntryRef<'a>

fn eq(&self, other: &EntryRef<'a>) -> 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<'a> PartialOrd for EntryRef<'a>

fn partial_cmp(&self, other: &EntryRef<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Eq for EntryRef<'a>

impl<'a> StructuralPartialEq for EntryRef<'a>