ender 0.5.2

An encoding library to work with any binary data format
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

use crate::{Context, Decode, Encode, Encoder, EncodingResult};
use crate::io::{Read, Slice, SliceMut, Write};

/// Encodes the given value by constructing an encoder on the fly backed by a
/// [VecStream][`crate::io::VecStream`], then returning the wrapped vector of bytes.
/// 
/// Uses the default [`Context`]
#[cfg(feature = "alloc")]
#[cfg_attr(feature = "unstable", doc(cfg(feature = "alloc")))]
#[inline]
pub fn encode_bytes<V: Encode<crate::io::VecStream>>(value: V) -> EncodingResult<alloc::vec::Vec<u8>> {
	let stream = crate::io::VecStream::new(alloc::vec::Vec::new(), 0);
	let mut encoder = Encoder::new(stream, Context::default());
	value.encode(&mut encoder)?;
	Ok(encoder.stream.into_inner())
}

/// Decodes the given value by constructing an encoder on the fly and using it to wrap a byte
/// slice.
/// 
/// Uses the default [`Context`]
#[inline]
pub fn decode_bytes<'a, R: AsRef<[u8]>, V: Decode<Slice<'a>>>(bytes: &'a R) -> EncodingResult<V> {
	let mut decoder = Encoder::new(Slice::new(bytes.as_ref()), Context::default());
	V::decode(&mut decoder)
}

/// Decodes the given value by constructing an encoder on the fly and using it to wrap a byte
/// slice.
///
/// Uses the default [`Context`]
#[inline]
pub fn decode_bytes_owned<R: AsRef<[u8]>, V: for<'a> Decode<Slice<'a>>>(bytes: &R) -> EncodingResult<V> {
	let mut decoder = Encoder::new(Slice::new(bytes.as_ref()), Context::default());
	V::decode(&mut decoder)
}

/// Encodes the given value by constructing an encoder on the fly backed by a
/// [VecStream][`crate::io::VecStream`], then returning the wrapped vector of bytes
/// 
/// Uses the given [`Context`]
#[cfg(feature = "alloc")]
#[cfg_attr(feature = "unstable", doc(cfg(feature = "alloc")))]
#[inline]
pub fn encode_bytes_with<V: Encode<crate::io::VecStream>>(value: V, context: Context) -> EncodingResult<alloc::vec::Vec<u8>> {
	let stream = crate::io::VecStream::new(alloc::vec::Vec::new(), 0);
	let mut encoder = Encoder::new(stream, context);
	value.encode(&mut encoder)?;
	Ok(encoder.stream.into_inner())
}

/// Decodes the given value by constructing an encoder on the fly and using it to wrap a byte
/// slice.
/// 
/// Uses the given [`Context`]
#[inline]
pub fn decode_bytes_with<'a, R: AsRef<[u8]>, V: Decode<Slice<'a>>>(bytes: &'a R, context: Context) -> EncodingResult<V> {
	let mut decoder = Encoder::new(Slice::new(bytes.as_ref()), context);
	V::decode(&mut decoder)
}

/// Decodes the given value by constructing an encoder on the fly and using it to wrap a byte
/// slice.
///
/// Uses the given [`Context`]
#[inline]
pub fn decode_bytes_with_owned<R: AsRef<[u8]>, V: for<'a> Decode<Slice<'a>>>(bytes: &R, context: Context) -> EncodingResult<V> {
	let mut decoder = Encoder::new(Slice::new(bytes.as_ref()), context);
	V::decode(&mut decoder)
}

/// Encodes the given value by constructing an encoder on the fly and using it to wrap the writer,
/// with the default context.
#[inline]
pub fn encode<W: IntoWrite, V: Encode<W::Write>>(
	writer: W,
	value: V,
) -> EncodingResult<()> {
	let mut encoder = Encoder::new(writer.into_write(), Context::default());
	value.encode(&mut encoder)
}

/// Decodes the given value by constructing an encoder on the fly and using it to wrap the reader,
/// with the default context.
#[inline]
pub fn decode<R: IntoRead, V: Decode<R::Read>>(reader: R) -> EncodingResult<V> {
	let mut decoder = Encoder::new(reader.into_read(), Context::default());
	V::decode(&mut decoder)
}

/// Encodes the given value by constructing an encoder on the fly and using it to wrap the writer,
/// with the given context.
#[inline]
pub fn encode_with<W: IntoWrite, V: Encode<W::Write>>(
	writer: W,
	context: Context,
	value: V,
) -> EncodingResult<()> {
	let mut encoder = Encoder::new(writer.into_write(), context);
	value.encode(&mut encoder)
}

/// Decodes the given value by constructing an encoder on the fly and using it to wrap the reader,
/// with the given context.
#[inline]
pub fn decode_with<R: IntoRead, V: Decode<R::Read>>(reader: R, context: Context) -> EncodingResult<V> {
	let mut decoder = Encoder::new(reader.into_read(), context);
	V::decode(&mut decoder)
}

/// Something that can be turned into a writer compatible with [Encoder][`crate::Encoder`]
///
/// This is automatically implemented for some standard types, like byte slices and vectors of bytes.
pub trait IntoWrite {
	type Write: Write;
	/// Transforms `self` into a type implementing [Write][`crate::io::Write`]
	fn into_write(self) -> Self::Write;
}

impl<T: Write> IntoWrite for T {
	type Write = T;
	#[inline(always)]
	fn into_write(self) -> Self::Write {
		self
	}
}

impl<'a> IntoWrite for &'a mut [u8] {
	type Write = SliceMut<'a>;
	#[inline]
	fn into_write(self) -> Self::Write {
		SliceMut::new(self)
	}
}

#[cfg(feature = "alloc")]
#[cfg_attr(feature = "unstable", doc(cfg(feature = "alloc")))]
impl IntoWrite for alloc::vec::Vec<u8> {
	type Write = crate::io::VecStream;
	#[inline]
	fn into_write(self) -> Self::Write {
		crate::io::VecStream::new(self, 0)
	}
}

/// Something that can be turned into a reader compatible with [Encoder][`crate::Encoder`]
///
/// This is automatically implemented for some standard types, like byte slices and vectors of bytes.
pub trait IntoRead {
	type Read: Read;
	/// Transforms `self` into a type implementing [Read][`crate::io::Read`]
	fn into_read(self) -> Self::Read;
}

impl<T: Read> IntoRead for T {
	type Read = T;
	#[inline(always)]
	fn into_read(self) -> Self::Read {
		self
	}
}

impl<'a> IntoRead for &'a [u8] {
	type Read = Slice<'a>;
	#[inline]
	fn into_read(self) -> Self::Read {
		Slice::new(self)
	}
}

impl<'a> IntoRead for &'a mut [u8] {
	type Read = Slice<'a>;
	#[inline]
	fn into_read(self) -> Self::Read {
		Slice::new(self)
	}
}

#[cfg(feature = "alloc")]
#[cfg_attr(feature = "unstable", doc(cfg(feature = "alloc")))]
impl IntoRead for alloc::vec::Vec<u8> {
	type Read = crate::io::VecStream;
	#[inline]
	fn into_read(self) -> Self::Read {
		crate::io::VecStream::new(self, 0)
	}
}