Struct TextTreeElements

pub struct TextTreeElements<'a> {
    pub prefix: TextTreeSymbols<'a>,
    pub branch: TextTreeSymbols<'a>,
}

Fields

prefix: TextTreeSymbols<'a>

symbols for padding and previous branches

branch: TextTreeSymbols<'a>

symbols for padding and branch

Implementations

impl<'a> TextTreeElements<'a>

pub fn new(prefix: [&'a str; 4], branch: [&'a str; 4]) -> Self

Initialize prefix and branch structures with user given symbols

let branch = [root, first, middle, last]; (default: ["", "", "├─ ", "└─ "]) let prefix = [root, first, middle, last]; (default: ["", "", "│ ", " "])

Examples found in repository

examples/example_1.rs (line 72)

fn main() {
    let path = PathBuf::from(".");
    let path_str = path.as_os_str().to_str().unwrap();
    let prefixes = "";
    let ignore = vec![".git", "target"];

    // print root dir
    println!("\n\n{}", path_str);
    // default symbols
    let tree = TextTreeElements::default();
    // 0 - root, 0 - first item of 1 - max items
    list_files(&path, Some(&ignore), &tree, prefixes, 0, 0, 1);

    // print root dir
    println!("\n\n{}", path_str);
    // custom symbols
    let tree = TextTreeElements::new(["", "", "|  ", "   "], ["", "", "|- ", "'- "]);
    // 0 - root, 0 - first item of 1 - max items
    list_files(&path, Some(&ignore), &tree, prefixes, 0, 0, 1);

    // print root dir
    println!("\n\n{}", path_str);
    // custom symbols
    let tree = TextTreeElements::new(["", "", "   ", "   "], ["", "", "   ", "   "]);
    // 0 - root, 0 - first item of 1 - max items
    list_files(&path, Some(&ignore), &tree, prefixes, 0, 0, 1);
}

pub fn get_prefix(&self, level: usize, index: usize, size: usize) -> &'a str

Function returns the current item prefix, depending on the position in the children list, and depth level

• prefixes - all prefixes from previous level
• level - current depth level of the tree (0 - for the root item)
• index - current item index (0 - for the first item)
• size - items num (items number on the current level), will be used for detecting of the last item

pub fn get_branch(&self, level: usize, index: usize, size: usize) -> &'a str

Function returns the current tree item branch symbol, depending on the position in the children list, and depth level

• level - current depth level of the tree (0 - for the root item)
• index - current item index (0 - for the first item)
• size - items num (items number on the current level), will be used for detecting of the last item

pub fn get_prefix_branch( &self, level: usize, index: usize, size: usize, ) -> (&'a str, &'a str)

Function returns a tuple containing both a prefix and a branch, depending on the position in the children list, and depth level

• level - current depth level of the tree (0 - for the root item)
• index - current item index (0 - for the first item)
• size - items num (items number on the current level), will be used for detecting of the last item

Examples found in repository

examples/example_1.rs (line 24)

fn list_files(
    path: &Path,
    ignore: Option<&Vec<&str>>,
    tree: &TextTreeElements,
    prefixes: &str,
    level: usize,
    index: usize,
    size: usize,
) {
    let (prefix, branch) = tree.get_prefix_branch(level, index, size);

    // skip "." path, doesn't have file name
    if let Some(file_name) = path.file_name() {
        let file_name = file_name.to_str().unwrap();

        // skip if in ignore list
        if let Some(v) = ignore {
            if v.contains(&file_name) {
                return;
            }
        }

        println!("{}{}{}", prefixes, branch, file_name);
    }

    // if dir contains files?
    if let Ok(files) = fs::read_dir(path) {
        let files = files.collect::<Result<Vec<_>, _>>().unwrap();

        let prefixes = format!("{}{}", prefixes, prefix);
        let size = files.len();

        // for all children files
        for (i, file) in files.iter().enumerate() {
            let dir = file.path();
            // recursive call
            list_files(&dir, ignore, tree, &prefixes, level + 1, i, size)
        }
    }
}

Trait Implementations

impl<'a> Debug for TextTreeElements<'a>

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

Formats the value using the given formatter.

impl<'a> Default for TextTreeElements<'a>

fn default() -> Self

Returns the “default value” for a type.