iptrie 0.11.1

IPv4/v6 prefixes lookup structures (based on tries)
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

//! Graphviz representation of tries
//!
//! This module is only dedicated to produce graphviz representation
//! of the tries for debugging purpose.
//!
use std::fs::File;
use std::io;
use std::io::Write;
use std::path::PathBuf;
use std::process::{Command, Stdio};

const DOTCMD: &str = "dot";

/// Display the inner structure of tries (require `dot` and the activation of feature __graphviz__).
pub trait DotWriter {
    /// Writes the trie structure in dot format
    fn write_dot(&self, dot: &mut dyn Write) -> io::Result<()>;

    /// Generates the trie structure in a pdf file using `dot` command.
    ///
    /// If a file name is specified, the pdf file is generated.
    /// If not, the output is redirected to standard output.
    ///
    /// # Panics
    /// Panics if the `dot` command was not found.
    fn generate_pdf_file(&self, file: Option<&str>) -> io::Result<()> {
        let child = match file {
            None => Command::new(DOTCMD)
                .arg("-Tpdf")
                .stdin(Stdio::piped())
                .spawn(),
            Some(filename) => {
                let mut path = PathBuf::from(filename);
                path.set_extension("pdf");
                eprintln!("write output in file: {}", path.display());

                Command::new(DOTCMD)
                    .arg("-Tpdf")
                    .arg("-o")
                    .arg(path)
                    .stdin(Stdio::piped())
                    .spawn()
            }
        };
        let child = match child {
            Err(why) => panic!("couldn't spawn dot: {}", why),
            Ok(process) => process,
        };
        let mut dot = child.stdin.unwrap();
        self.write_dot(&mut dot)
    }

    /// Prints the trie structure in graphviz format.
    ///
    /// If a file name is specified, the graphviz file is generated.
    /// If not, the output is redirected to standard output.
    fn generate_graphviz_file(&self, file: Option<&str>) -> io::Result<()> {
        match file {
            None => {
                let mut dot = io::stdout();
                self.write_dot(&mut dot)
            }
            Some(filename) => {
                let mut path = PathBuf::from(filename);
                path.set_extension("gv");
                eprintln!("write output in file: {}", path.to_string_lossy());
                let mut dot = File::create(path)?;
                self.write_dot(&mut dot)
            }
        }
    }

    #[doc(hidden)]
    #[cfg(target_os = "macos")]
    fn open_dot_view(&self) -> io::Result<()> {
        use std::os::unix::io::AsRawFd;
        use std::os::unix::io::FromRawFd;

        let dot = match Command::new(DOTCMD)
            .arg("-Tpdf")
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .spawn()
        {
            Err(why) => panic!("couldn't spawn dot: {}", why),
            Ok(process) => process,
        };
        // sur mac seulement...
        unsafe {
            Command::new("open")
                .arg("-f")
                .arg("-a")
                .arg("Preview")
                .stdin(Stdio::from_raw_fd(dot.stdout.unwrap().as_raw_fd()))
                .spawn()?;
        }
        let mut dot = dot.stdin.unwrap();
        self.write_dot(&mut dot)
    }
}