berkus
/
bincode
mirror of https://git.sr.ht/~stygianentity/bincode
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Added decode_ fns

This commit is contained in:
Victor Koenders 2021-09-22 09:54:09 +02:00
parent 6361ad7d69
commit 78cb27f782
6 changed files with 418 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

210
src/de/decoder.rs Normal file
View File

@ -0,0 +1,210 @@
use super::{read::Reader, Decode};
use crate::{
config::{Config, Endian, IntEncoding},
error::DecodeError,
};
use std::marker::PhantomData;
pub struct Decoder<R, C: Config> {
reader: R,
config: PhantomData<C>,
}
impl<'de, R: Reader<'de>, C: Config> Decoder<R, C> {
pub fn new(reader: R) -> Decoder<R, C> {
Decoder {
reader,
config: PhantomData,
}
}
pub fn into_reader(self) -> R {
self.reader
}
}
impl<'a, 'de, R: Reader<'de>, C: Config> Decode for &'a mut Decoder<R, C> {
fn decode_u8(&mut self) -> Result<u8, DecodeError> {
let mut bytes = [0u8; 1];
self.reader.read(&mut bytes)?;
Ok(bytes[0])
}
fn decode_u16(&mut self) -> Result<u16, DecodeError> {
match C::INT_ENCODING {
IntEncoding::Variable => crate::varint::varint_decode_u16(&mut self.reader, C::ENDIAN),
IntEncoding::Fixed => {
let mut bytes = [0u8; 2];
self.reader.read(&mut bytes)?;
Ok(match C::ENDIAN {
Endian::Little => u16::from_le_bytes(bytes),
Endian::Big => u16::from_be_bytes(bytes),
})
}
}
}
fn decode_u32(&mut self) -> Result<u32, DecodeError> {
match C::INT_ENCODING {
IntEncoding::Variable => crate::varint::varint_decode_u32(&mut self.reader, C::ENDIAN),
IntEncoding::Fixed => {
let mut bytes = [0u8; 4];
self.reader.read(&mut bytes)?;
Ok(match C::ENDIAN {
Endian::Little => u32::from_le_bytes(bytes),
Endian::Big => u32::from_be_bytes(bytes),
})
}
}
}
fn decode_u64(&mut self) -> Result<u64, DecodeError> {
match C::INT_ENCODING {
IntEncoding::Variable => crate::varint::varint_decode_u64(&mut self.reader, C::ENDIAN),
IntEncoding::Fixed => {
let mut bytes = [0u8; 8];
self.reader.read(&mut bytes)?;
Ok(match C::ENDIAN {
Endian::Little => u64::from_le_bytes(bytes),
Endian::Big => u64::from_be_bytes(bytes),
})
}
}
}
fn decode_u128(&mut self) -> Result<u128, DecodeError> {
match C::INT_ENCODING {
IntEncoding::Variable => crate::varint::varint_decode_u128(&mut self.reader, C::ENDIAN),
IntEncoding::Fixed => {
let mut bytes = [0u8; 16];
self.reader.read(&mut bytes)?;
Ok(match C::ENDIAN {
Endian::Little => u128::from_le_bytes(bytes),
Endian::Big => u128::from_be_bytes(bytes),
})
}
}
}
fn decode_usize(&mut self) -> Result<usize, DecodeError> {
match C::INT_ENCODING {
IntEncoding::Variable => {
crate::varint::varint_decode_usize(&mut self.reader, C::ENDIAN)
}
IntEncoding::Fixed => {
let mut bytes = [0u8; 8];
self.reader.read(&mut bytes)?;
Ok(match C::ENDIAN {
Endian::Little => u64::from_le_bytes(bytes),
Endian::Big => u64::from_be_bytes(bytes),
} as usize)
}
}
}
fn decode_i8(&mut self) -> Result<i8, DecodeError> {
let mut bytes = [0u8; 1];
self.reader.read(&mut bytes)?;
Ok(bytes[0] as i8)
}
fn decode_i16(&mut self) -> Result<i16, DecodeError> {
match C::INT_ENCODING {
IntEncoding::Variable => crate::varint::varint_decode_i16(&mut self.reader, C::ENDIAN),
IntEncoding::Fixed => {
let mut bytes = [0u8; 2];
self.reader.read(&mut bytes)?;
Ok(match C::ENDIAN {
Endian::Little => i16::from_le_bytes(bytes),
Endian::Big => i16::from_be_bytes(bytes),
})
}
}
}
fn decode_i32(&mut self) -> Result<i32, DecodeError> {
match C::INT_ENCODING {
IntEncoding::Variable => crate::varint::varint_decode_i32(&mut self.reader, C::ENDIAN),
IntEncoding::Fixed => {
let mut bytes = [0u8; 4];
self.reader.read(&mut bytes)?;
Ok(match C::ENDIAN {
Endian::Little => i32::from_le_bytes(bytes),
Endian::Big => i32::from_be_bytes(bytes),
})
}
}
}
fn decode_i64(&mut self) -> Result<i64, DecodeError> {
match C::INT_ENCODING {
IntEncoding::Variable => crate::varint::varint_decode_i64(&mut self.reader, C::ENDIAN),
IntEncoding::Fixed => {
let mut bytes = [0u8; 8];
self.reader.read(&mut bytes)?;
Ok(match C::ENDIAN {
Endian::Little => i64::from_le_bytes(bytes),
Endian::Big => i64::from_be_bytes(bytes),
})
}
}
}
fn decode_i128(&mut self) -> Result<i128, DecodeError> {
match C::INT_ENCODING {
IntEncoding::Variable => crate::varint::varint_decode_i128(&mut self.reader, C::ENDIAN),
IntEncoding::Fixed => {
let mut bytes = [0u8; 16];
self.reader.read(&mut bytes)?;
Ok(match C::ENDIAN {
Endian::Little => i128::from_le_bytes(bytes),
Endian::Big => i128::from_be_bytes(bytes),
})
}
}
}
fn decode_isize(&mut self) -> Result<isize, DecodeError> {
match C::INT_ENCODING {
IntEncoding::Variable => {
crate::varint::varint_decode_isize(&mut self.reader, C::ENDIAN)
}
IntEncoding::Fixed => {
let mut bytes = [0u8; 8];
self.reader.read(&mut bytes)?;
Ok(match C::ENDIAN {
Endian::Little => i64::from_le_bytes(bytes),
Endian::Big => i64::from_be_bytes(bytes),
} as isize)
}
}
}
fn decode_f32(&mut self) -> Result<f32, DecodeError> {
let mut bytes = [0u8; 4];
self.reader.read(&mut bytes)?;
Ok(match C::ENDIAN {
Endian::Little => f32::from_le_bytes(bytes),
Endian::Big => f32::from_be_bytes(bytes),
})
}
fn decode_f64(&mut self) -> Result<f64, DecodeError> {
let mut bytes = [0u8; 8];
self.reader.read(&mut bytes)?;
Ok(match C::ENDIAN {
Endian::Little => f64::from_le_bytes(bytes),
Endian::Big => f64::from_be_bytes(bytes),
})
}
fn decode_slice(&mut self, slice: &mut [u8]) -> Result<(), DecodeError> {
self.reader.read(slice)
}
fn decode_array<const N: usize>(&mut self) -> Result<[u8; N], DecodeError> {
let mut array = [0u8; N];
self.reader.read(&mut array)?;
Ok(array)
}
}

135
src/de/impls.rs
View File

@ -1,8 +1,143 @@
use super::{Decodable, Decode};
use crate::error::DecodeError;
impl Decodable for u8 {
fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
decoder.decode_u8()
}
}
impl Decodable for u16 {
fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
decoder.decode_u16()
}
}
impl Decodable for u32 {
fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
decoder.decode_u32()
}
}
impl Decodable for u64 {
fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
decoder.decode_u64()
}
}
impl Decodable for u128 {
fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
decoder.decode_u128()
}
}
impl Decodable for usize {
fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
decoder.decode_usize()
}
}
impl Decodable for i8 {
fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
decoder.decode_i8()
}
}
impl Decodable for i16 {
fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
decoder.decode_i16()
}
}
impl Decodable for i32 {
fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
decoder.decode_i32()
}
}
impl Decodable for i64 {
fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
decoder.decode_i64()
}
}
impl Decodable for i128 {
fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
decoder.decode_i128()
}
}
impl Decodable for isize {
fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
decoder.decode_isize()
}
}
impl<'a, T> Decode for &'a mut T
where
T: Decode,
{
fn decode_u8(&mut self) -> Result<u8, DecodeError> {
T::decode_u8(self)
}
fn decode_u16(&mut self) -> Result<u16, DecodeError> {
T::decode_u16(self)
}
fn decode_u32(&mut self) -> Result<u32, DecodeError> {
T::decode_u32(self)
}
fn decode_u64(&mut self) -> Result<u64, DecodeError> {
T::decode_u64(self)
}
fn decode_u128(&mut self) -> Result<u128, DecodeError> {
T::decode_u128(self)
}
fn decode_usize(&mut self) -> Result<usize, DecodeError> {
T::decode_usize(self)
}
fn decode_i8(&mut self) -> Result<i8, DecodeError> {
T::decode_i8(self)
}
fn decode_i16(&mut self) -> Result<i16, DecodeError> {
T::decode_i16(self)
}
fn decode_i32(&mut self) -> Result<i32, DecodeError> {
T::decode_i32(self)
}
fn decode_i64(&mut self) -> Result<i64, DecodeError> {
T::decode_i64(self)
}
fn decode_i128(&mut self) -> Result<i128, DecodeError> {
T::decode_i128(self)
}
fn decode_isize(&mut self) -> Result<isize, DecodeError> {
T::decode_isize(self)
}
fn decode_f32(&mut self) -> Result<f32, DecodeError> {
T::decode_f32(self)
}
fn decode_f64(&mut self) -> Result<f64, DecodeError> {
T::decode_f64(self)
}
fn decode_slice(&mut self, slice: &mut [u8]) -> Result<(), DecodeError> {
T::decode_slice(self, slice)
}
fn decode_array<const N: usize>(&mut self) -> Result<[u8; N], DecodeError> {
T::decode_array::<N>(self)
}
}

64
src/de/mod.rs
View File

@ -1,58 +1,32 @@
use core::marker::PhantomData;
use crate::{
config::{Config, Endian, IntEncoding},
error::DecodeError,
};
use read::Reader;
use crate::error::DecodeError;
mod decoder;
mod impls;
pub mod read;
pub use self::decoder::Decoder;
pub trait Decodable: Sized {
fn decode<D: Decode>(decoder: D) -> Result<Self, DecodeError>;
}
pub trait Decode {
fn decode_u8(&mut self) -> Result<u8, DecodeError>;
fn decode_u16(&mut self) -> Result<u16, DecodeError>;
fn decode_u32(&mut self) -> Result<u32, DecodeError>;
}
fn decode_u64(&mut self) -> Result<u64, DecodeError>;
fn decode_u128(&mut self) -> Result<u128, DecodeError>;
fn decode_usize(&mut self) -> Result<usize, DecodeError>;
pub struct Decoder<R, C: Config> {
reader: R,
config: PhantomData<C>,
}
fn decode_i8(&mut self) -> Result<i8, DecodeError>;
fn decode_i16(&mut self) -> Result<i16, DecodeError>;
fn decode_i32(&mut self) -> Result<i32, DecodeError>;
fn decode_i64(&mut self) -> Result<i64, DecodeError>;
fn decode_i128(&mut self) -> Result<i128, DecodeError>;
fn decode_isize(&mut self) -> Result<isize, DecodeError>;
impl<'de, R: Reader<'de>, C: Config> Decoder<R, C> {
pub fn new(reader: R) -> Decoder<R, C> {
Decoder {
reader,
config: PhantomData,
}
}
}
impl<'a, 'de, R: Reader<'de>, C: Config> Decode for &'a mut Decoder<R, C> {
fn decode_u32(&mut self) -> Result<u32, DecodeError> {
Ok(match C::INT_ENCODING {
IntEncoding::Variable => crate::varint::varint_decode_u32(&mut self.reader, C::ENDIAN)?,
IntEncoding::Fixed => {
let mut bytes = [0u8; 4];
self.reader.read(bytes.as_mut())?;
match C::ENDIAN {
Endian::Little => u32::from_le_bytes(bytes),
Endian::Big => u32::from_be_bytes(bytes),
}
}
})
}
}
impl<'a, T> Decode for &'a mut T
where
T: Decode,
{
fn decode_u32(&mut self) -> Result<u32, DecodeError> {
T::decode_u32(self)
}
fn decode_f32(&mut self) -> Result<f32, DecodeError>;
fn decode_f64(&mut self) -> Result<f64, DecodeError>;
fn decode_slice(&mut self, slice: &mut [u8]) -> Result<(), DecodeError>;
fn decode_array<const N: usize>(&mut self) -> Result<[u8; N], DecodeError>;
}

19
src/enc/encoder.rs
View File

@ -154,27 +154,20 @@ impl<'a, W: Writer, C: Config> Encode for &'a mut Encoder<W, C> {
}
fn encode_f32(&mut self, val: f32) -> Result<(), EncodeError> {
match C::INT_ENCODING {
IntEncoding::Variable => unimplemented!(), // crate::int_encoding::varint_encode_f32(&mut self.writer, C::ENDIAN, val),
IntEncoding::Fixed => match C::ENDIAN {
Endian::Big => self.writer.write(&val.to_be_bytes()),
Endian::Little => self.writer.write(&val.to_le_bytes()),
},
match C::ENDIAN {
Endian::Big => self.writer.write(&val.to_be_bytes()),
Endian::Little => self.writer.write(&val.to_le_bytes()),
}
}
fn encode_f64(&mut self, val: f64) -> Result<(), EncodeError> {
match C::INT_ENCODING {
IntEncoding::Variable => unimplemented!(), // crate::int_encoding::varint_encode_f64(&mut self.writer, C::ENDIAN, val),
IntEncoding::Fixed => match C::ENDIAN {
Endian::Big => self.writer.write(&val.to_be_bytes()),
Endian::Little => self.writer.write(&val.to_le_bytes()),
},
match C::ENDIAN {
Endian::Big => self.writer.write(&val.to_be_bytes()),
Endian::Little => self.writer.write(&val.to_le_bytes()),
}
}
fn encode_slice(&mut self, val: &[u8]) -> Result<(), EncodeError> {
// TODO: Should this be swapped if we're big or little endian?
self.writer.write(val)
}
}

43
src/varint/decode_signed.rs Normal file
View File

@ -0,0 +1,43 @@
#![allow(unused_variables)]
use crate::{config::Endian, de::read::Reader, error::DecodeError};
#[allow(dead_code)]
pub fn varint_decode_i16<'a, R: Reader<'a>>(
read: &mut R,
endian: Endian,
) -> Result<i16, DecodeError> {
unimplemented!()
}
#[allow(dead_code)]
pub fn varint_decode_i32<'a, R: Reader<'a>>(
read: &mut R,
endian: Endian,
) -> Result<i32, DecodeError> {
unimplemented!()
}
#[allow(dead_code)]
pub fn varint_decode_i64<'a, R: Reader<'a>>(
read: &mut R,
endian: Endian,
) -> Result<i64, DecodeError> {
unimplemented!()
}
#[allow(dead_code)]
pub fn varint_decode_i128<'a, R: Reader<'a>>(
read: &mut R,
endian: Endian,
) -> Result<i128, DecodeError> {
unimplemented!()
}
#[allow(dead_code)]
pub fn varint_decode_isize<'a, R: Reader<'a>>(
read: &mut R,
endian: Endian,
) -> Result<isize, DecodeError> {
unimplemented!()
}

5
src/varint/mod.rs
View File

@ -1,7 +1,12 @@
mod decode_signed;
mod decode_unsigned;
mod encode_signed;
mod encode_unsigned;
pub use self::decode_signed::{
varint_decode_i128, varint_decode_i16, varint_decode_i32, varint_decode_i64,
varint_decode_isize,
};
pub use self::decode_unsigned::{
varint_decode_u128, varint_decode_u16, varint_decode_u32, varint_decode_u64,
varint_decode_usize,