Struct CommandFS

pub struct CommandFS<'a> {
    pub dir: &'a Path,
    pub err_msg: String,
}

Fields

dir: &'a Path

err_msg: String

Implementations

impl<'a> CommandFS<'a>

pub fn new(dir: &'a str) -> Self

let mut command = CommandFS::new("/");

It will create CommandFS struct which contain two Field. file_dir (File or Directory), err_msg (For Safety every error message is store in err_msg field)

Examples found in repository

examples/read/main.rs (line 5)

async fn main() {
    let mut command = CommandFS::new("/");
    let home_dir = command.know_home_dir();
    command.change_dir(home_dir.as_str());

    let search = ".bash";

    // Print every file content
    // Method 1
    for file in command.query_file(search, true) {
        println!("{file}");
        println!(
            "{}",
            String::from_utf8(command.read_data(file.as_str()).await).unwrap()
        );
        println!("{}", command.err_msg);
    }

    // Method 2
    for file in command.query_file(search, true) {
        println!("{file}");
        println!(
            "{}",
            String::from_utf8(&mut command >> file.as_str()).unwrap()
        );
        println!("{}", command.err_msg);
    }
}

examples/write/main.rs (line 6)

async fn main() {
    // Method 1 For Async
    let mut command = CommandFS::new("/");
    let home_dir = command.know_home_dir();
    command.change_dir(home_dir.as_str());
    command
        .write_data(b"It's November".to_vec(), "metadata.txt")
        .await;
    println!(
        "{}",
        String::from_utf8(command.read_data("metadata.txt").await).unwrap()
    ); // Print Content Asynchronously
    println!("{}", command.err_msg);

    // Method 2 For Sync
    let mut command = CommandFS::new("/");
    command >>= home_dir.as_str();
    command += "mydir";
    command >>= "mydir";
    command += ("metadata.txt", b"It's January Now");
    println!(
        "{}",
        String::from_utf8(&mut command >> "metadata.txt").unwrap()
    ); // Print Content Normally
}

pub async fn read_data(&mut self, from_file: &str) -> Vec<u8>

let mut command = CommandFS::new("/home/username"); // For Unix System
command.read_data(".bashrc"); // If you see Empty it means file Doesn't exist or something.
println!("{}", command.err_msg); // It'll print error message without any panic

Examples found in repository

examples/read/main.rs (line 17)

async fn main() {
    let mut command = CommandFS::new("/");
    let home_dir = command.know_home_dir();
    command.change_dir(home_dir.as_str());

    let search = ".bash";

    // Print every file content
    // Method 1
    for file in command.query_file(search, true) {
        println!("{file}");
        println!(
            "{}",
            String::from_utf8(command.read_data(file.as_str()).await).unwrap()
        );
        println!("{}", command.err_msg);
    }

    // Method 2
    for file in command.query_file(search, true) {
        println!("{file}");
        println!(
            "{}",
            String::from_utf8(&mut command >> file.as_str()).unwrap()
        );
        println!("{}", command.err_msg);
    }
}

examples/write/main.rs (line 14)

async fn main() {
    // Method 1 For Async
    let mut command = CommandFS::new("/");
    let home_dir = command.know_home_dir();
    command.change_dir(home_dir.as_str());
    command
        .write_data(b"It's November".to_vec(), "metadata.txt")
        .await;
    println!(
        "{}",
        String::from_utf8(command.read_data("metadata.txt").await).unwrap()
    ); // Print Content Asynchronously
    println!("{}", command.err_msg);

    // Method 2 For Sync
    let mut command = CommandFS::new("/");
    command >>= home_dir.as_str();
    command += "mydir";
    command >>= "mydir";
    command += ("metadata.txt", b"It's January Now");
    println!(
        "{}",
        String::from_utf8(&mut command >> "metadata.txt").unwrap()
    ); // Print Content Normally
}

pub async fn write_data(&mut self, data: Vec<u8>, to_file: &'a str)

let mut command = CommandFS::new("/home/username"); // For Unix System
command.read_data(".bashrc").await; // If you see Empty it means file Doesn't exist or something.

Examples found in repository

examples/write/main.rs (line 10)

async fn main() {
    // Method 1 For Async
    let mut command = CommandFS::new("/");
    let home_dir = command.know_home_dir();
    command.change_dir(home_dir.as_str());
    command
        .write_data(b"It's November".to_vec(), "metadata.txt")
        .await;
    println!(
        "{}",
        String::from_utf8(command.read_data("metadata.txt").await).unwrap()
    ); // Print Content Asynchronously
    println!("{}", command.err_msg);

    // Method 2 For Sync
    let mut command = CommandFS::new("/");
    command >>= home_dir.as_str();
    command += "mydir";
    command >>= "mydir";
    command += ("metadata.txt", b"It's January Now");
    println!(
        "{}",
        String::from_utf8(&mut command >> "metadata.txt").unwrap()
    ); // Print Content Normally
}

pub fn change_dir(&mut self, dir: &'a str)

Examples found in repository

examples/read/main.rs (line 7)

async fn main() {
    let mut command = CommandFS::new("/");
    let home_dir = command.know_home_dir();
    command.change_dir(home_dir.as_str());

    let search = ".bash";

    // Print every file content
    // Method 1
    for file in command.query_file(search, true) {
        println!("{file}");
        println!(
            "{}",
            String::from_utf8(command.read_data(file.as_str()).await).unwrap()
        );
        println!("{}", command.err_msg);
    }

    // Method 2
    for file in command.query_file(search, true) {
        println!("{file}");
        println!(
            "{}",
            String::from_utf8(&mut command >> file.as_str()).unwrap()
        );
        println!("{}", command.err_msg);
    }
}

examples/write/main.rs (line 8)

async fn main() {
    // Method 1 For Async
    let mut command = CommandFS::new("/");
    let home_dir = command.know_home_dir();
    command.change_dir(home_dir.as_str());
    command
        .write_data(b"It's November".to_vec(), "metadata.txt")
        .await;
    println!(
        "{}",
        String::from_utf8(command.read_data("metadata.txt").await).unwrap()
    ); // Print Content Asynchronously
    println!("{}", command.err_msg);

    // Method 2 For Sync
    let mut command = CommandFS::new("/");
    command >>= home_dir.as_str();
    command += "mydir";
    command >>= "mydir";
    command += ("metadata.txt", b"It's January Now");
    println!(
        "{}",
        String::from_utf8(&mut command >> "metadata.txt").unwrap()
    ); // Print Content Normally
}

pub fn step_back(&mut self, step: usize)

pub async fn remove(&mut self, file: &str)

pub fn rename(&mut self, from_file: &str, rename: &str)

impl<'a> CommandFS<'a>

pub fn whereami(&mut self) -> &str

pub fn know_home_dir(&mut self) -> String

Examples found in repository

examples/read/main.rs (line 6)

async fn main() {
    let mut command = CommandFS::new("/");
    let home_dir = command.know_home_dir();
    command.change_dir(home_dir.as_str());

    let search = ".bash";

    // Print every file content
    // Method 1
    for file in command.query_file(search, true) {
        println!("{file}");
        println!(
            "{}",
            String::from_utf8(command.read_data(file.as_str()).await).unwrap()
        );
        println!("{}", command.err_msg);
    }

    // Method 2
    for file in command.query_file(search, true) {
        println!("{file}");
        println!(
            "{}",
            String::from_utf8(&mut command >> file.as_str()).unwrap()
        );
        println!("{}", command.err_msg);
    }
}

examples/write/main.rs (line 7)

async fn main() {
    // Method 1 For Async
    let mut command = CommandFS::new("/");
    let home_dir = command.know_home_dir();
    command.change_dir(home_dir.as_str());
    command
        .write_data(b"It's November".to_vec(), "metadata.txt")
        .await;
    println!(
        "{}",
        String::from_utf8(command.read_data("metadata.txt").await).unwrap()
    ); // Print Content Asynchronously
    println!("{}", command.err_msg);

    // Method 2 For Sync
    let mut command = CommandFS::new("/");
    command >>= home_dir.as_str();
    command += "mydir";
    command >>= "mydir";
    command += ("metadata.txt", b"It's January Now");
    println!(
        "{}",
        String::from_utf8(&mut command >> "metadata.txt").unwrap()
    ); // Print Content Normally
}

pub fn dir_list(&mut self) -> Vec<String>

pub fn file_list(&mut self) -> Vec<String>

pub fn file_dir_list(&mut self) -> Vec<String>

pub fn query_dir(&mut self, query: &'a str, accurate: bool) -> Vec<String>

pub fn query_file(&mut self, query: &'a str, accurate: bool) -> Vec<String>

Examples found in repository

examples/read/main.rs (line 13)

async fn main() {
    let mut command = CommandFS::new("/");
    let home_dir = command.know_home_dir();
    command.change_dir(home_dir.as_str());

    let search = ".bash";

    // Print every file content
    // Method 1
    for file in command.query_file(search, true) {
        println!("{file}");
        println!(
            "{}",
            String::from_utf8(command.read_data(file.as_str()).await).unwrap()
        );
        println!("{}", command.err_msg);
    }

    // Method 2
    for file in command.query_file(search, true) {
        println!("{file}");
        println!(
            "{}",
            String::from_utf8(&mut command >> file.as_str()).unwrap()
        );
        println!("{}", command.err_msg);
    }
}

pub fn query_file_dir(&mut self, query: &'a str, accurate: bool) -> Vec<String>

Trait Implementations

impl<'a> AddAssign<&'a str> for CommandFS<'a>

```rust

let mut command = CommandFS::new(“/home/username”); command += (“mydirectory”); ``` It will create Directory,

fn add_assign(&mut self, rhs: &'a str)

Performs the += operation.

impl<'a> AddAssign<(&'a str, &[u8])> for CommandFS<'a>

```rust

let mut command = CommandFS::new(“/home/username”); command += (“myfile.txt”, vec![66, 108, 97, 104,32,66, 108, 97, 104,32,66, 108, 97, 104,32,66, 108, 97, 104,32].as_bytes());

      It will create Create and Write File for non sync task but different is unknown Size.

fn add_assign(&mut self, rhs: (&'a str, &[u8]))

Performs the += operation.

impl<'a, const N: usize> AddAssign<(&'a str, &[u8; N])> for CommandFS<'a>

```rust

let mut command = CommandFS::new(“/home/username”); command += (“myfile.txt”, b“Blah Blah Blah Blah“);

      It will create Create and Write File for non sync task for known Size.

fn add_assign(&mut self, rhs: (&'a str, &[u8; N]))

Performs the += operation.

impl<'a> ShlAssign<usize> for CommandFS<'a>

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl<'a> Shr<&str> for &mut CommandFS<'a>

type Output = Vec<u8>

The resulting type after applying the >> operator.

fn shr(self, rhs: &str) -> Self::Output

Performs the >> operation.

impl<'a> ShrAssign<&str> for CommandFS<'a>

fn shr_assign(&mut self, rhs: &str)

Performs the >>= operation.

impl<'a> SubAssign<&str> for CommandFS<'a>

fn sub_assign(&mut self, rhs: &str)

Performs the -= operation.