re_log_encoding 0.31.3

Encode/decode and serialize/deserialize RRD streams
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

use crate::rrd::{CodecError, Decodable, Encodable, MessageHeader, MessageKind};

impl Encodable for re_protos::log_msg::v1alpha1::log_msg::Msg {
    /// Serializes the appropriate `MessageHeader` too!
    fn to_rrd_bytes(&self, out: &mut Vec<u8>) -> Result<u64, CodecError> {
        use re_protos::external::prost::Message as _;

        let before = out.len() as u64;

        match self {
            Self::SetStoreInfo(set_store_info) => {
                let header = MessageHeader {
                    kind: MessageKind::SetStoreInfo,
                    len: set_store_info.encoded_len() as u64,
                };
                header.to_rrd_bytes(out)?;
                set_store_info.encode(out)?;
            }

            Self::ArrowMsg(arrow_msg) => {
                let header = MessageHeader {
                    kind: MessageKind::ArrowMsg,
                    len: arrow_msg.encoded_len() as u64,
                };
                header.to_rrd_bytes(out)?;
                arrow_msg.encode(out)?;
            }

            Self::BlueprintActivationCommand(blueprint_activation_command) => {
                let header = MessageHeader {
                    kind: MessageKind::BlueprintActivationCommand,
                    len: blueprint_activation_command.encoded_len() as u64,
                };
                header.to_rrd_bytes(out)?;
                blueprint_activation_command.encode(out)?;
            }
        }

        Ok(out.len() as u64 - before)
    }
}

impl Encodable for re_protos::log_msg::v1alpha1::ArrowMsg {
    fn to_rrd_bytes(&self, out: &mut Vec<u8>) -> Result<u64, CodecError> {
        use re_protos::external::prost::Message as _;

        let before = out.len() as u64;
        self.encode(out)?;
        Ok(out.len() as u64 - before)
    }
}

impl Encodable for re_protos::log_msg::v1alpha1::RrdFooter {
    fn to_rrd_bytes(&self, out: &mut Vec<u8>) -> Result<u64, CodecError> {
        use re_protos::external::prost::Message as _;

        let before = out.len() as u64;
        self.encode(out)?;
        Ok(out.len() as u64 - before)
    }
}

impl Encodable for re_protos::log_msg::v1alpha1::RrdManifest {
    fn to_rrd_bytes(&self, out: &mut Vec<u8>) -> Result<u64, CodecError> {
        use re_protos::external::prost::Message as _;

        let before = out.len() as u64;
        self.encode(out)?;
        Ok(out.len() as u64 - before)
    }
}

// NOTE: This is implemented for `Option<_>` because, in the native RRD protocol, the message kind
// might be `MessageKind::End` (signifying end-of-stream), which has no representation in our Protobuf
// definitions. I.e. `MessageKind::End` yields `None`.
impl Decodable for Option<re_protos::log_msg::v1alpha1::log_msg::Msg> {
    /// This expects `data` to carry the `MessageHeader` bytes too!
    fn from_rrd_bytes(data: &[u8]) -> Result<Self, CodecError> {
        use re_protos::log_msg::v1alpha1::{ArrowMsg, BlueprintActivationCommand, SetStoreInfo};

        let header = MessageHeader::from_rrd_bytes(&data[..MessageHeader::ENCODED_SIZE_BYTES])?;

        let data = &data[MessageHeader::ENCODED_SIZE_BYTES..];
        let msg = match header.kind {
            MessageKind::SetStoreInfo => {
                Some(re_protos::log_msg::v1alpha1::log_msg::Msg::SetStoreInfo(
                    SetStoreInfo::from_rrd_bytes(data)?,
                ))
            }

            MessageKind::ArrowMsg => Some(re_protos::log_msg::v1alpha1::log_msg::Msg::ArrowMsg(
                ArrowMsg::from_rrd_bytes(data)?,
            )),

            MessageKind::BlueprintActivationCommand => Some(
                re_protos::log_msg::v1alpha1::log_msg::Msg::BlueprintActivationCommand(
                    BlueprintActivationCommand::from_rrd_bytes(data)?,
                ),
            ),

            MessageKind::End => None,
        };

        Ok(msg)
    }
}

impl Decodable for re_protos::log_msg::v1alpha1::SetStoreInfo {
    fn from_rrd_bytes(data: &[u8]) -> Result<Self, CodecError> {
        use re_protos::external::prost::Message as _;
        Ok(Self::decode(data)?)
    }
}

impl Decodable for re_protos::log_msg::v1alpha1::ArrowMsg {
    fn from_rrd_bytes(data: &[u8]) -> Result<Self, CodecError> {
        use re_protos::external::prost::Message as _;
        Ok(Self::decode(data)?)
    }
}

impl Decodable for re_protos::log_msg::v1alpha1::BlueprintActivationCommand {
    fn from_rrd_bytes(data: &[u8]) -> Result<Self, CodecError> {
        use re_protos::external::prost::Message as _;
        Ok(Self::decode(data)?)
    }
}

impl Decodable for re_protos::log_msg::v1alpha1::RrdFooter {
    fn from_rrd_bytes(data: &[u8]) -> Result<Self, CodecError> {
        use re_protos::external::prost::Message as _;
        Ok(Self::decode(data)?)
    }
}

impl Decodable for re_protos::log_msg::v1alpha1::RrdManifest {
    fn from_rrd_bytes(data: &[u8]) -> Result<Self, CodecError> {
        use re_protos::external::prost::Message as _;
        Ok(Self::decode(data)?)
    }
}