#![warn(rust_2018_idioms)]
#![allow(clippy::cast_sign_loss)]
#![allow(clippy::cast_possible_truncation)]
#![allow(clippy::cast_possible_wrap)]
#[macro_use]
extern crate serde;
use std::any::Any;
use std::collections::BTreeMap;
use std::default::Default;
use std::fmt::Debug;
use std::io::{
Cursor,
Error,
ErrorKind,
Result,
Write,
};
use bytes::buf::{
Buf,
BufMut,
};
pub mod erased;
pub mod helpers;
pub mod varint;
pub mod wire_format;
mod buffer;
pub use crate::buffer::{
type_is,
CopyWriter,
Lazy,
PbBuffer,
PbBufferReader,
PbBufferWriter,
};
mod base_types;
pub use crate::base_types::{
ClosedProtoEnum,
Fixed32,
Fixed64,
OpenProtoEnum,
ProtoEnum,
Sfixed32,
Sfixed64,
Signed32,
Signed64,
};
mod descriptor;
pub use crate::descriptor::{
FieldDescriptor,
Label,
MessageDescriptor,
OneofDescriptor,
};
pub mod reflection;
pub use crate::reflection::Reflection;
#[cfg(test)]
mod tests;
pub trait Message: PartialEq + Default + Debug + Any {
fn descriptor(&self) -> Option<MessageDescriptor> {
None
}
fn compute_size(&self) -> usize;
fn compute_grpc_slices_size(&self) -> usize {
0
}
fn serialize<W: PbBufferWriter>(&self, w: &mut W) -> Result<()>;
fn deserialize<B: PbBufferReader>(&mut self, r: &mut B) -> Result<()>;
#[inline]
fn serialize_to_vec(&self) -> Vec<u8> {
let size = self.compute_size() as usize;
let mut out = Vec::with_capacity(size);
self.serialize(&mut Cursor::new(&mut out)).expect("Vec u32 overflow");
debug_assert_eq!(out.len(), size);
out
}
#[inline]
fn serialize_to_writer<W: Write>(&self, writer: &mut W) -> Result<()> {
let mut copy_writer = CopyWriter { writer };
self.serialize(&mut copy_writer)?;
Ok(())
}
#[inline]
fn deserialize_from_slice(slice: &[u8]) -> Result<Self> {
let mut buf = Cursor::new(slice);
let mut m = Self::default();
m.deserialize(&mut buf)?;
Ok(m)
}
}
pub fn ensure_wire_format(
format: wire_format::Type,
expected: wire_format::Type,
msg_name: &str,
field_number: usize,
) -> Result<()> {
if format != expected {
return Err(Error::new(
ErrorKind::Other,
format!(
"expected wire_format {:?}, found {:?}, at {:?}:{:?}",
expected, format, msg_name, field_number
),
));
}
Ok(())
}
pub fn unexpected_eof() -> Error {
Error::new(ErrorKind::UnexpectedEof, "unexpected EOF")
}
#[derive(Default)]
pub struct Unrecognized {
by_field_number: BTreeMap<u32, Vec<u8>>,
}
impl Unrecognized {
pub fn serialize(self, unrecognized_buf: &mut Vec<u8>) -> Result<()> {
unrecognized_buf.reserve(self.by_field_number.values().map(|v| v.len()).sum());
for serialized_field in self.by_field_number.values() {
unrecognized_buf.write_all(&serialized_field)?;
}
Ok(())
}
pub fn gather<B: Buf>(&mut self, field_number: u32, typ: wire_format::Type, buf: &mut B) -> Result<()> {
let mut unrecognized_buf = vec![];
wire_format::write(field_number, typ, &mut unrecognized_buf)?;
let advance = match typ {
wire_format::Type::Varint => {
if let Some(num) = varint::read(buf)? {
varint::write(num, &mut unrecognized_buf)?;
} else {
return Err(unexpected_eof());
};
0
},
wire_format::Type::Fixed64 => 8,
wire_format::Type::Fixed32 => 4,
wire_format::Type::LengthDelimited => match varint::read(buf)? {
Some(n) => {
varint::write(n, &mut unrecognized_buf)?;
n as usize
},
None => return Err(unexpected_eof()),
},
};
if buf.remaining() < advance {
return Err(unexpected_eof());
}
unrecognized_buf.put(buf.take(advance));
self.by_field_number.insert(field_number, unrecognized_buf);
Ok(())
}
}
pub fn skip<B: Buf>(typ: wire_format::Type, buf: &mut B) -> Result<()> {
let advance = match typ {
wire_format::Type::Varint => {
if varint::read(buf)?.is_none() {
return Err(unexpected_eof());
};
0
},
wire_format::Type::Fixed64 => 8,
wire_format::Type::Fixed32 => 4,
wire_format::Type::LengthDelimited => match varint::read(buf)? {
Some(n) => n as usize,
None => return Err(unexpected_eof()),
},
};
if buf.remaining() < advance {
return Err(unexpected_eof());
}
buf.advance(advance);
Ok(())
}
pub fn ensure_split<B: PbBufferReader>(buf: &mut B, len: usize) -> Result<B> {
if buf.remaining() < len {
Err(unexpected_eof())
} else {
Ok(buf.split(len))
}
}