astrs_operator_api/
output.rs1use astrs_data::ipc::encode_payload;
14use astrs_data::{AstrsMessage, RecordBatch};
15use astrs_wire::{DataId, Metadata};
16
17use crate::error::{OpError, OpResult};
18
19#[derive(Debug, Clone, PartialEq)]
21pub struct OpSend {
22 id: DataId,
23 metadata: Metadata,
24 payload: Vec<u8>,
25}
26
27impl OpSend {
28 #[must_use]
30 pub const fn id(&self) -> &DataId {
31 &self.id
32 }
33
34 #[must_use]
36 pub const fn metadata(&self) -> &Metadata {
37 &self.metadata
38 }
39
40 #[must_use]
42 pub fn payload(&self) -> &[u8] {
43 &self.payload
44 }
45
46 #[must_use]
48 pub fn into_parts(self) -> (DataId, Metadata, Vec<u8>) {
49 (self.id, self.metadata, self.payload)
50 }
51}
52
53#[derive(Debug, Default)]
97pub struct OpOutput {
98 pending: Vec<OpSend>,
99}
100
101impl OpOutput {
102 #[must_use]
104 pub fn new() -> Self {
105 Self {
106 pending: Vec::new(),
107 }
108 }
109
110 pub fn send_bytes(&mut self, id: &str, metadata: Metadata, payload: Vec<u8>) -> OpResult<()> {
121 let id = DataId::new(id).map_err(|source| OpError::invalid_output_id(id, source))?;
122 self.pending.push(OpSend {
123 id,
124 metadata,
125 payload,
126 });
127 Ok(())
128 }
129
130 pub fn send_batch(
138 &mut self,
139 id: &str,
140 metadata: Metadata,
141 batch: &RecordBatch,
142 ) -> OpResult<()> {
143 let bytes = encode_payload(batch)?.to_vec();
144 self.send_bytes(id, metadata, bytes)
145 }
146
147 pub fn send<M: AstrsMessage>(
160 &mut self,
161 id: &str,
162 metadata: Metadata,
163 message: &M,
164 ) -> OpResult<()> {
165 let batch = message.to_record_batch()?;
166 self.send_batch(id, metadata, &batch)
167 }
168
169 pub fn drain(&mut self) -> Vec<OpSend> {
171 std::mem::take(&mut self.pending)
172 }
173
174 #[must_use]
176 pub fn len(&self) -> usize {
177 self.pending.len()
178 }
179
180 #[must_use]
182 pub fn is_empty(&self) -> bool {
183 self.pending.is_empty()
184 }
185}
186
187#[cfg(test)]
188mod tests {
189 #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
190
191 use super::*;
192 use astrs_data::prelude::*;
193 use astrs_time::HlcTimestamp;
194
195 #[derive(Debug, PartialEq)]
196 struct Ping {
197 tick: u8,
198 }
199
200 impl AstrsMessage for Ping {
201 const URN: &'static str = "std/core/v1/PingMsg";
202
203 fn data_type() -> DataType {
204 DataType::strukt([Field::required("tick", DataType::UInt8)])
205 }
206
207 fn to_record_batch(&self) -> astrs_data::Result<RecordBatch> {
208 let DataType::Struct(fields) = Self::data_type() else {
209 unreachable!()
210 };
211 let column = UInt8Array::from_values([self.tick]).into_array_ref();
212 let strukt = StructArray::try_new(fields, vec![column], None)?;
213 Ok(RecordBatch::from_payload(strukt.into_array_ref()))
214 }
215
216 fn from_record_batch(batch: &RecordBatch) -> astrs_data::Result<Self> {
217 let column =
218 batch
219 .payload_column()
220 .ok_or(astrs_data::DataError::ColumnCountMismatch {
221 fields: 1,
222 columns: 0,
223 })?;
224 let strukt = column.try_downcast::<StructArray>()?;
225 let tick = strukt.columns()[0]
226 .try_downcast::<UInt8Array>()?
227 .get(0)
228 .ok_or(astrs_data::DataError::RequiredFieldIsNull {
229 field: "tick".to_owned(),
230 row: 0,
231 })?;
232 Ok(Self { tick })
233 }
234 }
235
236 fn meta() -> Metadata {
237 Metadata::new(HlcTimestamp::EPOCH)
238 }
239
240 #[test]
241 fn new_output_is_empty() {
242 let out = OpOutput::new();
243 assert!(out.is_empty());
244 assert_eq!(out.len(), 0);
245 }
246
247 #[test]
248 fn send_bytes_buffers_and_drain_empties() {
249 let mut out = OpOutput::new();
250 out.send_bytes("frames", meta(), vec![1, 2, 3]).unwrap();
251 assert_eq!(out.len(), 1);
252 assert!(!out.is_empty());
253
254 let sends = out.drain();
255 assert_eq!(sends.len(), 1);
256 assert_eq!(sends[0].id().as_str(), "frames");
257 assert_eq!(sends[0].payload(), &[1, 2, 3]);
258 assert!(out.is_empty(), "drain empties the buffer");
259 }
260
261 #[test]
262 fn send_bytes_rejects_an_invalid_id() {
263 let mut out = OpOutput::new();
264 let err = out.send_bytes("bad id", meta(), vec![]).unwrap_err();
265 assert!(matches!(err, OpError::InvalidOutputId { .. }));
266 assert!(out.is_empty());
267 }
268
269 #[test]
270 fn send_batch_encodes_a_record_batch() {
271 let mut out = OpOutput::new();
272 let batch = Ping { tick: 7 }.to_record_batch().unwrap();
273 out.send_batch("tick", meta(), &batch).unwrap();
274 let sends = out.drain();
275 assert_eq!(sends.len(), 1);
276
277 let decoded = astrs_data::ipc::decode_payload(sends[0].payload()).unwrap();
278 assert_eq!(Ping::from_record_batch(&decoded).unwrap(), Ping { tick: 7 });
279 }
280
281 #[test]
282 fn send_encodes_a_typed_message_round_trippably() {
283 let mut out = OpOutput::new();
284 out.send("tick", meta(), &Ping { tick: 42 }).unwrap();
285 let sends = out.drain();
286
287 let decoded = astrs_data::ipc::decode_payload(sends[0].payload()).unwrap();
288 assert_eq!(
289 Ping::from_record_batch(&decoded).unwrap(),
290 Ping { tick: 42 }
291 );
292 assert_eq!(sends[0].metadata(), &meta());
293 }
294
295 #[test]
296 fn multiple_sends_accumulate_in_order() {
297 let mut out = OpOutput::new();
298 out.send_bytes("a", meta(), vec![1]).unwrap();
299 out.send_bytes("b", meta(), vec![2]).unwrap();
300 out.send_bytes("c", meta(), vec![3]).unwrap();
301 let sends = out.drain();
302 let ids: Vec<&str> = sends.iter().map(|s| s.id().as_str()).collect();
303 assert_eq!(ids, ["a", "b", "c"]);
304 }
305
306 #[test]
307 fn into_parts_returns_the_three_fields() {
308 let mut out = OpOutput::new();
309 out.send_bytes("x", meta(), vec![7]).unwrap();
310 let (id, metadata, payload) = out.drain().remove(0).into_parts();
311 assert_eq!(id.as_str(), "x");
312 assert_eq!(metadata, meta());
313 assert_eq!(payload, vec![7]);
314 }
315}