#![cfg_attr(feature = "alloc", feature(alloc))]
#![allow(overflowing_literals)]
#![cfg_attr(all(not(feature = "std"), not(test)), no_std)]
#[cfg(all(not(feature = "std"), not(test)))]
extern crate core as std;
extern crate serde;
extern crate byteorder;
#[cfg(test)]
#[macro_use]
extern crate serde_derive;
#[cfg(feature = "alloc")]
#[macro_use]
extern crate alloc;
#[cfg(feature = "alloc")]
use alloc::vec::Vec;
pub use ser::Serializer;
pub use de::Deserializer;
pub mod error;
pub mod read;
mod defs;
mod seq_serializer;
mod map_serializer;
mod variant_deserializer;
mod ext_deserializer;
mod seq_deserializer;
mod ser;
mod de;
pub fn from_iter<I, V>(mut iter: I) -> Result<V, error::Error>
where I: Iterator<Item = u8>,
V: serde::de::DeserializeOwned
{
let mut de = Deserializer::new(read::CopyRead::new(|buf: &mut [u8]| {
for i in 0..buf.len() {
if let Some(byte) = iter.next() {
buf[i] = byte;
} else {
return Err(error::Error::EndOfStream);
}
}
Ok(())
}));
V::deserialize(&mut de)
}
pub fn from_bytes<'a, V>(bytes: &'a [u8]) -> Result<V, error::Error>
where V: serde::Deserialize<'a>
{
let mut position: usize = 0;
let mut de = Deserializer::new(read::BorrowRead::new(|len: usize| if position + len >
bytes.len() {
Err(error::Error::EndOfStream)
} else {
let result = &bytes[position..position + len];
position += len;
Ok(result)
}));
V::deserialize(&mut de)
}
pub fn to_bytes<V>(value: V) -> Result<Vec<u8>, error::Error>
where V: serde::Serialize
{
let mut bytes = vec![];
{
let mut ser = Serializer::new(|buf| {
bytes.extend_from_slice(buf);
Ok(())
});
try!(value.serialize(&mut ser));
}
Ok(bytes)
}
#[cfg(test)]
mod test {
use serde::Serialize;
use serde::de::DeserializeOwned;
use std::fmt::Debug;
use std::ffi::CString;
#[derive(PartialEq, Eq, Debug, Serialize, Deserialize)]
enum T {
A(usize),
B,
C(i8, i8),
D { a: isize, b: String },
}
fn test_through<T>(item: T, expected: &[u8])
where T: Serialize + DeserializeOwned + PartialEq + Debug
{
let actual = ::to_bytes(&item).expect("Failed to serialize");
assert_eq!(expected, &*actual);
let deserialized_item = ::from_bytes(&actual).expect("Failed to deserialize");
assert_eq!(item, deserialized_item);
}
#[test]
fn test_str() {
test_through(format!("Hello World!"),
&[0xac, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64,
0x21]);
}
#[test]
fn test_enum() {
test_through(T::B, &[0x92, 0x01, 0xc0])
}
#[test]
fn test_enum_newtype() {
test_through(T::A(42), &[0x92, 0x00, 0x2a])
}
#[test]
fn test_enum_tuple() {
test_through(T::C(-3, 22), &[0x92, 0x02, 0x92, 0xfd, 0x16])
}
#[test]
fn test_enum_struct() {
test_through(T::D {
a: 9001,
b: "Hello world!".into(),
},
&[0x92,
0x03,
0x82,
0xa1,
0x61,
0xd1,
0x23,
0x29,
0xa1,
0x62,
0xac,
0x48,
0x65,
0x6c,
0x6c,
0x6f,
0x20,
0x77,
0x6f,
0x72,
0x6c,
0x64,
0x21])
}
#[test]
fn test_option() {
test_through(Some(7), &[0x92, 0xc3, 0x07])
}
#[test]
fn test_option_none() {
test_through::<Option<usize>>(None, &[0x91, 0xc2])
}
#[test]
fn test_unit_option() {
test_through(Some(()), &[0x92, 0xc3, 0xc0])
}
#[test]
fn test_char() {
test_through('b', &[0xa1, 0x62])
}
#[test]
fn test_false() {
test_through(false, &[0xc2])
}
#[test]
fn test_byte_array() {
test_through(CString::new("hello").unwrap(),
&[0xc4, 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f])
}
#[test]
fn test_float() {
test_through(4.5, &[0xcb, 0x40, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
}
#[test]
fn test_float32() {
test_through(3.2f32, &[0xca, 0x40, 0x4c, 0xcc, 0xcd])
}
}