use std::any::{Any, TypeId};
use std::borrow::Borrow;
use std::collections::BTreeMap;
use std::fmt;
use std::sync::{Arc, Mutex, MutexGuard, RwLock};
use rustorb_cdr::ValueHeader;
use super::{IdlType, Sys};
use crate::{InStream, OutStream, TypeCode};
#[derive(Debug)]
pub struct ValueInfo {
pub id: &'static str,
pub sent_ids: &'static [&'static str],
pub ancestors: &'static [&'static str],
pub custom: bool,
pub make: fn() -> ValueHandle,
pub type_code: fn() -> TypeCode,
}
pub trait ValueState: Send + 'static {
fn info(&self) -> &'static ValueInfo;
fn write_state(&self, out: &mut OutStream<'_>) -> Sys<()>;
fn read_state(&mut self, input: &mut InStream<'_>) -> Sys<()>;
fn view(&self, ty: TypeId) -> Option<&dyn Any>;
fn view_mut(&mut self, ty: TypeId) -> Option<&mut dyn Any>;
}
struct ValueObj<S: ?Sized> {
info: &'static ValueInfo,
state: Mutex<S>,
}
#[derive(Clone)]
pub struct ValueHandle(Arc<ValueObj<dyn ValueState>>);
impl fmt::Debug for ValueHandle {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "ValueHandle({} @ {:#x})", self.0.info.id, self.key())
}
}
impl ValueHandle {
pub fn new<S: ValueState>(state: S) -> ValueHandle {
let info = state.info();
let obj: Arc<ValueObj<dyn ValueState>> = Arc::new(ValueObj {
info,
state: Mutex::new(state),
});
ValueHandle(obj)
}
pub fn info(&self) -> &'static ValueInfo {
self.0.info
}
pub fn is_a(&self, id: &str) -> bool {
self.0.info.ancestors.contains(&id)
}
pub fn ptr_eq(&self, other: &ValueHandle) -> bool {
Arc::ptr_eq(&self.0, &other.0)
}
pub fn key(&self) -> u64 {
Arc::as_ptr(&self.0) as *const () as usize as u64
}
fn lock(&self) -> MutexGuard<'_, dyn ValueState> {
self.0.state.lock().unwrap_or_else(|e| e.into_inner())
}
pub fn with<S: 'static, R>(&self, f: impl FnOnce(&S) -> R) -> R {
let guard = self.lock();
let state = guard
.view(TypeId::of::<S>())
.and_then(|s| s.downcast_ref::<S>())
.expect("the state of a base type");
f(state)
}
pub fn with_mut<S: 'static, R>(&self, f: impl FnOnce(&mut S) -> R) -> R {
let mut guard = self.lock();
let state = guard
.view_mut(TypeId::of::<S>())
.and_then(|s| s.downcast_mut::<S>())
.expect("the state of a base type");
f(state)
}
pub fn write(v: Option<&ValueHandle>, out: &mut OutStream<'_>) -> Sys<()> {
let Some(v) = v else {
out.write_null_value();
return Ok(());
};
let ids = v.0.info.sent_ids;
if !out.begin_value(v.key(), ids, ids.len() > 1 || v.0.info.custom)? {
return Ok(());
}
v.lock().write_state(out)?;
out.end_value()?;
Ok(())
}
pub fn read(
input: &mut InStream<'_>,
expected: &'static ValueInfo,
) -> Sys<Option<ValueHandle>> {
let e = input.marshal_error();
let header = input.read_value_header().map_err(|_| e.clone())?;
let (slot, ids) = match header {
ValueHeader::Null => return Ok(None),
ValueHeader::Indirection(slot) => {
let v = input
.typed_values
.get(slot)
.and_then(|v| v.as_ref())
.and_then(|v| v.downcast_ref::<ValueHandle>())
.filter(|v| v.is_a(expected.id))
.ok_or(e)?;
return Ok(Some(v.clone()));
}
ValueHeader::Value { slot, ids, .. } => (slot, ids),
};
let info = if ids.is_empty() {
expected
} else {
ids.iter()
.find_map(|id| {
if id == expected.id {
Some(expected)
} else {
lookup(id).filter(|i| i.ancestors.contains(&expected.id))
}
})
.ok_or_else(|| e.clone())?
};
let v = (info.make)();
set_slot(input, slot, Box::new(v.clone()));
v.lock().read_state(input)?;
input.end_value().map_err(|_| e)?;
Ok(Some(v))
}
}
fn set_slot(input: &mut InStream<'_>, slot: usize, v: Box<dyn Any>) {
if input.typed_values.len() <= slot {
input.typed_values.resize_with(slot + 1, || None);
}
input.typed_values[slot] = Some(v);
}
static VALUES: RwLock<BTreeMap<&'static str, &'static ValueInfo>> = RwLock::new(BTreeMap::new());
pub fn register_value(info: &'static ValueInfo) {
VALUES
.write()
.unwrap_or_else(|e| e.into_inner())
.insert(info.id, info);
crate::register_value_type(&(info.type_code)());
if info.custom {
crate::register_custom_reader(
info.id,
Arc::new(move |r, input| custom_reader(info, r, input)),
);
}
}
fn custom_reader(
info: &'static ValueInfo,
r: &crate::ValueRef,
input: &mut InStream<'_>,
) -> Sys<()> {
let v = (info.make)();
let outer = input.custom_items.replace(Vec::new());
let result = v.lock().read_state(input);
let items = std::mem::replace(&mut input.custom_items, outer).unwrap_or_default();
result?;
r.set_members(items);
Ok(())
}
fn lookup(id: &str) -> Option<&'static ValueInfo> {
VALUES
.read()
.unwrap_or_else(|e| e.into_inner())
.get(id)
.copied()
}
pub fn write_box<T: IdlType>(
v: Option<&Arc<T::Rust>>,
id: &str,
out: &mut OutStream<'_>,
) -> Sys<()> {
let Some(v) = v else {
out.write_null_value();
return Ok(());
};
let key = Arc::as_ptr(v) as *const () as usize as u64;
if !out.begin_value(key, &[id], false)? {
return Ok(());
}
T::write(v.as_ref().borrow(), out)?;
out.end_value()?;
Ok(())
}
pub fn read_box<T: IdlType>(input: &mut InStream<'_>, id: &str) -> Sys<Option<Arc<T::Rust>>> {
let e = input.marshal_error();
let header = input.read_value_header().map_err(|_| e.clone())?;
match header {
ValueHeader::Null => Ok(None),
ValueHeader::Indirection(slot) => input
.typed_values
.get(slot)
.and_then(|v| v.as_ref())
.and_then(|v| v.downcast_ref::<Arc<T::Rust>>())
.cloned()
.map(Some)
.ok_or(e),
ValueHeader::Value { slot, ids, .. } => {
if ids.first().is_some_and(|i| i != id) {
return Err(e);
}
let v = Arc::new(T::read(input)?);
set_slot(input, slot, Box::new(v.clone()));
input.end_value().map_err(|_| e)?;
Ok(Some(v))
}
}
}
pub trait CustomMarshal {
fn marshal(&self, os: &mut DataOutputStream<'_, '_>) -> Sys<()>;
fn unmarshal(&mut self, is: &mut DataInputStream<'_, '_>) -> Sys<()>;
}
#[derive(Debug)]
pub struct DataOutputStream<'s, 'a> {
out: &'s mut OutStream<'a>,
}
impl<'s, 'a> DataOutputStream<'s, 'a> {
pub fn new(out: &'s mut OutStream<'a>) -> Self {
DataOutputStream { out }
}
pub fn write<T: IdlType>(&mut self, v: &T::Borrowed) -> Sys<()> {
T::write(v, self.out)
}
pub fn write_array<T: IdlType>(&mut self, items: &[T::Rust]) -> Sys<()> {
T::write_items(items, self.out)
}
pub fn stream(&mut self) -> &mut OutStream<'a> {
self.out
}
}
#[derive(Debug)]
pub struct DataInputStream<'s, 'a> {
input: &'s mut InStream<'a>,
}
impl<'s, 'a> DataInputStream<'s, 'a> {
pub fn new(input: &'s mut InStream<'a>) -> Self {
DataInputStream { input }
}
pub fn read<T: IdlType>(&mut self) -> Sys<T::Rust> {
if self.input.custom_items.is_none() {
return T::read(self.input);
}
let e = self.input.marshal_error();
let tc = T::type_code();
let value = self.input.read_value(&tc)?;
let item = crate::Any::new(tc, value);
let v = item.extract::<T>().ok_or_else(|| e.clone())?;
self.input
.custom_items
.as_mut()
.ok_or(e)?
.push(crate::Value::Any(Box::new(item)));
Ok(v)
}
pub fn read_array<T: IdlType>(&mut self, len: usize) -> Sys<Vec<T::Rust>> {
let e = self.input.marshal_error();
if len.saturating_mul(T::MIN_SIZE) > self.input.remaining() {
return Err(e);
}
if self.input.custom_items.is_none() {
return T::read_items(len, self.input);
}
(0..len).map(|_| self.read::<T>()).collect()
}
pub fn stream(&mut self) -> &mut InStream<'a> {
self.input
}
}