fexbluffers 0.1.2

Allocation optimized FlexBuffer implementation (Rust).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use crate::Buffer;
use crate::reader::Reader;
use crate::{BitWidth::{W8, W16, W32, W64}, FlexBufferType::{Null, Int, IndirectInt, UInt, IndirectUInt, Float, IndirectFloat, Bool, Key, String, Map, Vector, VectorInt, VectorUInt, VectorFloat, VectorKey, VectorBool, VectorInt2, VectorUInt2, VectorFloat2, VectorInt3, VectorUInt3, VectorFloat3, VectorInt4, VectorUInt4, VectorFloat4, Blob}};
use serde::ser;
use serde::ser::{SerializeMap, SerializeSeq};

impl<B: Buffer> ser::Serialize for &Reader<B> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: ser::Serializer,
    {
        match (self.flexbuffer_type(), self.bitwidth()) {
            (Null, _) => serializer.serialize_unit(),
            (Int | IndirectInt, W8) => serializer.serialize_i8(self.as_i8()),
            (Int | IndirectInt, W16) => serializer.serialize_i16(self.as_i16()),
            (Int | IndirectInt, W32) => serializer.serialize_i32(self.as_i32()),
            (Int | IndirectInt, W64) => serializer.serialize_i64(self.as_i64()),
            (UInt | IndirectUInt, W8) => serializer.serialize_u8(self.as_u8()),
            (UInt | IndirectUInt, W16) => serializer.serialize_u16(self.as_u16()),
            (UInt | IndirectUInt, W32) => serializer.serialize_u32(self.as_u32()),
            (UInt | IndirectUInt, W64) => serializer.serialize_u64(self.as_u64()),
            (Float | IndirectFloat, W32) => serializer.serialize_f32(self.as_f32()),
            (Float | IndirectFloat, _) => serializer.serialize_f64(self.as_f64()),
            (Bool, _) => serializer.serialize_bool(self.as_bool()),
            (Key | String, _) => serializer.serialize_str(&self.as_str()),
            (Map, _) => {
                let m = self.as_map();
                let mut map_serializer = serializer.serialize_map(Some(m.len()))?;
                for (k, v) in m.iter_keys().zip(m.iter_values()) {
                    map_serializer.serialize_key(&&k)?;
                    map_serializer.serialize_value(&&v)?;
                }
                map_serializer.end()
            }
            (Vector | VectorInt | VectorUInt | VectorFloat | VectorKey | VectorBool |
VectorInt2 | VectorUInt2 | VectorFloat2 | VectorInt3 | VectorUInt3 |
VectorFloat3 | VectorInt4 | VectorUInt4 | VectorFloat4, _) => {
                let v = self.as_vector();
                let mut seq_serializer = serializer.serialize_seq(Some(v.len()))?;
                for x in &v {
                    seq_serializer.serialize_element(&&x)?;
                }
                seq_serializer.end()
            }
            (Blob, _) => serializer.serialize_bytes(&self.as_blob().0),
        }
    }
}