Struct gix_dir::walk::Options

pub struct Options<'a> {

    pub precompose_unicode: bool,
    pub ignore_case: bool,
    pub recurse_repositories: bool,
    pub emit_pruned: bool,
    pub emit_ignored: Option<EmissionMode>,
    pub for_deletion: Option<ForDeletionMode>,
    pub classify_untracked_bare_repositories: bool,
    pub emit_tracked: bool,
    pub emit_untracked: EmissionMode,
    pub emit_empty_directories: bool,
    pub emit_collapsed: Option<CollapsedEntriesEmissionMode>,
    pub symlinks_to_directories_are_ignored_like_directories: bool,
    pub worktree_relative_worktree_dirs: Option<&'a BTreeSet<BString>>,
}

Options for use in walk() function.

Fields

precompose_unicode: bool

If true, the filesystem will store paths as decomposed unicode, i.e. ä becomes "a\u{308}", which means that we have to turn these forms back from decomposed to precomposed unicode before storing it in the index or generally using it. This also applies to input received from the command-line, so callers may have to be aware of this and perform conversions accordingly. If false, no conversions will be performed.

ignore_case: bool

If true, the filesystem ignores the case of input, which makes A the same file as a. This is also called case-folding. Note that pathspecs must also be using the same defaults, which makes them match case-insensitive automatically.

recurse_repositories: bool

If true, we will stop figuring out if any directory that is a candidate for recursion is also a nested repository, which saves time but leads to recurse into it. If false, nested repositories will not be traversed.

emit_pruned: bool

If true, entries that are pruned and whose Kind is known will be emitted.

emit_ignored: Option<EmissionMode>

If Some(mode), entries that are ignored will be emitted according to the given mode. If None, ignored entries will not be emitted at all.

for_deletion: Option<ForDeletionMode>

When the walk is for deletion, this must be Some(_) to assure we don’t collapse directories that have precious files in them, and otherwise assure that no entries are observable that shouldn’t be deleted. If None, precious files are treated like expendable files, which is usually what you want when displaying them for addition to the repository, and the collapse of folders can be more generous in relation to ignored files.

classify_untracked_bare_repositories: bool

If true, we will not only find non-bare repositories in untracked directories, but also bare ones.

Note that this is very costly, but without it, bare repositories will appear like untracked directories when collapsed, and they will be recursed into.

emit_tracked: bool

If true, we will also emit entries for tracked items. Otherwise these will remain ‘hidden’, even if a pathspec directly refers to it.

emit_untracked: EmissionMode

Controls the way untracked files are emitted. By default, this is happening immediately and without any simplification.

emit_empty_directories: bool

If true, emit empty directories as well. Note that a directory also counts as empty if it has any amount or depth of nested subdirectories, as long as none of them includes a file. Thus, this makes leaf-level empty directories visible, as those don’t have any content.

emit_collapsed: Option<CollapsedEntriesEmissionMode>

If None, no entries inside of collapsed directories are emitted. Otherwise, act as specified by Some(mode).

symlinks_to_directories_are_ignored_like_directories: bool

This is a libgit2 compatibility flag, and if enabled, symlinks that point to directories will be considered a directory when checking for exclusion.

This is relevant if src2 points to src, and is excluded with src2/. If false, src2 will not be excluded, if true it will be excluded as the symlink is considered a directory.

In other words, for Git compatibility this flag should be false, the default, for git2 compatibility it should be true.

worktree_relative_worktree_dirs: Option<&'a BTreeSet<BString>>

A set of all git worktree checkouts that are located within the main worktree directory.

They will automatically be detected as ‘tracked’, but without providing index information (as there is no actual index entry). Note that the unicode composition must match the precompose_unicode field so that paths will match verbatim.

Trait Implementations

impl<'a> Clone for Options<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Options<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Options<'a>

fn default() -> Options<'a>

Returns the “default value” for a type.

impl<'a> Hash for Options<'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 Options<'a>

fn cmp(&self, other: &Options<'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 Options<'a>

fn eq(&self, other: &Options<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> PartialOrd for Options<'a>

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> Copy for Options<'a>

impl<'a> Eq for Options<'a>

impl<'a> StructuralPartialEq for Options<'a>