devone 0.2.0

In addition to /dev/zero, aka, a UNIX virtual device, it can simulate /dev/one.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use clap::Parser;
use std::{fs::*, io::*, os::unix::fs::FileExt};
#[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,
    #[arg(default_value_t = 0, short, long)]
    ///always outputing
    nonstop: u8,
}
fn main() -> Result<()> {
    let args = Cli::parse();
    let val: [u8; 1] = if args.val == 0 {
        [0b0000_0000]
    } else if args.val == 1 {
        [0b1111_1111]
    } else {
        [args.val]
    };

    let d = |mut f: File| f.flush();
    let of = || {
        let f = OpenOptions::new()
            .create(true)
            .write(true)
            .append(args.append)
            .open(&args.of)
            .unwrap();
        f
    };
    let w: Box<dyn Fn(&[u8], u64) -> Result<()>> = if args.of == String::new() {
        Box::new(|v, _| stdout().write_all(v))
    } else {
        Box::new(|v, p| {
            let f = of();
            if let Err(e) = f.write_at(v, p) {
                Err(e)
            } else {
                let mut h = Ok(());
                if let Err(e) = d(f) {
                    h = Err(e)
                }
                h
            }
        })
    };
    let w: Box<dyn Fn() -> Result<()>> = if args.r#if == String::new() {
        Box::new(|| w(&val, 0))
    } else {
        Box::new(|| {
            let f = File::open(&args.r#if)?;
            let mut b = [0u8; 1];
            let mut p = 0u64;
            loop {
                if let Ok(0) = f.read_at(&mut b, p) {
                    break Ok(());
                }
                if let Err(e) = w(&b, p) {
                    break Err(e);
                }
                p += 1
            }
        })
    };

    if args.nonstop > 0 {
        loop {
            if let Err(e) = w() {
                break Err(e);
            }
        }
    } else {
        w()
    }
}