shrike 0.1.0

AT Protocol library for 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
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

// Code generated by lexgen. DO NOT EDIT.

pub mod app;
pub mod chat;
pub mod com;
pub mod tools;

/// A CID link for use in AT Protocol objects.
#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
pub struct CidLink {
    #[serde(rename = "$link")]
    pub link: String,
}

impl CidLink {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        let cid = self
            .link
            .parse::<crate::cbor::Cid>()
            .map_err(|e| crate::cbor::CborError::InvalidCbor(format!("invalid CID: {e}")))?;
        crate::cbor::Encoder::new(&mut *buf).encode_cid(&cid)?;
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        if let crate::cbor::Value::Cid(c) = val {
            Ok(CidLink {
                link: c.to_string(),
            })
        } else {
            Err(crate::cbor::CborError::InvalidCbor(
                "expected CID for CidLink".into(),
            ))
        }
    }
}

/// A blob reference for use in AT Protocol objects.
#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
pub struct Blob {
    #[serde(rename = "$type")]
    #[serde(default)]
    pub r#type: String,
    #[serde(default)]
    pub r#ref: Option<CidLink>,
    #[serde(rename = "mimeType")]
    #[serde(default)]
    pub mime_type: String,
    #[serde(default)]
    pub size: i64,
}

impl Blob {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        // CBOR key order (by encoded length then lex):
        // "ref" (3) < "size" (4) < "$type" (5) < "mimeType" (8)
        let mut count = 3u64; // $type, mimeType, size are always present
        if self.r#ref.is_some() {
            count += 1;
        }
        crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
        if let Some(ref cid_link) = self.r#ref {
            crate::cbor::Encoder::new(&mut *buf).encode_text("ref")?;
            cid_link.encode_cbor(buf)?;
        }
        crate::cbor::Encoder::new(&mut *buf).encode_text("size")?;
        crate::cbor::Encoder::new(&mut *buf).encode_i64(self.size)?;
        crate::cbor::Encoder::new(&mut *buf).encode_text("$type")?;
        crate::cbor::Encoder::new(&mut *buf).encode_text(&self.r#type)?;
        crate::cbor::Encoder::new(&mut *buf).encode_text("mimeType")?;
        crate::cbor::Encoder::new(&mut *buf).encode_text(&self.mime_type)?;
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => {
                return Err(crate::cbor::CborError::InvalidCbor(
                    "expected map for Blob".into(),
                ));
            }
        };
        let mut blob = Blob::default();
        for (key, value) in entries {
            match key {
                "$type" => {
                    if let crate::cbor::Value::Text(s) = value {
                        blob.r#type = s.to_string();
                    }
                }
                "ref" => {
                    if !matches!(value, crate::cbor::Value::Null) {
                        let raw = crate::cbor::encode_value(&value)?;
                        let mut dec = crate::cbor::Decoder::new(&raw);
                        blob.r#ref = Some(CidLink::decode_cbor(&mut dec)?);
                    }
                }
                "mimeType" => {
                    if let crate::cbor::Value::Text(s) = value {
                        blob.mime_type = s.to_string();
                    }
                }
                "size" => match value {
                    crate::cbor::Value::Unsigned(n) => blob.size = n as i64,
                    crate::cbor::Value::Signed(n) => blob.size = n,
                    _ => {}
                },
                _ => {}
            }
        }
        Ok(blob)
    }
}

/// An unknown/unrecognized union variant preserved for round-tripping.
#[derive(Debug, Clone)]
pub struct UnknownUnionVariant {
    pub r#type: String,
    pub json: Option<serde_json::Value>,
    pub cbor: Option<Vec<u8>>,
}