file-utils 0.1.5

Convenience wrappers for file I/O, mostly around binary operations.
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


use std::io;

use conversions::u::*;
use conversions::i::*;
use conversions::f::*;

pub trait Write
{
	// Conditional
	fn write_usize(&mut self, val: usize)-> io::Result<()>;
	fn write_isize(&mut self, val: isize)-> io::Result<()>;

	// 8-bit
	fn write_u8(&mut self, val: u8)-> io::Result<()>;
	fn write_i8(&mut self, val: i8)-> io::Result<()>;

	// 16-bit
	fn write_u16(&mut self, val: u16)-> io::Result<()>;
	fn write_i16(&mut self, val: i16)-> io::Result<()>;

	// 32-bit
	fn write_u32(&mut self, val: u32)-> io::Result<()>;
	fn write_i32(&mut self, val: i32)-> io::Result<()>;
	fn write_f32(&mut self, val: f32)-> io::Result<()>;

	// 64-bit
	fn write_u64(&mut self, val: u64)-> io::Result<()>;
	fn write_i64(&mut self, val: i64)-> io::Result<()>;
	fn write_f64(&mut self, val: f64)-> io::Result<()>;
}

impl<T> Write for T 
	where T: io::Write
{
	/*
		Based on architecture
	*/
	#[cfg(target_pointer_width = "64")]
	fn write_usize(&mut self, val: usize)-> io::Result<()>
	{
		self.write_u64(val as u64)
	}

	#[cfg(target_pointer_width = "32")]
	fn write_usize(&mut self, val: usize)-> io::Result<()>
	{
		self.write_u32(val as u32)
	}

	#[cfg(target_pointer_width = "64")]
	fn write_isize(&mut self, val: isize)-> io::Result<()>
	{
		self.write_i64(val as i64)
	}

	#[cfg(target_pointer_width = "32")]
	fn write_isize(&mut self, val: isize)-> io::Result<()>
	{
		self.write_i32(val as i32)
	}

	/*
		8-bit
	*/
	fn write_u8(&mut self, val: u8)-> io::Result<()>
	{
		self.write_all(&[val])
	}

	fn write_i8(&mut self, val: i8)-> io::Result<()>
	{
		self.write_all(&[val as u8])
	}

	/*
		16-bit
	*/
	fn write_u16(&mut self, val: u16)-> io::Result<()>
	{
		self.write_all(&u16_to_bytes(val))
	}

	fn write_i16(&mut self, val: i16)-> io::Result<()>
	{
		self.write_all(&i16_to_bytes(val))
	}

	/*
		32-bit
	*/
	fn write_u32(&mut self, val: u32)-> io::Result<()>
	{
		self.write_all(&u32_to_bytes(val))
	}

	fn write_i32(&mut self, val: i32)-> io::Result<()>
	{
		self.write_all(&i32_to_bytes(val))
	}
	
	fn write_f32(&mut self, val: f32)-> io::Result<()>
	{
		self.write_all(&f32_to_bytes(val))
	}

	/*
		64-bit
	*/
	fn write_u64(&mut self, val: u64)-> io::Result<()>
	{
		self.write_all(&u64_to_bytes(val))
	}

	fn write_i64(&mut self, val: i64)-> io::Result<()>
	{
		self.write_all(&i64_to_bytes(val))
	}
	
	fn write_f64(&mut self, val: f64)-> io::Result<()>
	{
		self.write_all(&f64_to_bytes(val))
	}
}