rorschach 0.1.3

Binary data definition and formatter.
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use std::io::{self, Read, Write};
use ansi_term;
use {Formatter, Definition, Field};
use super::Style;

/// Inline formatter, just puts bytes one after another as hex.
#[derive(Clone, Copy, PartialEq, Debug)]
pub struct Inline {
	split:   usize,
	newline: bool,
	style:   Option<Style>,
}

impl Default for Inline {
	fn default() -> Self {
		Inline {
			split:   1,
			newline: false,
			style:   None,
		}
	}
}

impl Inline {
	/// Adds a space every given bytes.
	pub fn split(mut self, value: usize) -> Self {
		self.split = value;
		self
	}

	/// Whether to print a newline or not at the end.
	pub fn newline(mut self, value: bool) -> Self {
		self.newline = value;
		self
	}

	/// The default colors, once set it will always color the output.
	pub fn style(mut self, value: Style) -> Self {
		self.style = Some(value);
		self
	}
}

impl Formatter for Inline {
	fn format<R: Read, W: Write>(&self, def: &Definition, mut input: R, output: W) -> io::Result<()> {
		let mut printer = Printer { newline: self.newline, split: self.split, printed: 0, output: output };

		for field in def.fields() {
			match field {
				&Field::Named(ref field) => {
					try!(printer.print(&try!(field.read(input.by_ref())),
						self.style.and(field.style())));
				}

				&Field::Constant(ref field) => {
					let data = try!(field.read(input.by_ref()));

					try!(printer.print(&data,
						self.style.map(|s| if data == field.value() {
							s.constant.0
						}
						else {
							s.constant.1
						})));
				}

				&Field::Garbage(ref field) => {
					try!(printer.print(&try!(field.read(input.by_ref())),
						self.style.map(|s| s.garbage)));
				}

				&Field::Unknown(ref field) => {
					try!(printer.print(&try!(field.read(input.by_ref())),
						self.style.map(|s| s.unknown)));
				}

				&Field::Padding(ref field) => {
					for byte in try!(field.read(input.by_ref())) {
						try!(printer.print(&[byte][..],
							self.style.map(|s| if byte != 0 {
								s.padding.1
							}
							else {
								s.padding.0
							})));
					}
				}
			}
		}

		printer.finish()
	}
}

struct Printer<W: Write> {
	split:   usize,
	newline: bool,
	printed: usize,
	output:  W,
}

impl<W: Write> Printer<W> {
	pub fn print(&mut self, input: &[u8], style: Option<ansi_term::Style>) -> io::Result<()> {
		for byte in input {
			let string = format!("{:02x}", byte);

			if let Some(style) = style {
				try!(write!(self.output, "{}", style.paint(string)));
			}
			else {
				try!(write!(self.output, "{}", string));
			}

			if self.split > 0 && (self.printed + 1) % self.split == 0 {
				try!(write!(self.output, " "));
			}

			self.printed += 1;
		}

		Ok(())
	}

	pub fn finish(&mut self) -> io::Result<()> {
		if self.newline {
			try!(writeln!(self.output, ""));
		}

		Ok(())
	}
}