jacquard-common 0.10.0

Core AT Protocol types and utilities for Jacquard
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

//! Custom serde helpers for bytes::Bytes using serde_bytes

use alloc::string::String;
use alloc::vec::Vec;
use base64::{
    Engine,
    prelude::{BASE64_STANDARD, BASE64_STANDARD_NO_PAD, BASE64_URL_SAFE, BASE64_URL_SAFE_NO_PAD},
};
use bytes::Bytes;
use core::fmt;
use serde::{
    Deserializer, Serializer,
    de::{self, MapAccess, Visitor},
};

/// Serialize Bytes as a CBOR byte string
pub fn serialize<S>(bytes: &Option<Bytes>, serializer: S) -> Result<S::Ok, S::Error>
where
    S: Serializer,
{
    if let Some(bytes) = bytes {
        if serializer.is_human_readable() {
            // JSON: {"$bytes": "base64 string"}
            use serde::ser::SerializeMap;
            let mut map = serializer.serialize_map(Some(1))?;
            map.serialize_entry("$bytes", &BASE64_STANDARD.encode(bytes))?;
            map.end()
        } else {
            // CBOR: raw bytes
            serde_bytes::serialize(bytes.as_ref(), serializer)
        }
    } else {
        serializer.serialize_none()
    }
}

/// Deserialize Bytes from a CBOR byte string
pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Bytes>, D::Error>
where
    D: Deserializer<'de>,
{
    if deserializer.is_human_readable() {
        Ok(deserializer.deserialize_any(OptBytesVisitor)?)
    } else {
        let vec: Option<Vec<u8>> = serde_bytes::deserialize(deserializer)?;
        Ok(vec.map(Bytes::from))
    }
}

struct OptBytesVisitor;

impl<'de> Visitor<'de> for OptBytesVisitor {
    type Value = Option<Bytes>;

    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("a base64-encoded string")
    }

    fn visit_none<E>(self) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        Ok(None)
    }

    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
    where
        D: Deserializer<'de>,
    {
        let vec: Vec<u8> = serde_bytes::deserialize(deserializer)?;
        Ok(Some(Bytes::from(vec)))
    }

    fn visit_unit<E>(self) -> Result<Self::Value, E> {
        Ok(None)
    }

    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
    where
        A: MapAccess<'de>,
    {
        let mut bytes = None;

        while let Some(key) = map.next_key()? {
            match key {
                "$bytes" => {
                    if bytes.is_some() {
                        return Err(de::Error::duplicate_field("$bytes"));
                    }
                    let bytes_str: String = map.next_value()?;
                    // First one should just work. rest are insurance.
                    bytes = if let Ok(bytes) = BASE64_STANDARD.decode(&bytes_str) {
                        Some(Bytes::from_owner(bytes))
                    } else if let Ok(bytes) = BASE64_STANDARD_NO_PAD.decode(&bytes_str) {
                        Some(Bytes::from_owner(bytes))
                    } else if let Ok(bytes) = BASE64_URL_SAFE.decode(&bytes_str) {
                        Some(Bytes::from_owner(bytes))
                    } else if let Ok(bytes) = BASE64_URL_SAFE_NO_PAD.decode(&bytes_str) {
                        Some(Bytes::from_owner(bytes))
                    } else {
                        return Err(de::Error::custom("invalid base64 string"));
                    }
                }
                _ => {
                    return Err(de::Error::unknown_field(key, &["$bytes"]));
                }
            }
        }

        Ok(bytes)
    }
}