Struct ListOption

pub struct ListOption { /* private fields */ }

Implementations

impl ListOption

specify the list option

pub fn new() -> Self

pub fn dir(&mut self, if_show: bool) -> &mut Self

set if allow this option to show directories

Examples found in repository

examples/list_unexisted_dir.rs (line 4)

fn main() {
    use ls_option::ListOption;
    dbg!(ListOption::default()
        .dir(true)
        .file(true)
        .hidden(false)
        .unhidden(true)
        .recursive(true)
        .level(1)
        .list("unexisted_dir"));
}

examples/list_all_rs.rs (line 5)

fn main() {
    use ls_option::*;
    let fs = ListOption::default()
        .file(true)
        .dir(false)
        .unhidden(true)
        .hidden(false)
        .recursive(true)
        .sufs(vec![".rs"])
        .list(".");
    dbg!(fs);
}

examples/list_all_hidden_dir.rs (line 4)

fn main() {
    use ls_option::ListOption;
    dbg!(ListOption::default()
        .dir(true)
        .file(false)
        .hidden(true)
        .unhidden(false)
        .hidden(true)
        .recursive(false)
        .level(1)
        .list("."));
}

pub fn file(&mut self, if_show: bool) -> &mut Self

set if allow this option to show files

Examples found in repository

examples/list_unexisted_dir.rs (line 5)

fn main() {
    use ls_option::ListOption;
    dbg!(ListOption::default()
        .dir(true)
        .file(true)
        .hidden(false)
        .unhidden(true)
        .recursive(true)
        .level(1)
        .list("unexisted_dir"));
}

examples/list_all_rs.rs (line 4)

fn main() {
    use ls_option::*;
    let fs = ListOption::default()
        .file(true)
        .dir(false)
        .unhidden(true)
        .hidden(false)
        .recursive(true)
        .sufs(vec![".rs"])
        .list(".");
    dbg!(fs);
}

examples/list_all_hidden_dir.rs (line 5)

fn main() {
    use ls_option::ListOption;
    dbg!(ListOption::default()
        .dir(true)
        .file(false)
        .hidden(true)
        .unhidden(false)
        .hidden(true)
        .recursive(false)
        .level(1)
        .list("."));
}

pub fn hidden(&mut self, if_show: bool) -> &mut Self

set if allow this option to show hidden files

Examples found in repository

examples/list_unexisted_dir.rs (line 6)

fn main() {
    use ls_option::ListOption;
    dbg!(ListOption::default()
        .dir(true)
        .file(true)
        .hidden(false)
        .unhidden(true)
        .recursive(true)
        .level(1)
        .list("unexisted_dir"));
}

examples/list_all_rs.rs (line 7)

fn main() {
    use ls_option::*;
    let fs = ListOption::default()
        .file(true)
        .dir(false)
        .unhidden(true)
        .hidden(false)
        .recursive(true)
        .sufs(vec![".rs"])
        .list(".");
    dbg!(fs);
}

examples/list_all_hidden_dir.rs (line 6)

fn main() {
    use ls_option::ListOption;
    dbg!(ListOption::default()
        .dir(true)
        .file(false)
        .hidden(true)
        .unhidden(false)
        .hidden(true)
        .recursive(false)
        .level(1)
        .list("."));
}

pub fn unhidden(&mut self, if_show: bool) -> &mut Self

set if allow this option to show unhidden files

Examples found in repository

examples/list_unexisted_dir.rs (line 7)

fn main() {
    use ls_option::ListOption;
    dbg!(ListOption::default()
        .dir(true)
        .file(true)
        .hidden(false)
        .unhidden(true)
        .recursive(true)
        .level(1)
        .list("unexisted_dir"));
}

examples/list_all_rs.rs (line 6)

fn main() {
    use ls_option::*;
    let fs = ListOption::default()
        .file(true)
        .dir(false)
        .unhidden(true)
        .hidden(false)
        .recursive(true)
        .sufs(vec![".rs"])
        .list(".");
    dbg!(fs);
}

examples/list_all_hidden_dir.rs (line 7)

fn main() {
    use ls_option::ListOption;
    dbg!(ListOption::default()
        .dir(true)
        .file(false)
        .hidden(true)
        .unhidden(false)
        .hidden(true)
        .recursive(false)
        .level(1)
        .list("."));
}

pub fn level(&mut self, level: usize) -> &mut Self

set the level of recursion while listing files in some path

Examples found in repository

examples/list_unexisted_dir.rs (line 9)

fn main() {
    use ls_option::ListOption;
    dbg!(ListOption::default()
        .dir(true)
        .file(true)
        .hidden(false)
        .unhidden(true)
        .recursive(true)
        .level(1)
        .list("unexisted_dir"));
}

examples/list_all_hidden_dir.rs (line 10)

fn main() {
    use ls_option::ListOption;
    dbg!(ListOption::default()
        .dir(true)
        .file(false)
        .hidden(true)
        .unhidden(false)
        .hidden(true)
        .recursive(false)
        .level(1)
        .list("."));
}

pub fn recursive(&mut self, if_choose: bool) -> &mut Self

set if allow this option to list recursively

Examples found in repository

examples/list_unexisted_dir.rs (line 8)

fn main() {
    use ls_option::ListOption;
    dbg!(ListOption::default()
        .dir(true)
        .file(true)
        .hidden(false)
        .unhidden(true)
        .recursive(true)
        .level(1)
        .list("unexisted_dir"));
}

examples/list_all_rs.rs (line 8)

fn main() {
    use ls_option::*;
    let fs = ListOption::default()
        .file(true)
        .dir(false)
        .unhidden(true)
        .hidden(false)
        .recursive(true)
        .sufs(vec![".rs"])
        .list(".");
    dbg!(fs);
}

examples/list_all_hidden_dir.rs (line 9)

fn main() {
    use ls_option::ListOption;
    dbg!(ListOption::default()
        .dir(true)
        .file(false)
        .hidden(true)
        .unhidden(false)
        .hidden(true)
        .recursive(false)
        .level(1)
        .list("."));
}

pub fn ext(&mut self, ext: &str) -> &mut Self

add one ext to the list of allowed extensions

only files with one of these extensions will be listed

e.g. ext(“rs”) will allow files with .rs extension to be listed

e.g. ext(“rs”).ext(“toml”) will allow files with .rs and .toml extensions to be listed

pub fn exts(&mut self, exts: Vec<&str>) -> &mut Self

add multiple exts to the list of allowed extensions

only files with one of these extensions will be listed

but this function will shadow the previous sufs

e.g. exts(vec![“rs”, “toml”]) will allow files with .rs and .toml extensions to be listed

e.g. exts(vec![“rs”]).exts(vec![“toml”]) will only allow files with .toml extensions to be listed

pub fn suf(&mut self, suf: &str) -> &mut Self

add one suf to the list of allowed suffixes, only files with one of these suffixes will be listed

e.g. suf(“rs”) will allow files with rs suffix to be listed

notice that exts function will shadow the previous sufs

e.g. suf(“.rs”).ext(“toml”) will only allow files with .rs and .toml extensions to be listed

e.g. suf(“.rs”).suf(“.toml”) will only allow files with .toml extensions to be listed

e.g. suf(“rs”).exts(vec![“toml”]) will only allow files with .toml extensions to be listed

pub fn sufs(&mut self, sufs: Vec<&str>) -> &mut Self

add multiple sufs to the list of allowed suffixes

only files with one of these suffixes will be listed

but this function will shadow the previous sufs

e.g. sufs(vec![“rs”, “toml”]) will allow files with rs and toml suffixes to be listed

e.g. sufs(vec![“.rs”]).sufs(vec![“.toml”]) will only allow files with .toml extensions to be listed

e.g. sufs(vec![“.rs”]).ext(“toml”) will allow files with .rs or .toml extension to be listed

e.g. sufs(vec![“rs”]).exts(vec![“toml”]) will only allow files with .toml extensions to be listed

Examples found in repository

examples/list_all_rs.rs (line 9)

fn main() {
    use ls_option::*;
    let fs = ListOption::default()
        .file(true)
        .dir(false)
        .unhidden(true)
        .hidden(false)
        .recursive(true)
        .sufs(vec![".rs"])
        .list(".");
    dbg!(fs);
}

impl ListOption

pub fn only_dir(&mut self) -> &mut Self

pub fn only_file(&mut self) -> &mut Self

pub fn only_hidden(&mut self) -> &mut Self

pub fn only_unhidden(&mut self) -> &mut Self

impl ListOption

impl list functionality

pub fn list<S>(&self, path: &S) -> Vec<String>

where S: AsRef<OsStr> + ?Sized,

Lists the files and directories at the given path according to the options set in the ListOption

if the path is a file, it will be listed if it matches the options set in the ListOption

if the path is a directory, all files and directories in it will be listed if they match the options set in the ListOption

Examples found in repository

examples/list_unexisted_dir.rs (line 10)

fn main() {
    use ls_option::ListOption;
    dbg!(ListOption::default()
        .dir(true)
        .file(true)
        .hidden(false)
        .unhidden(true)
        .recursive(true)
        .level(1)
        .list("unexisted_dir"));
}

examples/list_all_rs.rs (line 10)

fn main() {
    use ls_option::*;
    let fs = ListOption::default()
        .file(true)
        .dir(false)
        .unhidden(true)
        .hidden(false)
        .recursive(true)
        .sufs(vec![".rs"])
        .list(".");
    dbg!(fs);
}

examples/list_all_hidden_dir.rs (line 11)

fn main() {
    use ls_option::ListOption;
    dbg!(ListOption::default()
        .dir(true)
        .file(false)
        .hidden(true)
        .unhidden(false)
        .hidden(true)
        .recursive(false)
        .level(1)
        .list("."));
}

pub fn would_show<S>(&self, path: &S) -> bool

where S: AsRef<OsStr> + ?Sized,

check if the path would be shown according to the options set in the ListOption

Trait Implementations

impl Clone for ListOption

fn clone(&self) -> ListOption

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ListOption

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

Formats the value using the given formatter.

impl Default for ListOption

fn default() -> Self

Returns the “default value” for a type.