51 lines
1.8 KiB
Rust
51 lines
1.8 KiB
Rust
use std::io::{Read, Write};
|
|
use super::{
|
|
decoder::{self, Decoder, DecodePlaceholderMap},
|
|
encoder::{Encoder, EncodePlaceholderMap},
|
|
invert_map,
|
|
reader::{BinaryReader, Error, is_eof_error},
|
|
value::{
|
|
NestedValue, Domain,
|
|
},
|
|
};
|
|
|
|
pub struct Codec<N: NestedValue<D>, D: Domain> {
|
|
pub decode_placeholders: Option<DecodePlaceholderMap<N, D>>,
|
|
pub encode_placeholders: Option<EncodePlaceholderMap<N, D>>,
|
|
}
|
|
|
|
impl<N: NestedValue<D>, D: Domain> Codec<N, D> {
|
|
pub fn new(decode_placeholders: DecodePlaceholderMap<N, D>) -> Self {
|
|
let encode_placeholders = Some(invert_map(&decode_placeholders));
|
|
Codec { decode_placeholders: Some(decode_placeholders), encode_placeholders }
|
|
}
|
|
|
|
pub fn without_placeholders() -> Self {
|
|
Codec { decode_placeholders: None, encode_placeholders: None }
|
|
}
|
|
|
|
pub fn decoder<'a, 'r, R: Read>(&'a self, read: &'r mut R) -> Decoder<'a, BinaryReader<'r, R>, N, D> {
|
|
Decoder::new(BinaryReader::new(read), self.decode_placeholders.as_ref())
|
|
}
|
|
|
|
pub fn encoder<'a, 'w, W: Write>(&'a self, write: &'w mut W) -> Encoder<'w, 'a, W, N, D> {
|
|
Encoder::new(write, self.encode_placeholders.as_ref())
|
|
}
|
|
|
|
pub fn decode_all<'r, R: Read>(&self, read: &'r mut R) -> decoder::Result<Vec<N>> {
|
|
let mut r = BinaryReader::new(read);
|
|
let vs: Vec<N> = Decoder::new(&mut r, self.decode_placeholders.as_ref()).collect::<decoder::Result<Vec<N>>>()?;
|
|
match r.peek() {
|
|
Err(e) if is_eof_error(&e) => Ok(vs),
|
|
Err(e) => Err(e),
|
|
Ok(_) => Err(Error::new(std::io::ErrorKind::Other, "trailing bytes")),
|
|
}
|
|
}
|
|
|
|
pub fn encode_bytes(&self, v: &N) -> std::io::Result<Vec<u8>> {
|
|
let mut buf: Vec<u8> = Vec::new();
|
|
self.encoder(&mut buf).write(v)?;
|
|
Ok(buf)
|
|
}
|
|
}
|