use super::Error;
use crate::raw::Marker;
use crate::raw::decode::{RmpRead, read_marker};
use crate::value::{Utf8String, Value};
use std::io::{self, Read};
fn read_array_data<R: Read>(rd: &mut R, len: usize, depth: u16) -> Result<Vec<Value>, Error> {
let depth = super::decrement_depth(depth)?;
let mut vec = Vec::with_capacity(super::prealloc_capacity::<Value>(len));
for _ in 0..len {
vec.push(read_value_inner(rd, depth)?);
}
Ok(vec)
}
fn read_map_data<R: Read>(rd: &mut R, len: usize, depth: u16) -> Result<Vec<(Value, Value)>, Error> {
let depth = super::decrement_depth(depth)?;
let mut vec = Vec::with_capacity(super::prealloc_capacity::<(Value, Value)>(len));
for _ in 0..len {
vec.push((read_value_inner(rd, depth)?, read_value_inner(rd, depth)?));
}
Ok(vec)
}
fn read_str_data<R: Read>(rd: &mut R, len: usize, depth: u16) -> Result<Utf8String, Error> {
let depth = super::decrement_depth(depth)?;
match String::from_utf8(read_bin_data(rd, len, depth)?) {
Ok(s) => Ok(Utf8String::from(s)),
Err(err) => {
let e = err.utf8_error();
let s = Utf8String {
s: Err((err.into_bytes(), e)),
};
Ok(s)
}
}
}
fn read_bin_data<R: Read>(rd: &mut R, len: usize, depth: u16) -> Result<Vec<u8>, Error> {
let _depth = super::decrement_depth(depth)?;
let mut buf = Vec::with_capacity(len.min(super::DATA_PREALLOC_MAX));
let bytes_read = rd
.take(len as u64)
.read_to_end(&mut buf)
.map_err(Error::InvalidDataRead)?;
if bytes_read != len {
return Err(Error::InvalidDataRead(io::Error::new(
io::ErrorKind::UnexpectedEof,
format!("Expected {} bytes, read {} bytes", len, bytes_read),
)));
}
Ok(buf)
}
fn read_ext_body<R: Read>(rd: &mut R, len: usize, depth: u16) -> Result<(i8, Vec<u8>), Error> {
let depth = super::decrement_depth(depth)?;
let ty = rd.read_data_i8()?;
let vec = read_bin_data(rd, len, depth)?;
Ok((ty, vec))
}
#[inline(never)]
fn read_value_inner<R>(rd: &mut R, depth: u16) -> Result<Value, Error>
where
R: Read,
{
let depth = super::decrement_depth(depth)?;
let val = match read_marker(rd)? {
Marker::Null => Value::Nil,
Marker::True => Value::Boolean(true),
Marker::False => Value::Boolean(false),
Marker::FixPos(val) => Value::from(val),
Marker::FixNeg(val) => Value::from(val),
Marker::U8 => Value::from(rd.read_data_u8()?),
Marker::U16 => Value::from(rd.read_data_u16()?),
Marker::U32 => Value::from(rd.read_data_u32()?),
Marker::U64 => Value::from(rd.read_data_u64()?),
Marker::I8 => Value::from(rd.read_data_i8()?),
Marker::I16 => Value::from(rd.read_data_i16()?),
Marker::I32 => Value::from(rd.read_data_i32()?),
Marker::I64 => Value::from(rd.read_data_i64()?),
Marker::F32 => Value::F32(rd.read_data_f32()?),
Marker::F64 => Value::F64(rd.read_data_f64()?),
Marker::FixStr(len) => {
let res = read_str_data(rd, len as usize, depth)?;
Value::String(res)
}
Marker::Str8 => {
let len = rd.read_data_u8()?;
let res = read_str_data(rd, len as usize, depth)?;
Value::String(res)
}
Marker::Str16 => {
let len = rd.read_data_u16()?;
let res = read_str_data(rd, len as usize, depth)?;
Value::String(res)
}
Marker::Str32 => {
let len = rd.read_data_u32()?;
let res = read_str_data(rd, len as usize, depth)?;
Value::String(res)
}
Marker::FixArray(len) => {
let vec = read_array_data(rd, len as usize, depth)?;
Value::Array(vec)
}
Marker::Array16 => {
let len = rd.read_data_u16()?;
let vec = read_array_data(rd, len as usize, depth)?;
Value::Array(vec)
}
Marker::Array32 => {
let len = rd.read_data_u32()?;
let vec = read_array_data(rd, len as usize, depth)?;
Value::Array(vec)
}
Marker::FixMap(len) => {
let map = read_map_data(rd, len as usize, depth)?;
Value::Map(map)
}
Marker::Map16 => {
let len = rd.read_data_u16()?;
let map = read_map_data(rd, len as usize, depth)?;
Value::Map(map)
}
Marker::Map32 => {
let len = rd.read_data_u32()?;
let map = read_map_data(rd, len as usize, depth)?;
Value::Map(map)
}
Marker::Bin8 => {
let len = rd.read_data_u8()?;
let vec = read_bin_data(rd, len as usize, depth)?;
Value::Binary(vec)
}
Marker::Bin16 => {
let len = rd.read_data_u16()?;
let vec = read_bin_data(rd, len as usize, depth)?;
Value::Binary(vec)
}
Marker::Bin32 => {
let len = rd.read_data_u32()?;
let vec = read_bin_data(rd, len as usize, depth)?;
Value::Binary(vec)
}
Marker::FixExt1 => {
let len = 1_usize;
let (ty, vec) = read_ext_body(rd, len, depth)?;
Value::Ext(ty, vec)
}
Marker::FixExt2 => {
let len = 2_usize;
let (ty, vec) = read_ext_body(rd, len, depth)?;
Value::Ext(ty, vec)
}
Marker::FixExt4 => {
let len = 4_usize;
let (ty, vec) = read_ext_body(rd, len, depth)?;
Value::Ext(ty, vec)
}
Marker::FixExt8 => {
let len = 8_usize;
let (ty, vec) = read_ext_body(rd, len, depth)?;
Value::Ext(ty, vec)
}
Marker::FixExt16 => {
let len = 16_usize;
let (ty, vec) = read_ext_body(rd, len, depth)?;
Value::Ext(ty, vec)
}
Marker::Ext8 => {
let len = rd.read_data_u8()? as usize;
let (ty, vec) = read_ext_body(rd, len, depth)?;
Value::Ext(ty, vec)
}
Marker::Ext16 => {
let len = rd.read_data_u16()? as usize;
let (ty, vec) = read_ext_body(rd, len, depth)?;
Value::Ext(ty, vec)
}
Marker::Ext32 => {
let len = rd.read_data_u32()? as usize;
let (ty, vec) = read_ext_body(rd, len, depth)?;
Value::Ext(ty, vec)
}
Marker::Reserved => Value::Nil,
};
Ok(val)
}
#[inline]
pub fn read_value<R>(rd: &mut R) -> Result<Value, Error>
where
R: Read,
{
read_value_inner(rd, super::max_depth_u16(super::MAX_DEPTH))
}
#[inline]
pub fn read_value_with_max_depth<R>(rd: &mut R, max_depth: usize) -> Result<Value, Error>
where
R: Read,
{
read_value_inner(rd, super::max_depth_u16(max_depth))
}