icewrap 0.1.1

Port of Heatshrink to Rust
Documentation 
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use std::{
    env::args,
    io::{copy, stdin, stdout},
    process::exit,
};

use icewrap::{
    decode::{dyn_decoder_builder, PullDecoder, PushDecoder},
    encode::{dyn_encoder_builder, PullEncoder},
};

fn main() {
    let mut it = args().skip(1);
    let mode = it.next();

    match mode.as_deref() {
        Some("encode") => {
            let window = it
                .next()
                .and_then(|w| w.parse().ok())
                .expect("valid window");
            let lookahead = it
                .next()
                .and_then(|l| l.parse().ok())
                .expect("valid lookahead");
            let indexed = it.next().and_then(|i| i.parse().ok()).unwrap_or(true);

            let encoder =
                dyn_encoder_builder(window, lookahead, indexed).expect("valid encoder params")();
            let mut pull_encoder = PullEncoder::new(encoder, stdin());

            copy(&mut pull_encoder, &mut stdout()).expect("I/O succeeds");
            // Flush any remaining data
            copy(&mut pull_encoder.finish(), &mut stdout()).expect("I/O succeeds");
        }
        Some("decode") => {
            let window = it
                .next()
                .and_then(|w| w.parse().ok())
                .expect("valid window");
            let lookahead = it
                .next()
                .and_then(|l| l.parse().ok())
                .expect("valid lookahead");

            let mut decoder =
                dyn_decoder_builder(window, lookahead).expect("valid decoder params")();
            let mut pull_decoder = PullDecoder::new(&mut decoder, stdin());

            copy(&mut pull_decoder, &mut stdout()).expect("I/O succeeds");

            if !decoder.is_finished() {
                eprintln!("Data may be invalid, decoder did not finish!")
            }
        }
        Some("passthrough") => {
            let window = it
                .next()
                .and_then(|w| w.parse().ok())
                .expect("valid window");
            let lookahead = it
                .next()
                .and_then(|l| l.parse().ok())
                .expect("valid lookahead");
            let indexed = it.next().and_then(|i| i.parse().ok()).unwrap_or(true);

            let encoder =
                dyn_encoder_builder(window, lookahead, indexed).expect("valid encoder params")();
            let mut pull_encoder = PullEncoder::new(encoder, stdin());

            let mut decoder =
                dyn_decoder_builder(window, lookahead).expect("valid decoder params")();
            let mut push_decoder = PushDecoder::new(&mut decoder, stdout());

            copy(&mut pull_encoder, &mut push_decoder).expect("I/O succeeds");
            // Flush any remaining data
            copy(&mut pull_encoder.finish(), &mut push_decoder).expect("I/O succeeds");

            assert!(
                decoder.is_finished(),
                "Data may be invalid, decoder did not finish!"
            );
        }
        Some("help") | None => {
            eprintln!(
                "Usage:\n\
                cli [COMMAND]\n\
                \n\
                Commands:\n\
                \tencode [window] [lookahead] [indexed]\t\tencodes stdin to stdout\n\
                \tdecode [window] [lookahead]\t\t\tdecodes stdin to stdout\n\
                \tpassthrough [window] [lookahead] [indexed]\tpipes stdin through encoding and decoding to stdout\n\
                \thelp\n\
            "
            )
        }
        Some(_) => {
            eprintln!("Unknown command");
            exit(1);
        }
    }
}