use astrs_data::ipc::encode_payload;
use astrs_data::{AstrsMessage, RecordBatch};
use astrs_wire::{DataId, Metadata};
use crate::error::{OpError, OpResult};
#[derive(Debug, Clone, PartialEq)]
pub struct OpSend {
id: DataId,
metadata: Metadata,
payload: Vec<u8>,
}
impl OpSend {
#[must_use]
pub const fn id(&self) -> &DataId {
&self.id
}
#[must_use]
pub const fn metadata(&self) -> &Metadata {
&self.metadata
}
#[must_use]
pub fn payload(&self) -> &[u8] {
&self.payload
}
#[must_use]
pub fn into_parts(self) -> (DataId, Metadata, Vec<u8>) {
(self.id, self.metadata, self.payload)
}
}
#[derive(Debug, Default)]
pub struct OpOutput {
pending: Vec<OpSend>,
}
impl OpOutput {
#[must_use]
pub fn new() -> Self {
Self {
pending: Vec::new(),
}
}
pub fn send_bytes(&mut self, id: &str, metadata: Metadata, payload: Vec<u8>) -> OpResult<()> {
let id = DataId::new(id).map_err(|source| OpError::invalid_output_id(id, source))?;
self.pending.push(OpSend {
id,
metadata,
payload,
});
Ok(())
}
pub fn send_batch(
&mut self,
id: &str,
metadata: Metadata,
batch: &RecordBatch,
) -> OpResult<()> {
let bytes = encode_payload(batch)?.to_vec();
self.send_bytes(id, metadata, bytes)
}
pub fn send<M: AstrsMessage>(
&mut self,
id: &str,
metadata: Metadata,
message: &M,
) -> OpResult<()> {
let batch = message.to_record_batch()?;
self.send_batch(id, metadata, &batch)
}
pub fn drain(&mut self) -> Vec<OpSend> {
std::mem::take(&mut self.pending)
}
#[must_use]
pub fn len(&self) -> usize {
self.pending.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.pending.is_empty()
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
use astrs_data::prelude::*;
use astrs_time::HlcTimestamp;
#[derive(Debug, PartialEq)]
struct Ping {
tick: u8,
}
impl AstrsMessage for Ping {
const URN: &'static str = "std/core/v1/PingMsg";
fn data_type() -> DataType {
DataType::strukt([Field::required("tick", DataType::UInt8)])
}
fn to_record_batch(&self) -> astrs_data::Result<RecordBatch> {
let DataType::Struct(fields) = Self::data_type() else {
unreachable!()
};
let column = UInt8Array::from_values([self.tick]).into_array_ref();
let strukt = StructArray::try_new(fields, vec![column], None)?;
Ok(RecordBatch::from_payload(strukt.into_array_ref()))
}
fn from_record_batch(batch: &RecordBatch) -> astrs_data::Result<Self> {
let column =
batch
.payload_column()
.ok_or(astrs_data::DataError::ColumnCountMismatch {
fields: 1,
columns: 0,
})?;
let strukt = column.try_downcast::<StructArray>()?;
let tick = strukt.columns()[0]
.try_downcast::<UInt8Array>()?
.get(0)
.ok_or(astrs_data::DataError::RequiredFieldIsNull {
field: "tick".to_owned(),
row: 0,
})?;
Ok(Self { tick })
}
}
fn meta() -> Metadata {
Metadata::new(HlcTimestamp::EPOCH)
}
#[test]
fn new_output_is_empty() {
let out = OpOutput::new();
assert!(out.is_empty());
assert_eq!(out.len(), 0);
}
#[test]
fn send_bytes_buffers_and_drain_empties() {
let mut out = OpOutput::new();
out.send_bytes("frames", meta(), vec![1, 2, 3]).unwrap();
assert_eq!(out.len(), 1);
assert!(!out.is_empty());
let sends = out.drain();
assert_eq!(sends.len(), 1);
assert_eq!(sends[0].id().as_str(), "frames");
assert_eq!(sends[0].payload(), &[1, 2, 3]);
assert!(out.is_empty(), "drain empties the buffer");
}
#[test]
fn send_bytes_rejects_an_invalid_id() {
let mut out = OpOutput::new();
let err = out.send_bytes("bad id", meta(), vec![]).unwrap_err();
assert!(matches!(err, OpError::InvalidOutputId { .. }));
assert!(out.is_empty());
}
#[test]
fn send_batch_encodes_a_record_batch() {
let mut out = OpOutput::new();
let batch = Ping { tick: 7 }.to_record_batch().unwrap();
out.send_batch("tick", meta(), &batch).unwrap();
let sends = out.drain();
assert_eq!(sends.len(), 1);
let decoded = astrs_data::ipc::decode_payload(sends[0].payload()).unwrap();
assert_eq!(Ping::from_record_batch(&decoded).unwrap(), Ping { tick: 7 });
}
#[test]
fn send_encodes_a_typed_message_round_trippably() {
let mut out = OpOutput::new();
out.send("tick", meta(), &Ping { tick: 42 }).unwrap();
let sends = out.drain();
let decoded = astrs_data::ipc::decode_payload(sends[0].payload()).unwrap();
assert_eq!(
Ping::from_record_batch(&decoded).unwrap(),
Ping { tick: 42 }
);
assert_eq!(sends[0].metadata(), &meta());
}
#[test]
fn multiple_sends_accumulate_in_order() {
let mut out = OpOutput::new();
out.send_bytes("a", meta(), vec![1]).unwrap();
out.send_bytes("b", meta(), vec![2]).unwrap();
out.send_bytes("c", meta(), vec![3]).unwrap();
let sends = out.drain();
let ids: Vec<&str> = sends.iter().map(|s| s.id().as_str()).collect();
assert_eq!(ids, ["a", "b", "c"]);
}
#[test]
fn into_parts_returns_the_three_fields() {
let mut out = OpOutput::new();
out.send_bytes("x", meta(), vec![7]).unwrap();
let (id, metadata, payload) = out.drain().remove(0).into_parts();
assert_eq!(id.as_str(), "x");
assert_eq!(metadata, meta());
assert_eq!(payload, vec![7]);
}
}