Struct radicle_surf::fs::Directory

source ·

pub struct Directory { /* private fields */ }

Expand description

A Directory is the representation of a file system directory, for a given git tree.

The name of a directory can be retrieved via File::name.

The Entries of a directory can be retrieved via Directory::entries.

Implementations§

source §

impl Directory

source

pub fn name(&self) -> &String

Get the name of the current Directory.

Examples found in repository ?

examples/browsing.rs (line 53)

fn print_directory(d: &Directory, repo: &Repository, indent_level: usize) {
    let indent = " ".repeat(indent_level * 4);
    println!("{}{}/", &indent, d.name());
    for entry in d.entries(repo).unwrap() {
        match entry {
            fs::Entry::File(f) => println!("    {}{}", &indent, f.name()),
            fs::Entry::Directory(d) => print_directory(&d, repo, indent_level + 1),
            fs::Entry::Submodule(s) => println!("    {}{}", &indent, s.name()),
        }
    }
}

source

pub fn id(&self) -> Oid

The object identifier of this [Directory].

source

pub fn path(&self) -> PathBuf

Return the exact path for this Directory, including the name of the directory itself.

The path is relative to the git repository root.

source

pub fn location(&self) -> &Path

Return the Path where this Directory is located, relative to the git repository root.

source

pub fn entries(&self, repo: &Repository) -> Result<Entries, Directory>

Return the Entries for this Directory’s Oid.

The resulting Entries will only resolve to this Directory’s entries. Any sub-directories will need to be resolved independently.

§Errors

This function will fail if it could not find the git tree for the Oid.

Examples found in repository ?

examples/browsing.rs (line 54)

fn print_directory(d: &Directory, repo: &Repository, indent_level: usize) {
    let indent = " ".repeat(indent_level * 4);
    println!("{}{}/", &indent, d.name());
    for entry in d.entries(repo).unwrap() {
        match entry {
            fs::Entry::File(f) => println!("    {}{}", &indent, f.name()),
            fs::Entry::Directory(d) => print_directory(&d, repo, indent_level + 1),
            fs::Entry::Submodule(s) => println!("    {}{}", &indent, s.name()),
        }
    }
}

source

pub fn find_entry( &self, path: &P, repo: &Repository, ) -> Result<Entry, Directory>
where P: AsRef<Path>,

Find the Entry found at a non-empty path, if it exists.

source

pub fn find_file( &self, path: &P, repo: &Repository, ) -> Result<File, Directory>
where P: AsRef<Path>,

Find the Oid, for a File, found at path, if it exists.

source

pub fn find_directory( &self, path: &P, repo: &Repository, ) -> Result<Self, Directory>
where P: AsRef<Path>,

Find the Directory found at path, if it exists.

If path is ROOT_DIR (i.e. an empty path), returns self.

source

pub fn size(&self, repo: &Repository) -> Result<usize, Directory>

Get the total size, in bytes, of a Directory. The size is the sum of all files that can be reached from this Directory.

source

pub fn traverse<Error, B, F>( &self, repo: &Repository, initial: B, f: &mut F, ) -> Result<B, Error>
where Error: From<Directory>, F: FnMut(B, &Entry) -> Result<B, Error>,

Traverse the entire Directory using the initial accumulator and the function f.

For each Entry::Directory this will recursively call Directory::traverse and obtain its Entries.

Error is the error type of the fallible function. B is the type of the accumulator. F is the fallible function that takes the accumulator and the next Entry, possibly providing the next accumulator value.