devone 0.1.0

use clap::Parser;
use std::{
    fs::*,
    io::{self, *},
    str,
};
#[derive(Parser)]
struct Cli {
    #[arg(default_value_t = 1)]
    ///specify 0 or 1 to output
    val: u8,
    #[arg(default_value_t = String::new(), short, long)]
    ///input file
    r#if: String,
    #[arg(default_value_t = String::new(), short, long)]
    ///output file
    of: String,
    #[arg(default_value_t = false, short, long)]
    ///append instead of overwrite
    append: bool,
}
fn main() -> io::Result<()> {
    let mut args = Cli::parse();
    let val: Box<[u8]> = if args.val == 0 {
        Box::new([0b0000_0000])
    } else if args.val == 1 {
        Box::new([0b1111_1111])
    } else {
        Box::new([args.val])
    };

    let mut w: Box<dyn Fn(&[u8]) -> io::Result<()>> = if args.of == String::new() {
        Box::new(|v| {
            let mut E = Ok(());
            if let Err(e) = io::stdout().write_all(v) {
                E = Err(e)
            }
            E
        })
    } else {
        Box::new(|v| {
            let mut f = OpenOptions::new()
                .create(true)
                .write(true)
                .append(args.append)
                .open(&args.of)?;
            let mut E = Ok(());
            if let Err(e) = f.write_all(v) {
                E = Err(e)
            }
            E
        })
    };

    if args.r#if == String::new() {
        let mut E = Ok(());
        loop {
            if let Err(e) = w(&val) {
                E = Err(e);
                break;
            }
        }
        E
    } else {
        let mut E = Ok(());
        loop {
            let f = File::open(&args.r#if).unwrap();
            let R = BufReader::new(f);
            for l in R.lines() {
                if let Err(e) = w((l.unwrap() + "\n").as_bytes()) {
                    E = Err(e);
                    break;
                }
            }
            if let Err(_) = E {
                break;
            }
        }
        E
    }
}