use core::fmt;
use core::ptr::NonNull;
use alloc::boxed::Box;
use crate::{Arena, DecodeError};
pub unsafe trait ArenaDecode {
type Message<'a>: 'a;
fn decode_borrowed<'a>(
input: &'a [u8],
arena: &'a Arena<'a>,
) -> Result<&'a Self::Message<'a>, DecodeError>;
}
pub struct Owned<D: ArenaDecode> {
root: NonNull<D::Message<'static>>,
#[allow(dead_code)]
arena: Arena<'static>,
input: NonNull<[u8]>,
}
unsafe impl<D: ArenaDecode> Send for Owned<D> where D::Message<'static>: Send {}
unsafe impl<D: ArenaDecode> Sync for Owned<D> where D::Message<'static>: Sync {}
impl<D: ArenaDecode> Drop for Owned<D> {
fn drop(&mut self) {
drop(unsafe { Box::from_raw(self.input.as_ptr()) });
}
}
impl<D: ArenaDecode> Owned<D> {
#[must_use]
pub fn get(&self) -> &D::Message<'_> {
unsafe { self.root.cast::<D::Message<'_>>().as_ref() }
}
}
impl<D: ArenaDecode> fmt::Debug for Owned<D>
where
for<'a> D::Message<'a>: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(self.get(), f)
}
}
pub fn decode_owned<D>(input: impl Into<Box<[u8]>>) -> Result<Owned<D>, DecodeError>
where
D: ArenaDecode,
{
let input: NonNull<[u8]> = NonNull::from(Box::leak(input.into()));
let arena = Arena::new();
let decoded = D::decode_borrowed(unsafe { input.as_ref() }, &arena);
let message = match decoded {
Ok(message) => message,
Err(e) => {
drop(unsafe { Box::from_raw(input.as_ptr()) });
return Err(e);
}
};
let root: NonNull<D::Message<'static>> = NonNull::from(message).cast();
Ok(Owned { root, arena, input })
}
#[cfg(test)]
mod tests {
use super::*;
#[derive(Debug)]
struct Mock<'a> {
bytes: &'a [u8],
len: &'a u32,
}
struct MockDecoder;
unsafe impl ArenaDecode for MockDecoder {
type Message<'a> = Mock<'a>;
fn decode_borrowed<'a>(
input: &'a [u8],
arena: &'a Arena<'a>,
) -> Result<&'a Mock<'a>, DecodeError> {
let len: &u32 =
arena.emplace(|slot| Ok::<_, DecodeError>(slot.write(input.len() as u32)))?;
let node = arena
.emplace(|slot| Ok::<_, DecodeError>(slot.write(Mock { bytes: input, len })))?;
Ok(node)
}
}
#[test]
fn owns_input_and_arena_across_moves() {
let owned: Owned<MockDecoder> = decode_owned(&b"hello world"[..]).unwrap();
let mut v = alloc::vec::Vec::new();
v.push(owned);
let owned = v.pop().unwrap();
assert_eq!(owned.get().bytes, b"hello world"); assert_eq!(*owned.get().len, 11); }
#[test]
fn debug_prints_the_message() {
let owned: Owned<MockDecoder> = decode_owned(&b"hi"[..]).unwrap();
assert_eq!(
alloc::format!("{owned:?}"),
"Mock { bytes: [104, 105], len: 2 }"
);
}
#[test]
fn moves_to_another_thread() {
let owned: Owned<MockDecoder> = decode_owned(&b"moved"[..]).unwrap();
let len = std::thread::spawn(move || *owned.get().len).join().unwrap();
assert_eq!(len, 5);
}
#[test]
fn threads_share_it_through_an_arc() {
let owned: Owned<MockDecoder> = decode_owned(&b"shared"[..]).unwrap();
let shared = std::sync::Arc::new(owned);
let threads: alloc::vec::Vec<_> = (0..4)
.map(|_| {
let shared = std::sync::Arc::clone(&shared);
std::thread::spawn(move || {
assert_eq!(shared.get().bytes, b"shared");
*shared.get().len
})
})
.collect();
for thread in threads {
assert_eq!(thread.join().unwrap(), 6);
}
}
#[test]
fn drops_on_the_receiving_thread() {
let (send, receive) = std::sync::mpsc::channel::<Owned<MockDecoder>>();
let receiver = std::thread::spawn(move || {
let owned = receive.recv().unwrap();
assert_eq!(owned.get().bytes, b"sent");
});
send.send(decode_owned(&b"sent"[..]).unwrap()).unwrap();
receiver.join().unwrap();
}
#[test]
fn a_task_holding_an_arena_and_its_message_is_send() {
fn assert_send<T: Send>(_: T) {}
async fn later() {}
assert_send(async {
let arena = Arena::new();
let message = MockDecoder::decode_borrowed(b"task", &arena).unwrap();
later().await;
assert_eq!(*message.len, 4);
});
}
#[test]
fn accepts_owned_and_borrowed_input() {
let from_vec: Owned<MockDecoder> = decode_owned(alloc::vec![1u8, 2, 3]).unwrap();
assert_eq!(from_vec.get().bytes, &[1, 2, 3]);
let from_box: Owned<MockDecoder> =
decode_owned(alloc::vec![4u8, 5].into_boxed_slice()).unwrap();
assert_eq!(from_box.get().bytes, &[4, 5]);
}
}