linefeed 0.5.4

Interactive terminal input reader
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
103
104
105
106
107
108
109
110
111
112
113

extern crate linefeed;

use std::io;

use linefeed::{Interface, ReadResult, Signal};

fn main() -> io::Result<()> {
    let interface = Interface::new("signal-demo")?;

    interface.set_prompt("signals> ")?;

    // Report all signals to application
    interface.set_report_signal(Signal::Break, true);
    interface.set_report_signal(Signal::Continue, true);
    interface.set_report_signal(Signal::Interrupt, true);
    interface.set_report_signal(Signal::Suspend, true);
    interface.set_report_signal(Signal::Quit, true);

    loop {
        let res = interface.read_line()?;

        match res {
            ReadResult::Eof => break,
            ReadResult::Input(line) => {
                let mut words = line.split_whitespace();

                match words.next() {
                    Some("help") => {
                        println!("linefeed signals demo commands:");
                        println!();
                        println!("  show            - Show which signals are ignored or reported");
                        println!("  report <sig>    - Start reporting a signal");
                        println!("  -report <sig>   - Stop reporting a signal");
                        println!("  ignore <sig>    - Start ignoring a signal");
                        println!("  -ignore <sig>   - Stop ignoring a signal");
                        println!();
                    }
                    Some("show") => {
                        for &sig in SIGNALS {
                            if interface.ignore_signal(sig) {
                                println!("ignoring {:?}", sig);
                            }
                            if interface.report_signal(sig) {
                                println!("reporting {:?}", sig);
                            }
                        }
                    }
                    Some("report") => {
                        for name in words {
                            if let Some(sig) = signal_by_name(name) {
                                interface.set_report_signal(sig, true);
                                println!("reporting signal {:?}", sig);
                            }
                        }
                    }
                    Some("-report") => {
                        for name in words {
                            if let Some(sig) = signal_by_name(name) {
                                interface.set_report_signal(sig, false);
                                println!("not reporting signal {:?}", sig);
                            }
                        }
                    }
                    Some("ignore") => {
                        for name in words {
                            if let Some(sig) = signal_by_name(name) {
                                interface.set_ignore_signal(sig, true);
                                println!("ignoring signal {:?}", sig);
                            }
                        }
                    }
                    Some("-ignore") => {
                        for name in words {
                            if let Some(sig) = signal_by_name(name) {
                                interface.set_ignore_signal(sig, false);
                                println!("not ignoring signal {:?}", sig);
                            }
                        }
                    }
                    _ => println!("read input: {:?}", line)
                }
            }
            ReadResult::Signal(sig) => {
                if sig == Signal::Interrupt {
                    interface.cancel_read_line()?;
                }

                let _ = writeln!(interface, "signal received: {:?}", sig);
            }
        }
    }

    Ok(())
}

const SIGNALS: &[Signal] = &[
    Signal::Break,
    Signal::Continue,
    Signal::Interrupt,
    Signal::Suspend,
    Signal::Quit,
];

fn signal_by_name(name: &str) -> Option<Signal> {
    match name {
        "break" => Some(Signal::Break),
        "cont" | "continue" => Some(Signal::Continue),
        "int" | "interrupt" => Some(Signal::Interrupt),
        "sus" | "suspend" => Some(Signal::Suspend),
        "quit" => Some(Signal::Quit),
        _ => None
    }
}