├── .gitignore
├── messagepack-rs
    ├── src
    │   ├── stream.rs
    │   ├── binary.rs
    │   ├── extension.rs
    │   ├── lib.rs
    │   ├── stream
    │   │   ├── serializer.rs
    │   │   └── deserializer.rs
    │   ├── marker.rs
    │   ├── marker
    │   │   ├── into.rs
    │   │   └── from.rs
    │   ├── value.rs
    │   ├── deserializable.rs
    │   └── serializable.rs
    ├── examples
    │   ├── basic.rs
    │   ├── stream.rs
    │   ├── extension1.rs
    │   └── extension2.rs
    ├── Cargo.toml
    └── LICENSE
├── Cargo.toml
├── messagepack-rs-macros
    ├── README.md
    ├── Cargo.toml
    ├── LICENSE
    └── src
    │   └── lib.rs
├── README.md
└── .github
    └── FUNDING.yml


/.gitignore:
--------------------------------------------------------------------------------
1 | target
2 | **/*.rs.bk
3 | Cargo.lock
4 | 


--------------------------------------------------------------------------------
/messagepack-rs/src/stream.rs:
--------------------------------------------------------------------------------
1 | pub mod deserializer;
2 | pub mod serializer;
3 | 


--------------------------------------------------------------------------------
/messagepack-rs/src/binary.rs:
--------------------------------------------------------------------------------
1 | #[derive(Clone, Debug, PartialEq)]
2 | pub struct Binary(pub Vec<u8>);
3 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
1 | [workspace]
2 | 
3 | members = [
4 |   "messagepack-rs",
5 |   "messagepack-rs-macros",
6 | ]
7 | 


--------------------------------------------------------------------------------
/messagepack-rs-macros/README.md:
--------------------------------------------------------------------------------
1 | # messagepack-rs-macros
2 | Procedural macros for messagepack-rs
3 | ## License
4 | MIT License
5 | 


--------------------------------------------------------------------------------
/messagepack-rs/src/extension.rs:
--------------------------------------------------------------------------------
1 | #[derive(Clone, Debug, PartialEq)]
2 | pub struct Extension {
3 |     pub t: i8,
4 |     pub data: Vec<u8>,
5 | }
6 | 


--------------------------------------------------------------------------------
/messagepack-rs/src/lib.rs:
--------------------------------------------------------------------------------
 1 | #![forbid(unsafe_code)]
 2 | 
 3 | pub mod binary;
 4 | pub mod deserializable;
 5 | pub mod extension;
 6 | pub mod marker;
 7 | pub mod serializable;
 8 | pub mod stream;
 9 | pub mod value;
10 | 
11 | pub use crate::marker::Marker;
12 | 


--------------------------------------------------------------------------------
/messagepack-rs-macros/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "messagepack-rs-macros"
 3 | version = "0.1.2"
 4 | authors = ["Shogo Otake <shogo.otake@gmail.com>"]
 5 | license = "MIT"
 6 | description = "Procedural macros for messagepack-rs"
 7 | repository = "https://github.com/otake84/messagepack-rs"
 8 | readme = "README.md"
 9 | keywords = ["msgpack", "MessagePack"]
10 | categories = ["encoding"]
11 | edition = "2018"
12 | 
13 | [lib]
14 | proc-macro = true
15 | 
16 | [dependencies]
17 | quote = "1.0.2"
18 | syn = "1.0.5"
19 | 


--------------------------------------------------------------------------------
/messagepack-rs/src/stream/serializer.rs:
--------------------------------------------------------------------------------
 1 | use crate::serializable::*;
 2 | use std::io::{BufWriter, Error, Write};
 3 | 
 4 | pub struct Serializer<T: Write>(BufWriter<T>);
 5 | 
 6 | impl<W: Write> Serializer<W> {
 7 |     pub fn new(w: W) -> Self {
 8 |         Serializer(BufWriter::new(w))
 9 |     }
10 | 
11 |     pub fn serialize<T: Serializable>(&mut self, value: T) -> Result<usize, SerializeError> {
12 |         self.0.write(&value.serialize()?).or(Err(SerializeError::FailedToWrite))
13 |     }
14 | 
15 |     pub fn get_ref(&self) -> &W {
16 |         self.0.get_ref()
17 |     }
18 | 
19 |     pub fn flush(&mut self) -> Result<(), Error> {
20 |         self.0.flush()
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # messagepack-rs
 2 | messagepack-rs is pure Rust MessagePack implementation.
 3 | ## Features
 4 | - Supports basic serialization and deserialization of MessagePack
 5 | - Supports Stream serialization and deserialization
 6 | - Supports Timestamp type (Note: The date range depends on [Chrono](https://github.com/chronotope/chrono))
 7 | - Supports user defined extension types
 8 | - `#![forbid(unsafe_code)]`
 9 | ## Usage
10 | See [examples](https://github.com/otake84/messagepack-rs/tree/master/messagepack-rs/examples)
11 | ## Todo
12 | - Support for Serde
13 | ## License
14 | MIT License
15 | ## Special Thanks
16 | [rust-jp](https://rust-jp.rs/) - Thanks to the slack community for answering questions.
17 | 


--------------------------------------------------------------------------------
/messagepack-rs/examples/basic.rs:
--------------------------------------------------------------------------------
 1 | use chrono::prelude::*;
 2 | use messagepack_rs::deserializable::Deserializable;
 3 | use messagepack_rs::serializable::Serializable;
 4 | use messagepack_rs::value::Value;
 5 | use std::io::{BufReader, Cursor};
 6 | 
 7 | fn main() {
 8 |     let value = Value::from(vec![Value::from(Utc::now()), Value::from(123u8), Value::from("test"), Value::from(true), Value::Nil, Value::from(None::<u8>)]);
 9 |     println!("{:?}", value);
10 |     let serialized_value = value.serialize().unwrap();
11 |     println!("{:?}", serialized_value);
12 |     let deserialized_value = Value::deserialize(&mut BufReader::new(Cursor::new(serialized_value))).unwrap();
13 |     println!("{:?}", deserialized_value);
14 | }
15 | 


--------------------------------------------------------------------------------
/messagepack-rs/src/marker.rs:
--------------------------------------------------------------------------------
 1 | mod from;
 2 | mod into;
 3 | 
 4 | #[derive(Clone, Debug, PartialEq)]
 5 | pub enum Marker {
 6 |     PositiveFixInt(u8),
 7 |     FixMap(u8),
 8 |     FixArray(u8),
 9 |     FixStr(u8),
10 |     Nil,
11 |     Reserved,
12 |     False,
13 |     True,
14 |     Bin8,
15 |     Bin16,
16 |     Bin32,
17 |     Ext8,
18 |     Ext16,
19 |     Ext32,
20 |     Float32,
21 |     Float64,
22 |     UInt8,
23 |     UInt16,
24 |     UInt32,
25 |     UInt64,
26 |     Int8,
27 |     Int16,
28 |     Int32,
29 |     Int64,
30 |     FixExt1,
31 |     FixExt2,
32 |     FixExt4,
33 |     FixExt8,
34 |     FixExt16,
35 |     Str8,
36 |     Str16,
37 |     Str32,
38 |     Array16,
39 |     Array32,
40 |     Map16,
41 |     Map32,
42 |     NegativeFixInt(i8),
43 | }
44 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
 1 | # These are supported funding model platforms
 2 | 
 3 | github: [otake84] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
 4 | patreon: # Replace with a single Patreon username
 5 | open_collective: # Replace with a single Open Collective username
 6 | ko_fi: # Replace with a single Ko-fi username
 7 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 8 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 9 | liberapay: # Replace with a single Liberapay username
10 | issuehunt: # Replace with a single IssueHunt username
11 | otechie: # Replace with a single Otechie username
12 | custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
13 | 


--------------------------------------------------------------------------------
/messagepack-rs/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "messagepack-rs"
 3 | version = "0.8.1"
 4 | authors = ["Shogo Otake <shogo.otake@gmail.com>"]
 5 | license = "MIT"
 6 | description = "messagepack-rs is pure Rust MessagePack implementation"
 7 | repository = "https://github.com/otake84/messagepack-rs"
 8 | readme = "../README.md"
 9 | keywords = ["msgpack", "MessagePack"]
10 | categories = ["encoding"]
11 | edition = "2018"
12 | 
13 | [dependencies]
14 | byteorder = "1.3.2"
15 | chrono = "0.4.9"
16 | messagepack-rs-macros = { version = "0.1.2", path = "../messagepack-rs-macros"}
17 | 
18 | [[example]]
19 | name = "basic"
20 | path = "examples/basic.rs"
21 | 
22 | [[example]]
23 | name = "stream"
24 | path = "examples/stream.rs"
25 | 
26 | [[example]]
27 | name = "extension1"
28 | path = "examples/extension1.rs"
29 | 
30 | [[example]]
31 | name = "extension2"
32 | path = "examples/extension2.rs"
33 | 


--------------------------------------------------------------------------------
/messagepack-rs/examples/stream.rs:
--------------------------------------------------------------------------------
 1 | use messagepack_rs::stream::serializer::Serializer;
 2 | use messagepack_rs::value::Value;
 3 | use std::io::{BufReader, Cursor};
 4 | 
 5 | fn main() {
 6 |     let buf = Vec::new();
 7 |     let mut stream_serializer = Serializer::new(buf);
 8 |     stream_serializer.serialize(Value::Nil).unwrap();
 9 |     stream_serializer.serialize(Value::from(true)).unwrap();
10 |     stream_serializer.serialize(Value::from(false)).unwrap();
11 |     stream_serializer.serialize(Value::from("test")).unwrap();
12 |     stream_serializer.serialize(Value::Nil).unwrap();
13 |     stream_serializer.flush().unwrap();
14 |     println!("{:?}", stream_serializer.get_ref());
15 | 
16 |     let buf_reader = BufReader::new(Cursor::new(stream_serializer.get_ref()));
17 |     let stream_deserializer = messagepack_rs::stream::deserializer::Deserializer::<Value, _>::new(buf_reader);
18 |     stream_deserializer.for_each(|v| println!("{:?}", v));
19 | }
20 | 


--------------------------------------------------------------------------------
/messagepack-rs/examples/extension1.rs:
--------------------------------------------------------------------------------
 1 | use messagepack_rs::deserializable::Deserializable;
 2 | use messagepack_rs::extension::Extension;
 3 | use messagepack_rs::serializable::Serializable;
 4 | use messagepack_rs::value::Value;
 5 | use std::io::{BufReader, Cursor};
 6 | 
 7 | #[derive(Clone, Debug, PartialEq)]
 8 | struct Rgba {
 9 |     r: u8,
10 |     g: u8,
11 |     b: u8,
12 |     a: u8,
13 | }
14 | 
15 | impl From<Rgba> for Value {
16 |     fn from(value: Rgba) -> Self {
17 |         Self::Extension(Extension { t: 0, data: vec![value.r, value.g, value.b, value.a] })
18 |     }
19 | }
20 | 
21 | fn main() {
22 |     let rgba = Rgba { r: 5, g: 10, b: 15, a: 20 };
23 |     let value = Value::from(rgba);
24 |     println!("{:?}", value);
25 | 
26 |     let serialized_value = value.serialize().unwrap();
27 |     println!("{:?}", serialized_value);
28 | 
29 |     let deserialized_value = Value::deserialize(&mut BufReader::new(Cursor::new(serialized_value))).unwrap();
30 |     println!("{:?}", deserialized_value);
31 | }
32 | 


--------------------------------------------------------------------------------
/messagepack-rs/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Shogo Otake
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/messagepack-rs-macros/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Shogo Otake
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/messagepack-rs/src/marker/into.rs:
--------------------------------------------------------------------------------
 1 | use super::Marker;
 2 | 
 3 | impl Into<u8> for Marker {
 4 |     fn into(self) -> u8 {
 5 |         match self {
 6 |             Self::PositiveFixInt(n) => n,
 7 |             Self::FixMap(n) => 0x80 | (n & 0x0f),
 8 |             Self::FixArray(n) => 0x90 | (n & 0x0f),
 9 |             Self::FixStr(n) => 0xa0 | (n & 0x1f),
10 |             Self::Nil => 0xc0,
11 |             Self::Reserved => 0xc1,
12 |             Self::False => 0xc2,
13 |             Self::True => 0xc3,
14 |             Self::Bin8 => 0xc4,
15 |             Self::Bin16 => 0xc5,
16 |             Self::Bin32 => 0xc6,
17 |             Self::Ext8 => 0xc7,
18 |             Self::Ext16 => 0xc8,
19 |             Self::Ext32 => 0xc9,
20 |             Self::Float32 => 0xca,
21 |             Self::Float64 => 0xcb,
22 |             Self::UInt8 => 0xcc,
23 |             Self::UInt16 => 0xcd,
24 |             Self::UInt32 => 0xce,
25 |             Self::UInt64 => 0xcf,
26 |             Self::Int8 => 0xd0,
27 |             Self::Int16 => 0xd1,
28 |             Self::Int32 => 0xd2,
29 |             Self::Int64 => 0xd3,
30 |             Self::FixExt1 => 0xd4,
31 |             Self::FixExt2 => 0xd5,
32 |             Self::FixExt4 => 0xd6,
33 |             Self::FixExt8 => 0xd7,
34 |             Self::FixExt16 => 0xd8,
35 |             Self::Str8 => 0xd9,
36 |             Self::Str16 => 0xda,
37 |             Self::Str32 => 0xdb,
38 |             Self::Array16 => 0xdc,
39 |             Self::Array32 => 0xdd,
40 |             Self::Map16 => 0xde,
41 |             Self::Map32 => 0xdf,
42 |             Self::NegativeFixInt(n) => n as u8,
43 |         }
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/messagepack-rs/src/marker/from.rs:
--------------------------------------------------------------------------------
 1 | use super::Marker;
 2 | 
 3 | impl From<u8> for Marker {
 4 |     fn from(n: u8) -> Marker {
 5 |         match n {
 6 |             0x00..=0x7f => Self::PositiveFixInt(n),
 7 |             0x80..=0x8f => Self::FixMap(n & 0x0f),
 8 |             0x90..=0x9f => Self::FixArray(n & 0x0f),
 9 |             0xa0..=0xbf => Self::FixStr(n & 0x1f),
10 |             0xc0 => Self::Nil,
11 |             0xc1 => Self::Reserved,
12 |             0xc2 => Self::False,
13 |             0xc3 => Self::True,
14 |             0xc4 => Self::Bin8,
15 |             0xc5 => Self::Bin16,
16 |             0xc6 => Self::Bin32,
17 |             0xc7 => Self::Ext8,
18 |             0xc8 => Self::Ext16,
19 |             0xc9 => Self::Ext32,
20 |             0xca => Self::Float32,
21 |             0xcb => Self::Float64,
22 |             0xcc => Self::UInt8,
23 |             0xcd => Self::UInt16,
24 |             0xce => Self::UInt32,
25 |             0xcf => Self::UInt64,
26 |             0xd0 => Self::Int8,
27 |             0xd1 => Self::Int16,
28 |             0xd2 => Self::Int32,
29 |             0xd3 => Self::Int64,
30 |             0xd4 => Self::FixExt1,
31 |             0xd5 => Self::FixExt2,
32 |             0xd6 => Self::FixExt4,
33 |             0xd7 => Self::FixExt8,
34 |             0xd8 => Self::FixExt16,
35 |             0xd9 => Self::Str8,
36 |             0xda => Self::Str16,
37 |             0xdb => Self::Str32,
38 |             0xdc => Self::Array16,
39 |             0xdd => Self::Array32,
40 |             0xde => Self::Map16,
41 |             0xdf => Self::Map32,
42 |             0xe0..=0xff => Self::NegativeFixInt(n as i8),
43 |         }
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/messagepack-rs/src/stream/deserializer.rs:
--------------------------------------------------------------------------------
 1 | use crate::deserializable::Deserializable;
 2 | use std::io::{BufRead, BufReader, Read, Seek, SeekFrom};
 3 | use std::marker::PhantomData;
 4 | 
 5 | pub struct Deserializer<D: Deserializable, R: Read + Seek> {
 6 |     buf_reader: BufReader<R>,
 7 |     phantom: PhantomData<D>,
 8 | }
 9 | 
10 | #[derive(Debug)]
11 | pub enum Error {
12 |     FailedToDeserialize(u64),
13 |     FailedToFillBuf,
14 |     FailedToSeek,
15 | }
16 | 
17 | impl<D: Deserializable, R: Read + Seek> Deserializer<D, R> {
18 |     pub fn new(buf_reader: BufReader<R>) -> Self {
19 |         Deserializer { buf_reader, phantom: PhantomData::<D> }
20 |     }
21 | }
22 | 
23 | impl<D: Deserializable, R: Read + Seek> Iterator for Deserializer<D, R> {
24 |     type Item = Result<(D, u64), Error>;
25 | 
26 |     fn next(&mut self) -> Option<Self::Item> {
27 |         match self.buf_reader.fill_buf() {
28 |             Ok(result) => {
29 |                 if !result.is_empty() {
30 |                     match self.buf_reader.seek(SeekFrom::Current(0)) {
31 |                         Ok(position) => {
32 |                             match D::deserialize(&mut self.buf_reader) {
33 |                                 Ok(v) => Some(Ok((v, position))),
34 |                                 _ => Some(Err(Error::FailedToDeserialize(position)))
35 |                             }
36 |                         },
37 |                         _ => Some(Err(Error::FailedToSeek))
38 |                     }
39 |                 } else {
40 |                     None
41 |                 }
42 |             },
43 |             _ => Some(Err(Error::FailedToFillBuf)),
44 |         }
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/messagepack-rs/src/value.rs:
--------------------------------------------------------------------------------
 1 | use crate::binary::Binary;
 2 | use crate::deserializable::Deserializable;
 3 | use crate::extension::Extension;
 4 | use crate::serializable::{Serializable, SerializeError};
 5 | use chrono::prelude::*;
 6 | use messagepack_rs_macros::MessagePackFrom;
 7 | use std::collections::BTreeMap;
 8 | 
 9 | #[derive(Clone, Debug, PartialEq, MessagePackFrom)]
10 | pub enum Value {
11 |     Nil,
12 |     Bool(bool),
13 |     Float32(f32),
14 |     Float64(f64),
15 |     UInt8(u8),
16 |     UInt16(u16),
17 |     UInt32(u32),
18 |     UInt64(u64),
19 |     Int8(i8),
20 |     Int16(i16),
21 |     Int32(i32),
22 |     Int64(i64),
23 |     Binary(Binary),
24 |     String(String),
25 |     Array(Vec<Self>),
26 |     Map(BTreeMap<String, Self>),
27 |     Extension(Extension),
28 |     Timestamp(DateTime<Utc>),
29 | }
30 | 
31 | impl Serializable for Value {
32 |     fn serialize(self) -> Result<Vec<u8>, SerializeError> {
33 |         match self {
34 |             Self::Nil => Self::serialize_nil(),
35 |             Self::Bool(v) => Self::serialize_bool(v),
36 |             Self::Float32(v) => Self::serialize_float32(v),
37 |             Self::Float64(v) => Self::serialize_float64(v),
38 |             Self::UInt8(v) => Self::serialize_uint8(v),
39 |             Self::UInt16(v) => Self::serialize_uint16(v),
40 |             Self::UInt32(v) => Self::serialize_uint32(v),
41 |             Self::UInt64(v) => Self::serialize_uint64(v),
42 |             Self::Int8(v) => Self::serialize_int8(v),
43 |             Self::Int16(v) => Self::serialize_int16(v),
44 |             Self::Int32(v) => Self::serialize_int32(v),
45 |             Self::Int64(v) => Self::serialize_int64(v),
46 |             Self::Binary(v) => Self::serialize_binary(v),
47 |             Self::String(v) => Self::serialize_string(v),
48 |             Self::Array(v) => Self::serialize_array(v),
49 |             Self::Map(v) => Self::serialize_map(v),
50 |             Self::Extension(v) => Self::serialize_extension(v),
51 |             Self::Timestamp(v) => Self::serialize_timestamp(v),
52 |         }
53 |     }
54 | }
55 | 
56 | impl Deserializable for Value {}
57 | 


--------------------------------------------------------------------------------
/messagepack-rs-macros/src/lib.rs:
--------------------------------------------------------------------------------
  1 | #![forbid(unsafe_code)]
  2 | 
  3 | extern crate proc_macro;
  4 | 
  5 | use crate::proc_macro::TokenStream;
  6 | use quote::quote;
  7 | use syn;
  8 | 
  9 | #[proc_macro_derive(MessagePackFrom)]
 10 | pub fn message_pack_from_macro_derive(input: TokenStream) -> TokenStream {
 11 |     let ast = syn::parse(input).unwrap();
 12 |     impl_message_pack_from_macro(&ast)
 13 | }
 14 | 
 15 | fn impl_message_pack_from_macro(ast: &syn::DeriveInput) -> TokenStream {
 16 |     let name = &ast.ident;
 17 |     let gen = quote! {
 18 |         impl<T: Into<#name>> From<Option<T>> for #name {
 19 |             fn from(value: Option<T>) -> Self {
 20 |                 value.map_or(Self::Nil, Into::into)
 21 |             }
 22 |         }
 23 | 
 24 |         impl From<bool> for #name {
 25 |             fn from(value: bool) -> Self {
 26 |                 Self::Bool(value)
 27 |             }
 28 |         }
 29 | 
 30 |         impl From<f32> for #name {
 31 |             fn from(value: f32) -> Self {
 32 |                 Self::Float32(value)
 33 |             }
 34 |         }
 35 | 
 36 |         impl From<f64> for #name {
 37 |             fn from(value: f64) -> Self {
 38 |                 Self::Float64(value)
 39 |             }
 40 |         }
 41 | 
 42 |         impl From<u8> for #name {
 43 |             fn from(value: u8) -> Self {
 44 |                 Self::UInt8(value)
 45 |             }
 46 |         }
 47 | 
 48 |         impl From<u16> for #name {
 49 |             fn from(value: u16) -> Self {
 50 |                 Self::UInt16(value)
 51 |             }
 52 |         }
 53 | 
 54 |         impl From<u32> for #name {
 55 |             fn from(value: u32) -> Self {
 56 |                 Self::UInt32(value)
 57 |             }
 58 |         }
 59 | 
 60 |         impl From<u64> for #name {
 61 |             fn from(value: u64) -> Self {
 62 |                 Self::UInt64(value)
 63 |             }
 64 |         }
 65 | 
 66 |         impl From<i8> for #name {
 67 |             fn from(value: i8) -> Self {
 68 |                 Self::Int8(value)
 69 |             }
 70 |         }
 71 | 
 72 |         impl From<i16> for #name {
 73 |             fn from(value: i16) -> Self {
 74 |                 Self::Int16(value)
 75 |             }
 76 |         }
 77 | 
 78 |         impl From<i32> for #name {
 79 |             fn from(value: i32) -> Self {
 80 |                 Self::Int32(value)
 81 |             }
 82 |         }
 83 | 
 84 |         impl From<i64> for #name {
 85 |             fn from(value: i64) -> Self {
 86 |                 Self::Int64(value)
 87 |             }
 88 |         }
 89 | 
 90 |         impl From<String> for #name {
 91 |             fn from(value: String) -> Self {
 92 |                 Self::String(value)
 93 |             }
 94 |         }
 95 | 
 96 |         impl From<Binary> for #name {
 97 |             fn from(value: Binary) -> Self {
 98 |                 Self::Binary(value)
 99 |             }
100 |         }
101 | 
102 |         impl From<&str> for #name {
103 |             fn from(value: &str) -> Self {
104 |                 Self::String(String::from(value))
105 |             }
106 |         }
107 | 
108 |         impl From<Vec<Self>> for #name {
109 |             fn from(value: Vec<Self>) -> Self {
110 |                 Self::Array(value)
111 |             }
112 |         }
113 | 
114 |         impl From<&[Self]> for #name {
115 |             fn from(value: &[Self]) -> Self {
116 |                 Self::Array(Vec::from(value))
117 |             }
118 |         }
119 | 
120 |         impl From<BTreeMap<String, Self>> for #name {
121 |             fn from(value: BTreeMap<String, Self>) -> Self {
122 |                 Self::Map(value)
123 |             }
124 |         }
125 | 
126 |         impl From<Extension> for #name {
127 |             fn from(value: Extension) -> Self {
128 |                 Self::Extension(value)
129 |             }
130 |         }
131 | 
132 |         impl From<DateTime<Utc>> for #name {
133 |             fn from(value: DateTime<Utc>) -> Self {
134 |                 Self::Timestamp(value)
135 |             }
136 |         }
137 |     };
138 |     gen.into()
139 | }
140 | 


--------------------------------------------------------------------------------
/messagepack-rs/examples/extension2.rs:
--------------------------------------------------------------------------------
  1 | use byteorder::{ReadBytesExt, WriteBytesExt};
  2 | use chrono::prelude::*;
  3 | use messagepack_rs::binary::Binary;
  4 | use messagepack_rs::deserializable::{Deserializable, DeserializeError};
  5 | use messagepack_rs::extension::Extension;
  6 | use messagepack_rs::marker::Marker;
  7 | use messagepack_rs::serializable::{Serializable, SerializeError};
  8 | use messagepack_rs_macros::MessagePackFrom;
  9 | use std::collections::BTreeMap;
 10 | use std::io::{BufReader, Cursor, Read};
 11 | 
 12 | #[derive(Clone, Debug, PartialEq)]
 13 | struct Rgba {
 14 |     r: u8,
 15 |     g: u8,
 16 |     b: u8,
 17 |     a: u8,
 18 | }
 19 | 
 20 | #[derive(Clone, Debug, PartialEq, MessagePackFrom)]
 21 | enum MyValue {
 22 |     Nil,
 23 |     Bool(bool),
 24 |     Float32(f32),
 25 |     Float64(f64),
 26 |     UInt8(u8),
 27 |     UInt16(u16),
 28 |     UInt32(u32),
 29 |     UInt64(u64),
 30 |     Int8(i8),
 31 |     Int16(i16),
 32 |     Int32(i32),
 33 |     Int64(i64),
 34 |     Binary(Binary),
 35 |     String(String),
 36 |     Array(Vec<Self>),
 37 |     Map(BTreeMap<String, Self>),
 38 |     Extension(Extension),
 39 |     Timestamp(DateTime<Utc>),
 40 |     Rgba(Rgba),
 41 | }
 42 | 
 43 | impl From<Rgba> for MyValue {
 44 |     fn from(value: Rgba) -> Self {
 45 |         Self::Rgba(value)
 46 |     }
 47 | }
 48 | 
 49 | impl Serializable for MyValue {
 50 |     fn serialize(self) -> Result<Vec<u8>, SerializeError> {
 51 |         match self {
 52 |             Self::Nil => Self::serialize_nil(),
 53 |             Self::Bool(v) => Self::serialize_bool(v),
 54 |             Self::Float32(v) => Self::serialize_float32(v),
 55 |             Self::Float64(v) => Self::serialize_float64(v),
 56 |             Self::UInt8(v) => Self::serialize_uint8(v),
 57 |             Self::UInt16(v) => Self::serialize_uint16(v),
 58 |             Self::UInt32(v) => Self::serialize_uint32(v),
 59 |             Self::UInt64(v) => Self::serialize_uint64(v),
 60 |             Self::Int8(v) => Self::serialize_int8(v),
 61 |             Self::Int16(v) => Self::serialize_int16(v),
 62 |             Self::Int32(v) => Self::serialize_int32(v),
 63 |             Self::Int64(v) => Self::serialize_int64(v),
 64 |             Self::Binary(v) => Self::serialize_binary(v),
 65 |             Self::String(v) => Self::serialize_string(v),
 66 |             Self::Array(v) => Self::serialize_array(v),
 67 |             Self::Map(v) => Self::serialize_map(v),
 68 |             Self::Extension(v) => Self::serialize_extension(v),
 69 |             Self::Timestamp(v) => Self::serialize_timestamp(v),
 70 |             Self::Rgba(v) => {
 71 |                 let mut w = Vec::with_capacity(1 + 1 + 4);
 72 |                 w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
 73 |                 w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
 74 |                 w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
 75 |                 w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
 76 |                 w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
 77 |                 w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
 78 |                 Ok(w)
 79 |             },
 80 |         }
 81 |     }
 82 | }
 83 | 
 84 | impl Deserializable for MyValue {
 85 |     fn deserialize_extension_for_the_you_type_defined<R: Read>(t: i8, size: usize, buf_reader: &mut R) -> Result<Self, DeserializeError> {
 86 |         if t == 0 {
 87 |             Ok(From::from(Rgba {
 88 |                 r: buf_reader.read_u8().or(Err(DeserializeError::InvalidValue))?,
 89 |                 g: buf_reader.read_u8().or(Err(DeserializeError::InvalidValue))?,
 90 |                 b: buf_reader.read_u8().or(Err(DeserializeError::InvalidValue))?,
 91 |                 a: buf_reader.read_u8().or(Err(DeserializeError::InvalidValue))?,
 92 |             }))
 93 |         } else {
 94 |             Self::deserialize_extension_others(t, size, buf_reader)
 95 |         }
 96 |     }
 97 | }
 98 | 
 99 | fn main() {
100 |     let rgba = Rgba { r: 5, g: 10, b: 15, a: 20 };
101 |     let value = MyValue::from(rgba);
102 |     println!("{:?}", value);
103 | 
104 |     let serialized_value = value.serialize().unwrap();
105 |     println!("{:?}", serialized_value);
106 | 
107 |     let deserialized_value = MyValue::deserialize(&mut BufReader::new(Cursor::new(serialized_value))).unwrap();
108 |     println!("{:?}", deserialized_value);
109 | }
110 | 


--------------------------------------------------------------------------------
/messagepack-rs/src/deserializable.rs:
--------------------------------------------------------------------------------
  1 | use byteorder::{BigEndian, ReadBytesExt};
  2 | use chrono::prelude::*;
  3 | use crate::binary::Binary;
  4 | use crate::extension::Extension;
  5 | use crate::marker::Marker;
  6 | use std::collections::BTreeMap;
  7 | use std::io::Read;
  8 | 
  9 | #[derive(Debug)]
 10 | pub enum DeserializeError {
 11 |     InvalidLength,
 12 |     InvalidMarker,
 13 |     InvalidValue,
 14 | }
 15 | 
 16 | pub trait Deserializable: Sized + From<Option<Self>> + From<bool> + From<Binary> + From<f32> + From<f64> + From<u8> + From<u16> + From<u32> + From<u64> + From<i8> + From<i16> + From<i32> + From<i64> + From<String> + From<Vec<Self>> + From<BTreeMap<String, Self>> + From<Extension> + From<DateTime<Utc>> {
 17 |     fn deserialize<R: Read>(buf_reader: &mut R) -> Result<Self, DeserializeError> {
 18 |         match Marker::from(buf_reader.read_u8().or(Err(DeserializeError::InvalidMarker))?) {
 19 |             Marker::PositiveFixInt(n) => Ok(Self::from(n)),
 20 |             Marker::FixMap(n) => Self::deserialize_map(n as usize, buf_reader),
 21 |             Marker::FixArray(n) => Self::deserialize_array(n as usize, buf_reader),
 22 |             Marker::FixStr(n) => Self::deserialize_string(n as usize, buf_reader),
 23 |             Marker::Nil => Ok(Self::from(None::<Self>)),
 24 |             Marker::Reserved => Err(DeserializeError::InvalidMarker),
 25 |             Marker::False => Ok(Self::from(false)),
 26 |             Marker::True => Ok(Self::from(true)),
 27 |             Marker::Bin8 => Self::deserialize_binary(buf_reader.read_u8().or(Err(DeserializeError::InvalidLength))? as usize, buf_reader),
 28 |             Marker::Bin16 => Self::deserialize_binary(buf_reader.read_u16::<BigEndian>().or(Err(DeserializeError::InvalidLength))? as usize, buf_reader),
 29 |             Marker::Bin32 => Self::deserialize_binary(buf_reader.read_u32::<BigEndian>().or(Err(DeserializeError::InvalidLength))? as usize, buf_reader),
 30 |             Marker::Ext8 => Self::deserialize_extension(buf_reader.read_u8().or(Err(DeserializeError::InvalidLength))? as usize, buf_reader),
 31 |             Marker::Ext16 => Self::deserialize_extension(buf_reader.read_u16::<BigEndian>().or(Err(DeserializeError::InvalidLength))? as usize, buf_reader),
 32 |             Marker::Ext32 => Self::deserialize_extension(buf_reader.read_u32::<BigEndian>().or(Err(DeserializeError::InvalidLength))? as usize, buf_reader),
 33 |             Marker::Float32 => Ok(Self::from(buf_reader.read_f32::<BigEndian>().or(Err(DeserializeError::InvalidValue))?)),
 34 |             Marker::Float64 => Ok(Self::from(buf_reader.read_f64::<BigEndian>().or(Err(DeserializeError::InvalidValue))?)),
 35 |             Marker::UInt8 => Ok(Self::from(buf_reader.read_u8().or(Err(DeserializeError::InvalidValue))?)),
 36 |             Marker::UInt16 => Ok(Self::from(buf_reader.read_u16::<BigEndian>().or(Err(DeserializeError::InvalidValue))?)),
 37 |             Marker::UInt32 => Ok(Self::from(buf_reader.read_u32::<BigEndian>().or(Err(DeserializeError::InvalidValue))?)),
 38 |             Marker::UInt64 => Ok(Self::from(buf_reader.read_u64::<BigEndian>().or(Err(DeserializeError::InvalidValue))?)),
 39 |             Marker::Int8 => Ok(Self::from(buf_reader.read_i8().or(Err(DeserializeError::InvalidValue))?)),
 40 |             Marker::Int16 => Ok(Self::from(buf_reader.read_i16::<BigEndian>().or(Err(DeserializeError::InvalidValue))?)),
 41 |             Marker::Int32 => Ok(Self::from(buf_reader.read_i32::<BigEndian>().or(Err(DeserializeError::InvalidValue))?)),
 42 |             Marker::Int64 => Ok(Self::from(buf_reader.read_i64::<BigEndian>().or(Err(DeserializeError::InvalidValue))?)),
 43 |             Marker::FixExt1 => Self::deserialize_extension(1, buf_reader),
 44 |             Marker::FixExt2 => Self::deserialize_extension(2, buf_reader),
 45 |             Marker::FixExt4 => Self::deserialize_extension(4, buf_reader),
 46 |             Marker::FixExt8 => Self::deserialize_extension(8, buf_reader),
 47 |             Marker::FixExt16 => Self::deserialize_extension(16, buf_reader),
 48 |             Marker::Str8 => Self::deserialize_string(buf_reader.read_u8().or(Err(DeserializeError::InvalidLength))? as usize, buf_reader),
 49 |             Marker::Str16 => Self::deserialize_string(buf_reader.read_u16::<BigEndian>().or(Err(DeserializeError::InvalidLength))? as usize, buf_reader),
 50 |             Marker::Str32 => Self::deserialize_string(buf_reader.read_u32::<BigEndian>().or(Err(DeserializeError::InvalidLength))? as usize, buf_reader),
 51 |             Marker::Array16 => Self::deserialize_array(buf_reader.read_u16::<BigEndian>().or(Err(DeserializeError::InvalidLength))? as usize, buf_reader),
 52 |             Marker::Array32 => Self::deserialize_array(buf_reader.read_u32::<BigEndian>().or(Err(DeserializeError::InvalidLength))? as usize, buf_reader),
 53 |             Marker::Map16 => Self::deserialize_map(buf_reader.read_u16::<BigEndian>().or(Err(DeserializeError::InvalidLength))? as usize, buf_reader),
 54 |             Marker::Map32 => Self::deserialize_map(buf_reader.read_u32::<BigEndian>().or(Err(DeserializeError::InvalidLength))? as usize, buf_reader),
 55 |             Marker::NegativeFixInt(n) => Ok(Self::from(n)),
 56 |         }
 57 |     }
 58 | 
 59 |     fn deserialize_binary<R: Read>(size: usize, buf_reader: &mut R) -> Result<Self, DeserializeError> {
 60 |         let mut buf = vec![0; size];
 61 |         buf_reader.read_exact(&mut buf[..]).or(Err(DeserializeError::InvalidValue))?;
 62 |         Ok(From::from(Binary(buf)))
 63 |     }
 64 | 
 65 |     fn deserialize_string<R: Read>(size: usize, buf_reader: &mut R) -> Result<Self, DeserializeError> {
 66 |         let mut buf = vec![0; size];
 67 |         buf_reader.read_exact(&mut buf).or(Err(DeserializeError::InvalidValue))?;
 68 |         Ok(From::from(String::from_utf8(buf).or(Err(DeserializeError::InvalidValue))?))
 69 |     }
 70 | 
 71 |     fn deserialize_array<R: Read>(size: usize, buf_reader: &mut R) -> Result<Self, DeserializeError> {
 72 |         let mut buf = Vec::with_capacity(size);
 73 |         for _ in 0..size {
 74 |             buf.push(Self::deserialize(buf_reader)?);
 75 |         }
 76 |         Ok(From::from(buf))
 77 |     }
 78 | 
 79 |     fn deserialize_map<R: Read>(size: usize, buf_reader: &mut R) -> Result<Self, DeserializeError> {
 80 |         fn deserialize_string_primitive<R: Read>(buf_reader: &mut R) -> Result<String, DeserializeError> {
 81 |             let mut buf = match From::from(buf_reader.read_u8().or(Err(DeserializeError::InvalidMarker))?) {
 82 |                 Marker::FixStr(n) => vec![0; n as usize],
 83 |                 Marker::Str8 => vec![0; buf_reader.read_u8().or(Err(DeserializeError::InvalidLength))? as usize],
 84 |                 Marker::Str16 => vec![0; buf_reader.read_u16::<BigEndian>().or(Err(DeserializeError::InvalidLength))? as usize],
 85 |                 Marker::Str32 => vec![0; buf_reader.read_u32::<BigEndian>().or(Err(DeserializeError::InvalidLength))? as usize],
 86 |                 _ => Err(DeserializeError::InvalidMarker)?
 87 |             };
 88 |             buf_reader.read_exact(&mut buf[..]).or(Err(DeserializeError::InvalidValue))?;
 89 |             String::from_utf8(buf).or(Err(DeserializeError::InvalidValue))
 90 |         }
 91 | 
 92 |         let mut buf = BTreeMap::new();
 93 |         for _ in 0..size {
 94 |             buf.insert(deserialize_string_primitive(buf_reader)?, Self::deserialize(buf_reader)?);
 95 |         }
 96 |         Ok(From::from(buf))
 97 |     }
 98 | 
 99 |     fn deserialize_extension<R: Read>(size: usize, buf_reader: &mut R) -> Result<Self, DeserializeError> {
100 |         let t = buf_reader.read_i8().or(Err(DeserializeError::InvalidLength))?;
101 | 
102 |         if t == -1 {
103 |             if size == 4 {
104 |                 let value = buf_reader.read_u32::<BigEndian>().or(Err(DeserializeError::InvalidValue))?;
105 |                 Utc.timestamp_opt(i64::from(value), 0).single().map(Self::from).ok_or(DeserializeError::InvalidValue)
106 |             } else if size == 8 {
107 |                 let value = buf_reader.read_u64::<BigEndian>().or(Err(DeserializeError::InvalidValue))?;
108 |                 let nano = value >> 34;
109 |                 let sec = value & 0x00_00_00_03_ff_ff_ff_ff;
110 |                 Utc.timestamp_opt(sec as i64, nano as u32).single().map(Self::from).ok_or(DeserializeError::InvalidValue)
111 |             } else if size == 12 {
112 |                 let nano = buf_reader.read_u32::<BigEndian>().or(Err(DeserializeError::InvalidValue))?;
113 |                 let sec = buf_reader.read_i64::<BigEndian>().or(Err(DeserializeError::InvalidValue))?;
114 |                 Utc.timestamp_opt(sec, nano).single().map(Self::from).ok_or(DeserializeError::InvalidValue)
115 |             } else {
116 |                 Err(DeserializeError::InvalidValue)
117 |             }
118 |         } else {
119 |             Self::deserialize_extension_for_the_you_type_defined(t, size, buf_reader)
120 |         }
121 |     }
122 | 
123 |     fn deserialize_extension_for_the_you_type_defined<R: Read>(t: i8, size: usize, buf_reader: &mut R) -> Result<Self, DeserializeError> {
124 |         Self::deserialize_extension_others(t, size, buf_reader)
125 |     }
126 | 
127 |     fn deserialize_extension_others<R: Read>(t: i8, size: usize, buf_reader: &mut R) -> Result<Self, DeserializeError> {
128 |         let mut data = vec![0; size];
129 |         buf_reader.read_exact(&mut data[..]).or(Err(DeserializeError::InvalidValue))?;
130 |         Ok(From::from(Extension { t, data }))
131 |     }
132 | }
133 | 


--------------------------------------------------------------------------------
/messagepack-rs/src/serializable.rs:
--------------------------------------------------------------------------------
  1 | use byteorder::{BigEndian, WriteBytesExt};
  2 | use chrono::prelude::*;
  3 | use crate::binary::Binary;
  4 | use crate::extension::Extension;
  5 | use crate::marker::Marker;
  6 | use std::collections::BTreeMap;
  7 | use std::io::Write;
  8 | 
  9 | #[derive(Debug)]
 10 | pub enum SerializeError {
 11 |     FailedToWrite,
 12 |     OutOfRange,
 13 | }
 14 | 
 15 | pub trait Serializable: Sized {
 16 |     fn serialize(self) -> Result<Vec<u8>, SerializeError>;
 17 | 
 18 |     fn serialize_nil() -> Result<Vec<u8>, SerializeError> {
 19 |         Ok(vec![Marker::Nil.into()])
 20 |     }
 21 | 
 22 |     fn serialize_bool(v: bool) -> Result<Vec<u8>, SerializeError> {
 23 |         Ok(if v { vec![Marker::True.into()] } else { vec![Marker::False.into()] })
 24 |     }
 25 | 
 26 |     fn serialize_float32(v: f32) -> Result<Vec<u8>, SerializeError> {
 27 |         let mut w = Vec::with_capacity(1 + 4);
 28 |         w.write_u8(Marker::Float32.into()).or(Err(SerializeError::FailedToWrite))?;
 29 |         w.write_f32::<BigEndian>(v).or(Err(SerializeError::FailedToWrite))?;
 30 |         Ok(w)
 31 |     }
 32 | 
 33 |     fn serialize_float64(v: f64) -> Result<Vec<u8>, SerializeError> {
 34 |         let mut w = Vec::with_capacity(1 + 8);
 35 |         w.write_u8(Marker::Float64.into()).or(Err(SerializeError::FailedToWrite))?;
 36 |         w.write_f64::<BigEndian>(v).or(Err(SerializeError::FailedToWrite))?;
 37 |         Ok(w)
 38 |     }
 39 | 
 40 |     fn serialize_uint8(v: u8) -> Result<Vec<u8>, SerializeError> {
 41 |         if v < 0b1000_0000 {
 42 |             let mut w = Vec::with_capacity(1);
 43 |             w.write_u8(v).or(Err(SerializeError::FailedToWrite))?;
 44 |             Ok(w)
 45 |         } else {
 46 |             let mut w = Vec::with_capacity(1 + 1);
 47 |             w.write_u8(Marker::UInt8.into()).or(Err(SerializeError::FailedToWrite))?;
 48 |             w.write_u8(v).or(Err(SerializeError::FailedToWrite))?;
 49 |             Ok(w)
 50 |         }
 51 |     }
 52 | 
 53 |     fn serialize_uint16(v: u16) -> Result<Vec<u8>, SerializeError> {
 54 |         if v < 0b1000_0000 {
 55 |             let mut w = Vec::with_capacity(1);
 56 |             w.write_u8(v as u8).or(Err(SerializeError::FailedToWrite))?;
 57 |             Ok(w)
 58 |         } else if v <= u16::from(u8::max_value()) {
 59 |             let mut w = Vec::with_capacity(1 + 1);
 60 |             w.write_u8(Marker::UInt8.into()).or(Err(SerializeError::FailedToWrite))?;
 61 |             w.write_u8(v as u8).or(Err(SerializeError::FailedToWrite))?;
 62 |             Ok(w)
 63 |         } else {
 64 |             let mut w = Vec::with_capacity(1 + 2);
 65 |             w.write_u8(Marker::UInt16.into()).or(Err(SerializeError::FailedToWrite))?;
 66 |             w.write_u16::<BigEndian>(v).or(Err(SerializeError::FailedToWrite))?;
 67 |             Ok(w)
 68 |         }
 69 |     }
 70 | 
 71 |     fn serialize_uint32(v: u32) -> Result<Vec<u8>, SerializeError> {
 72 |         if v < 0b1000_0000 {
 73 |             let mut w = Vec::with_capacity(1);
 74 |             w.write_u8(v as u8).or(Err(SerializeError::FailedToWrite))?;
 75 |             Ok(w)
 76 |         } else if v <= u32::from(u8::max_value()) {
 77 |             let mut w = Vec::with_capacity(1 + 1);
 78 |             w.write_u8(Marker::UInt8.into()).or(Err(SerializeError::FailedToWrite))?;
 79 |             w.write_u8(v as u8).or(Err(SerializeError::FailedToWrite))?;
 80 |             Ok(w)
 81 |         } else if v <= u32::from(u16::max_value()) {
 82 |             let mut w = Vec::with_capacity(1 + 2);
 83 |             w.write_u8(Marker::UInt16.into()).or(Err(SerializeError::FailedToWrite))?;
 84 |             w.write_u16::<BigEndian>(v as u16).or(Err(SerializeError::FailedToWrite))?;
 85 |             Ok(w)
 86 |         } else {
 87 |             let mut w = Vec::with_capacity(1 + 4);
 88 |             w.write_u8(Marker::UInt32.into()).or(Err(SerializeError::FailedToWrite))?;
 89 |             w.write_u32::<BigEndian>(v).or(Err(SerializeError::FailedToWrite))?;
 90 |             Ok(w)
 91 |         }
 92 |     }
 93 | 
 94 |     fn serialize_uint64(v: u64) -> Result<Vec<u8>, SerializeError> {
 95 |         if v < 0b1000_0000 {
 96 |             let mut w = Vec::with_capacity(1);
 97 |             w.write_u8(v as u8).or(Err(SerializeError::FailedToWrite))?;
 98 |             Ok(w)
 99 |         } else if v <= u64::from(u8::max_value()) {
100 |             let mut w = Vec::with_capacity(1 + 1);
101 |             w.write_u8(Marker::UInt8.into()).or(Err(SerializeError::FailedToWrite))?;
102 |             w.write_u8(v as u8).or(Err(SerializeError::FailedToWrite))?;
103 |             Ok(w)
104 |         } else if v <= u64::from(u16::max_value()) {
105 |             let mut w = Vec::with_capacity(1 + 2);
106 |             w.write_u8(Marker::UInt16.into()).or(Err(SerializeError::FailedToWrite))?;
107 |             w.write_u16::<BigEndian>(v as u16).or(Err(SerializeError::FailedToWrite))?;
108 |             Ok(w)
109 |         } else if v <= u64::from(u32::max_value()) {
110 |             let mut w = Vec::with_capacity(1 + 4);
111 |             w.write_u8(Marker::UInt32.into()).or(Err(SerializeError::FailedToWrite))?;
112 |             w.write_u32::<BigEndian>(v as u32).or(Err(SerializeError::FailedToWrite))?;
113 |             Ok(w)
114 |         } else {
115 |             let mut w = Vec::with_capacity(1 + 8);
116 |             w.write_u8(Marker::UInt64.into()).or(Err(SerializeError::FailedToWrite))?;
117 |             w.write_u64::<BigEndian>(v).or(Err(SerializeError::FailedToWrite))?;
118 |             Ok(w)
119 |         }
120 |     }
121 | 
122 |     fn serialize_int8(v: i8) -> Result<Vec<u8>, SerializeError> {
123 |         if v >= -0b0010_0000 {
124 |             let mut w = Vec::with_capacity(1);
125 |             w.write_i8(v).or(Err(SerializeError::FailedToWrite))?;
126 |             Ok(w)
127 |         } else {
128 |             let mut w = Vec::with_capacity(1 + 1);
129 |             w.write_u8(Marker::Int8.into()).or(Err(SerializeError::FailedToWrite))?;
130 |             w.write_i8(v).or(Err(SerializeError::FailedToWrite))?;
131 |             Ok(w)
132 |         }
133 |     }
134 | 
135 |     fn serialize_int16(v: i16) -> Result<Vec<u8>, SerializeError> {
136 |         if v >= -0b0010_0000 {
137 |             let mut w = Vec::with_capacity(1);
138 |             w.write_i8(v as i8).or(Err(SerializeError::FailedToWrite))?;
139 |             Ok(w)
140 |         } else if v >= i16::from(i8::min_value()) && v <= i16::from(i8::max_value()) {
141 |             let mut w = Vec::with_capacity(1 + 1);
142 |             w.write_u8(Marker::Int8.into()).or(Err(SerializeError::FailedToWrite))?;
143 |             w.write_i8(v as i8).or(Err(SerializeError::FailedToWrite))?;
144 |             Ok(w)
145 |         } else {
146 |             let mut w = Vec::with_capacity(1 + 2);
147 |             w.write_u8(Marker::Int16.into()).or(Err(SerializeError::FailedToWrite))?;
148 |             w.write_i16::<BigEndian>(v).or(Err(SerializeError::FailedToWrite))?;
149 |             Ok(w)
150 |         }
151 |     }
152 | 
153 |     fn serialize_int32(v: i32) -> Result<Vec<u8>, SerializeError> {
154 |         if v >= -0b0010_0000 {
155 |             let mut w = Vec::with_capacity(1);
156 |             w.write_i8(v as i8).or(Err(SerializeError::FailedToWrite))?;
157 |             Ok(w)
158 |         } else if v >= i32::from(i8::min_value()) && v <= i32::from(i8::max_value()) {
159 |             let mut w = Vec::with_capacity(1 + 1);
160 |             w.write_u8(Marker::Int8.into()).or(Err(SerializeError::FailedToWrite))?;
161 |             w.write_i8(v as i8).or(Err(SerializeError::FailedToWrite))?;
162 |             Ok(w)
163 |         } else if v >= i32::from(i16::min_value()) && v <= i32::from(i16::max_value()) {
164 |             let mut w = Vec::with_capacity(1 + 2);
165 |             w.write_u8(Marker::Int16.into()).or(Err(SerializeError::FailedToWrite))?;
166 |             w.write_i16::<BigEndian>(v as i16).or(Err(SerializeError::FailedToWrite))?;
167 |             Ok(w)
168 |         } else {
169 |             let mut w = Vec::with_capacity(1 + 4);
170 |             w.write_u8(Marker::Int32.into()).or(Err(SerializeError::FailedToWrite))?;
171 |             w.write_i32::<BigEndian>(v).or(Err(SerializeError::FailedToWrite))?;
172 |             Ok(w)
173 |         }
174 |     }
175 | 
176 |     fn serialize_int64(v: i64) -> Result<Vec<u8>, SerializeError> {
177 |         if v >= -0b0010_0000 {
178 |             let mut w = Vec::with_capacity(1);
179 |             w.write_i8(v as i8).or(Err(SerializeError::FailedToWrite))?;
180 |             Ok(w)
181 |         } else if v >= i64::from(i8::min_value()) && v <= i64::from(i8::max_value()) {
182 |             let mut w = Vec::with_capacity(1 + 1);
183 |             w.write_u8(Marker::Int8.into()).or(Err(SerializeError::FailedToWrite))?;
184 |             w.write_i8(v as i8).or(Err(SerializeError::FailedToWrite))?;
185 |             Ok(w)
186 |         } else if v >= i64::from(i16::min_value()) && v <= i64::from(i16::max_value()) {
187 |             let mut w = Vec::with_capacity(1 + 2);
188 |             w.write_u8(Marker::Int16.into()).or(Err(SerializeError::FailedToWrite))?;
189 |             w.write_i16::<BigEndian>(v as i16).or(Err(SerializeError::FailedToWrite))?;
190 |             Ok(w)
191 |         } else if v >= i64::from(i32::min_value()) && v <= i64::from(i32::max_value()) {
192 |             let mut w = Vec::with_capacity(1 + 4);
193 |             w.write_u8(Marker::Int32.into()).or(Err(SerializeError::FailedToWrite))?;
194 |             w.write_i32::<BigEndian>(v as i32).or(Err(SerializeError::FailedToWrite))?;
195 |             Ok(w)
196 |         } else {
197 |             let mut w = Vec::with_capacity(1 + 8);
198 |             w.write_u8(Marker::Int64.into()).or(Err(SerializeError::FailedToWrite))?;
199 |             w.write_i64::<BigEndian>(v).or(Err(SerializeError::FailedToWrite))?;
200 |             Ok(w)
201 |         }
202 |     }
203 | 
204 |     fn serialize_binary(v: Binary) -> Result<Vec<u8>, SerializeError> {
205 |         let mut w = match v.0.len() {
206 |             len if u8::max_value() as usize >= len => {
207 |                 let mut w = Vec::with_capacity(1 + 1 + len);
208 |                 w.write_u8(Marker::Bin8.into()).or(Err(SerializeError::FailedToWrite))?;
209 |                 w.write_u8(len as u8).or(Err(SerializeError::FailedToWrite))?;
210 |                 w
211 |             },
212 |             len if u16::max_value() as usize >= len => {
213 |                 let mut w = Vec::with_capacity(1 + 2 + len);
214 |                 w.write_u8(Marker::Bin16.into()).or(Err(SerializeError::FailedToWrite))?;
215 |                 w.write_u16::<BigEndian>(len as u16).or(Err(SerializeError::FailedToWrite))?;
216 |                 w
217 |             },
218 |             len if u32::max_value() as usize >= len => {
219 |                 let mut w = Vec::with_capacity(1 + 4 + len);
220 |                 w.write_u8(Marker::Bin32.into()).or(Err(SerializeError::FailedToWrite))?;
221 |                 w.write_u32::<BigEndian>(len as u32).or(Err(SerializeError::FailedToWrite))?;
222 |                 w
223 |             },
224 |             _ => Err(SerializeError::OutOfRange)?,
225 |         };
226 |         w.write_all(&v.0).or(Err(SerializeError::FailedToWrite))?;
227 |         Ok(w)
228 |     }
229 | 
230 |     fn serialize_string(v: String) -> Result<Vec<u8>, SerializeError> {
231 |         let mut w = match v.len() {
232 |             len if len <= 31 => {
233 |                 let mut w = Vec::with_capacity(1 + len);
234 |                 w.write_u8(Marker::FixStr(len as u8).into()).or(Err(SerializeError::FailedToWrite))?;
235 |                 w
236 |             },
237 |             len if u8::max_value() as usize >= len => {
238 |                 let mut w = Vec::with_capacity(1 + 1 + len);
239 |                 w.write_u8(Marker::Str8.into()).or(Err(SerializeError::FailedToWrite))?;
240 |                 w.write_u8(len as u8).or(Err(SerializeError::FailedToWrite))?;
241 |                 w
242 |             },
243 |             len if u16::max_value() as usize >= len => {
244 |                 let mut w = Vec::with_capacity(1 + 2 + len);
245 |                 w.write_u8(Marker::Str16.into()).or(Err(SerializeError::FailedToWrite))?;
246 |                 w.write_u16::<BigEndian>(len as u16).or(Err(SerializeError::FailedToWrite))?;
247 |                 w
248 |             },
249 |             len if u32::max_value() as usize >= len => {
250 |                 let mut w = Vec::with_capacity(1 + 4 + len);
251 |                 w.write_u8(Marker::Str32.into()).or(Err(SerializeError::FailedToWrite))?;
252 |                 w.write_u32::<BigEndian>(len as u32).or(Err(SerializeError::FailedToWrite))?;
253 |                 w
254 |             },
255 |             _ => Err(SerializeError::OutOfRange)?,
256 |         };
257 |         w.write_all(v.as_bytes()).or(Err(SerializeError::FailedToWrite))?;
258 |         Ok(w)
259 |     }
260 | 
261 |     fn serialize_array(v: Vec<Self>) -> Result<Vec<u8>, SerializeError> {
262 |         let mut values = Vec::new();
263 |         let len = v.len();
264 |         for vv in v.into_iter() {
265 |             values.append(&mut Self::serialize(vv)?);
266 |         }
267 |         let mut w = match len {
268 |             len if len <= 15 => {
269 |                 let mut w = Vec::with_capacity(1 + values.len());
270 |                 w.write_u8(Marker::FixArray(len as u8).into()).or(Err(SerializeError::FailedToWrite))?;
271 |                 w
272 |             },
273 |             len if u16::max_value() as usize >= len => {
274 |                 let mut w = Vec::with_capacity(1 + 2 + values.len());
275 |                 w.write_u8(Marker::Array16.into()).or(Err(SerializeError::FailedToWrite))?;
276 |                 w.write_u16::<BigEndian>(len as u16).or(Err(SerializeError::FailedToWrite))?;
277 |                 w
278 |             },
279 |             len if u32::max_value() as usize >= len => {
280 |                 let mut w = Vec::with_capacity(1 + 4 + values.len());
281 |                 w.write_u8(Marker::Array32.into()).or(Err(SerializeError::FailedToWrite))?;
282 |                 w.write_u32::<BigEndian>(len as u32).or(Err(SerializeError::FailedToWrite))?;
283 |                 w
284 |             },
285 |             _ => Err(SerializeError::OutOfRange)?,
286 |         };
287 |         w.append(&mut values);
288 |         Ok(w)
289 |     }
290 | 
291 |     fn serialize_map(v: BTreeMap<String, Self>) -> Result<Vec<u8>, SerializeError> {
292 |         let mut w = match v.len() {
293 |             len if len <= 15 => {
294 |                 vec![Marker::FixMap(len as u8).into()]
295 |             },
296 |             len if u16::max_value() as usize >= len => {
297 |                 let mut w = vec![Marker::Map16.into()];
298 |                 w.write_u16::<BigEndian>(len as u16).or(Err(SerializeError::FailedToWrite))?;
299 |                 w
300 |             },
301 |             len if u32::max_value() as usize >= len => {
302 |                 let mut w = vec![Marker::Map32.into()];
303 |                 w.write_u32::<BigEndian>(len as u32).or(Err(SerializeError::FailedToWrite))?;
304 |                 w
305 |             },
306 |             _ => Err(SerializeError::OutOfRange)?,
307 |         };
308 |         for (k, v) in v {
309 |             w.write_all(&Self::serialize_string(k)?).or(Err(SerializeError::FailedToWrite))?;
310 |             w.write_all(&v.serialize()?).or(Err(SerializeError::FailedToWrite))?;
311 |         }
312 |         Ok(w)
313 |     }
314 | 
315 |     fn serialize_extension(mut v: Extension) -> Result<Vec<u8>, SerializeError> {
316 |         let mut w = match v.data.len() {
317 |             1 => {
318 |                 let mut w = Vec::with_capacity(1 + 1 + 1);
319 |                 w.write_u8(Marker::FixExt1.into()).or(Err(SerializeError::FailedToWrite))?;
320 |                 w
321 |             },
322 |             2 => {
323 |                 let mut w = Vec::with_capacity(1 + 1 + 2);
324 |                 w.write_u8(Marker::FixExt2.into()).or(Err(SerializeError::FailedToWrite))?;
325 |                 w
326 |             },
327 |             4 => {
328 |                 let mut w = Vec::with_capacity(1 + 1 + 4);
329 |                 w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
330 |                 w
331 |             },
332 |             8 => {
333 |                 let mut w = Vec::with_capacity(1 + 1 + 8);
334 |                 w.write_u8(Marker::FixExt8.into()).or(Err(SerializeError::FailedToWrite))?;
335 |                 w
336 |             },
337 |             16 => {
338 |                 let mut w = Vec::with_capacity(1 + 1 + 16);
339 |                 w.write_u8(Marker::FixExt16.into()).or(Err(SerializeError::FailedToWrite))?;
340 |                 w
341 |             },
342 |             len if len <= u8::max_value() as usize => {
343 |                 let mut w = Vec::with_capacity(1 + 1 + 1 + len);
344 |                 w.write_u8(Marker::Ext8.into()).or(Err(SerializeError::FailedToWrite))?;
345 |                 w.write_u8(len as u8).or(Err(SerializeError::FailedToWrite))?;
346 |                 w
347 |             },
348 |             len if len <= u16::max_value() as usize => {
349 |                 let mut w = Vec::with_capacity(1 + 2 + 1 + len);
350 |                 w.write_u8(Marker::Ext16.into()).or(Err(SerializeError::FailedToWrite))?;
351 |                 w.write_u16::<BigEndian>(len as u16).or(Err(SerializeError::FailedToWrite))?;
352 |                 w
353 |             },
354 |             len if len <= u32::max_value() as usize => {
355 |                 let mut w = Vec::with_capacity(1 + 4 + 1 + len);
356 |                 w.write_u8(Marker::Ext32.into()).or(Err(SerializeError::FailedToWrite))?;
357 |                 w.write_u32::<BigEndian>(len as u32).or(Err(SerializeError::FailedToWrite))?;
358 |                 w
359 |             },
360 |             _ => Err(SerializeError::OutOfRange)?,
361 |         };
362 |         w.write_i8(v.t).or(Err(SerializeError::FailedToWrite))?;
363 |         w.append(&mut v.data);
364 |         Ok(w)
365 |     }
366 | 
367 |     fn serialize_timestamp(v: DateTime<Utc>) -> Result<Vec<u8>, SerializeError> {
368 |         if v.timestamp() >> 34 == 0 {
369 |             let value = (u64::from(v.timestamp_subsec_nanos()) << 34) | (v.timestamp() as u64);
370 |             if value & 0xff_ff_ff_ff_00_00_00_00 == 0 {
371 |                 let mut w = Vec::with_capacity(1 + 1 + 4);
372 |                 w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
373 |                 w.write_i8(-1).or(Err(SerializeError::FailedToWrite))?;
374 |                 w.write_u32::<BigEndian>(value as u32).or(Err(SerializeError::FailedToWrite))?;
375 |                 Ok(w)
376 |             } else {
377 |                 let mut w = Vec::with_capacity(1 + 1 + 8);
378 |                 w.write_u8(Marker::FixExt8.into()).or(Err(SerializeError::FailedToWrite))?;
379 |                 w.write_i8(-1).or(Err(SerializeError::FailedToWrite))?;
380 |                 w.write_u64::<BigEndian>(value).or(Err(SerializeError::FailedToWrite))?;
381 |                 Ok(w)
382 |             }
383 |         } else {
384 |             let mut w = Vec::with_capacity(1 + 1 + 1 + 4 + 8);
385 |             w.write_u8(Marker::Ext8.into()).or(Err(SerializeError::FailedToWrite))?;
386 |             w.write_u8(12).or(Err(SerializeError::FailedToWrite))?;
387 |             w.write_i8(-1).or(Err(SerializeError::FailedToWrite))?;
388 |             w.write_u32::<BigEndian>(v.timestamp_subsec_nanos() as u32).or(Err(SerializeError::FailedToWrite))?;
389 |             w.write_i64::<BigEndian>(v.timestamp()).or(Err(SerializeError::FailedToWrite))?;
390 |             Ok(w)
391 |         }
392 |     }
393 | }
394 | 


--------------------------------------------------------------------------------