packet 0.1.4

Network packet handling.
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

//            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
//                    Version 2, December 2004
//
// Copyleft (ↄ) meh. <meh@schizofreni.co> | http://meh.schizofreni.co
//
// Everyone is permitted to copy and distribute verbatim or modified
// copies of this license document, and changing it is allowed as long
// as the name is changed.
//
//            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
//   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
//
//  0. You just DO WHAT THE FUCK YOU WANT TO.

use std::ops::{Deref, DerefMut};

use crate::error::*;

/// A growable buffer.
#[derive(Clone, Eq, PartialEq, Default, Debug)]
pub struct Buffer {
	inner: Vec<u8>,

	offset: usize,
	length: usize,
}

impl Buffer {
	/// Create a new growable buffer.
	pub fn new() -> Self {
		Default::default()
	}
}

impl super::Buffer for Buffer {
	type Inner = Vec<u8>;

	fn into_inner(self) -> Self::Inner {
		self.inner
	}

	fn next(&mut self, size: usize) -> Result<()> {
		self.offset += self.length;
		self.length  = size;

		let current = self.inner.len();
		self.inner.resize(current + size, 0);

		Ok(())
	}

	fn more(&mut self, size: usize) -> Result<()> {
		let current = self.inner.len();
		self.inner.resize(current + size, 0);
		self.length += size;

		Ok(())
	}

	fn clear(&mut self) {
		self.inner.clear();
		self.offset = 0;
		self.length = 0;
	}

	fn used(&self) -> usize {
		self.inner.len()
	}

	fn offset(&self) -> usize {
		self.offset
	}

	fn length(&self) -> usize {
		self.length
	}

	fn data(&self) -> &[u8] {
		&self.inner[self.offset .. self.offset + self.length]
	}

	fn data_mut(&mut self) -> &mut [u8] {
		&mut self.inner[self.offset .. self.offset + self.length]
	}
}

impl Into<Vec<u8>> for Buffer {
	fn into(self) -> Vec<u8> {
		self.inner
	}
}

impl AsRef<[u8]> for Buffer {
	fn as_ref(&self) -> &[u8] {
		use super::Buffer;
		self.data()
	}
}

impl AsMut<[u8]> for Buffer {
	fn as_mut(&mut self) -> &mut [u8] {
		use super::Buffer;
		self.data_mut()
	}
}

impl Deref for Buffer {
	type Target = [u8];

	fn deref(&self) -> &Self::Target {
		use super::Buffer;
		self.data()
	}
}

impl DerefMut for Buffer {
	fn deref_mut(&mut self) -> &mut Self::Target {
		use super::Buffer;
		self.data_mut()
	}
}