cbor_no_std/
ser.rs

1#[cfg(test)]
2use alloc::collections::btree_map::BTreeMap;
3use alloc::string::String;
4use bytes::bytes;
5use alloc::vec::Vec;
6use value::{Value};
7use io::{Writer, VecWriter};
8use constants::{
9    MAX_U8,
10    MAX_U16,
11    MAX_U32,
12    MAX_U64,
13};
14#[cfg(test)]
15use std::mem::transmute;
16#[cfg(not(test))]
17use core::mem::transmute;
18
19pub trait Serializer {
20    fn serialize_unsigned(&mut self, n: u64, major_type: u8);
21    fn serialize_bytes(&mut self, bytes: Vec<u8>);
22    fn serialize_seq(&mut self, len: usize);
23    fn serialize_map(&mut self, len: usize);
24    fn serialize_simple(&mut self, value: u64);
25    fn serialize_string(&mut self, string: &String);
26}
27
28pub trait Serialize {
29    fn serialize<S>(&mut self, serializer: &mut S) where S: Serializer;
30}
31
32pub struct VecSerializer<'a>  {
33    pub writer: VecWriter<'a>,
34}
35
36pub fn to_bytes(mut value: Value) -> Vec<u8>
37{
38    let mut output = Vec::with_capacity(128);
39    value.serialize(
40        &mut VecSerializer::from_vec_writer(
41            VecWriter{
42                output: &mut output,
43            }
44        )
45    );
46    output
47}
48
49impl<'a> VecSerializer<'a> {
50    fn from_vec_writer(vec_writer: VecWriter) -> VecSerializer {
51        VecSerializer{writer: vec_writer}
52    }
53
54    fn encode_unsigned(&mut self, n: u64, major_type: u8) -> Vec<u8> {
55        match n {
56            n if n < MAX_U8  => self.encode_u8(n as u8, major_type),
57            n if n < MAX_U16 => self.encode_u16(n as u16, major_type),
58            n if n < MAX_U32 => self.encode_u32(n as u32, major_type),
59            n if n < MAX_U64 => self.encode_u64(n as u64, major_type),
60            _ => unreachable!()
61        }
62    }
63
64    fn encode_u8(&self, value: u8, major_type: u8) -> Vec<u8> {
65        match value as u64 {
66            n @ 0 ... 23 => vec![bytes::concat(major_type, n as u8)],
67            n @ 24 ... 255 => vec![bytes::concat(major_type, 24), n as u8],
68            _ => unreachable!()
69        }
70    }
71
72    fn encode_u16(&self, value: u16, major_type: u8) -> Vec<u8> {
73        let mut header = vec![bytes::concat(major_type, 25)];
74        let mut value: Vec<u8> = unsafe {
75            transmute::<u16, [u8; 2]>((value as u16).to_be()).to_vec()
76        };
77        header.append(&mut value);
78        header
79    }
80
81    fn encode_u32(&self, value: u32, major_type: u8) -> Vec<u8> {
82        let mut header = vec![bytes::concat(major_type, 26)];
83        let mut value: Vec<u8> = unsafe {
84            transmute::<u32, [u8; 4]>((value as u32).to_be()).to_vec()
85        };
86        header.append(&mut value);
87        header
88    }
89
90    fn encode_u64(&self, value: u64, major_type: u8) -> Vec<u8> {
91        let mut header = vec![bytes::concat(major_type, 27)];
92        let mut value: Vec<u8> = unsafe {
93            transmute::<u64, [u8; 8]>((value).to_be()).to_vec()
94        };
95        header.append(&mut value);
96        header
97    }
98}
99
100impl<'a> Serializer for VecSerializer<'a> {
101    fn serialize_unsigned(&mut self, n: u64, major_type: u8) {
102        let bytes = self.encode_unsigned(n, major_type).to_vec();
103        self.writer.write_bytes(bytes);
104    }
105
106    fn serialize_bytes(&mut self, bytes: Vec<u8>) {
107        self.serialize_unsigned(bytes.len() as u64, 0b010);
108        self.writer.write_bytes(bytes);
109    }
110
111    fn serialize_string(&mut self, string: &String) {
112        self.serialize_unsigned(string.len() as u64, 0b011);
113        self.writer.write_bytes(string.as_bytes().to_vec());
114    }
115
116    fn serialize_seq(&mut self, len: usize) {
117        self.serialize_unsigned(len as u64, 0b100);
118    }
119
120    fn serialize_map(&mut self, len: usize) {
121        self.serialize_unsigned(len as u64, 0b101);
122    }
123
124    fn serialize_simple(&mut self, value: u64) {
125        self.serialize_unsigned(value, 0b111);
126    }
127}
128
129#[test]
130fn serialize_map() {
131    let mut test_map = BTreeMap::new();
132    test_map.insert("key1".into(), Value::String("value1".into()));
133    test_map.insert("key2".into(), Value::String("value2".into()));
134    let value: Value = Value::Map(test_map);
135    assert_eq!(vec![0xa2, 0x64, 0x6b, 0x65, 0x79, 0x31, 0x66, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x31, 0x64, 0x6b, 0x65, 0x79, 0x32, 0x66, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x32], to_bytes(value));
136}
137
138#[test]
139fn serialize_array() {
140    let value = Value::Array(vec![Value::Int(1), Value::Int(2), Value::Int(3)]);
141    assert_eq!(vec![131, 1, 2, 3], to_bytes(value));
142}
143
144#[test]
145fn serialize_string() {
146    let value = Value::String("test".into());
147    assert_eq!(vec![0x64, 0x74, 0x65, 0x73, 0x74], to_bytes(value));
148}
149
150#[test]
151fn serialize_u16() {
152    let value = Value::Int(0x100);
153    assert_eq!(vec![25, 1, 0], to_bytes(value));
154}
155
156#[test]
157fn serialize_u32() {
158    let value = Value::Int(0x1000000);
159    assert_eq!(vec![26, 1, 0, 0, 0], to_bytes(value));
160}
161
162#[test]
163fn serialize_u64() {
164    let value = Value::Int(0x100000000000000 as u64);
165    assert_eq!(vec![27, 1, 0, 0, 0, 0, 0, 0, 0], to_bytes(value));
166}
167
168#[test]
169fn serialize_u8() {
170    let value = Value::Int(2);
171    assert_eq!(vec![2], to_bytes(value));
172}
173
174#[test]
175fn serialize_u8_2() {
176    let value = Value::Int(42);
177    assert_eq!(vec![24, 42], to_bytes(value));
178}
179
180#[test]
181fn serialize_null() {
182    let value = Value::Null;
183    assert_eq!(vec![246], to_bytes(value));
184}
cbor_no_std/ser.rs

cbor_no_std/
ser.rs
