use crate::HostEnv;
use std::any::{Any, TypeId};
pub const MAX_REBIND_KEY: usize = 4096;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum UserdataPolicy {
Portable,
Refuse,
Rebind,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct RebindError(pub &'static str);
impl std::fmt::Display for RebindError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.0)
}
}
impl std::error::Error for RebindError {}
pub trait RebindUserdata: HostUserdata + Sized {
fn key(&self) -> Vec<u8>;
fn rebind(key: &[u8], env: &HostEnv) -> Result<Self, RebindError>;
}
pub(crate) const MAX_USERDATA_BYTES: usize = crate::heap::STRING_CEILING;
pub(crate) const MAX_USER_VALUES: usize = u16::MAX as usize - 1;
pub trait HostUserdata: 'static {
const SYMBOL: &'static str;
fn logical_size(&self) -> u64;
}
pub trait PortableUserdata: HostUserdata + Sized {
fn encode(&self) -> Vec<u8>;
fn decode(bytes: &[u8]) -> Option<Self>;
}
#[derive(Clone, Copy)]
pub(crate) struct HostType {
pub(crate) symbol: &'static str,
pub(crate) type_id: TypeId,
pub(crate) size: fn(&dyn Any) -> Option<u64>,
pub(crate) policy: Policy,
}
#[derive(Clone, Copy)]
pub(crate) enum Policy {
Refuse,
Portable(Codec),
Rebind {
key: fn(&dyn Any) -> Option<Vec<u8>>,
rebind: fn(&[u8], &HostEnv) -> Result<Decoded, RebindError>,
},
}
impl Policy {
pub(crate) fn kind(self) -> UserdataPolicy {
match self {
Self::Refuse => UserdataPolicy::Refuse,
Self::Portable(_) => UserdataPolicy::Portable,
Self::Rebind { .. } => UserdataPolicy::Rebind,
}
}
}
pub(crate) type Decoded = (Box<dyn Any>, u64);
#[derive(Clone, Copy)]
pub(crate) struct Codec {
pub(crate) encode: fn(&dyn Any) -> Option<Vec<u8>>,
pub(crate) decode: fn(&[u8]) -> Option<Decoded>,
}
impl HostType {
pub(crate) fn of<T: HostUserdata>() -> Self {
Self {
symbol: T::SYMBOL,
type_id: TypeId::of::<T>(),
size: size_as::<T>,
policy: Policy::Refuse,
}
}
pub(crate) fn portable<T: PortableUserdata>() -> Self {
Self {
policy: Policy::Portable(Codec {
encode: encode_as::<T>,
decode: decode_as::<T>,
}),
..Self::of::<T>()
}
}
pub(crate) fn rebind<T: RebindUserdata>() -> Self {
Self {
policy: Policy::Rebind {
key: key_as::<T>,
rebind: rebind_as::<T>,
},
..Self::of::<T>()
}
}
}
fn key_as<T: RebindUserdata>(value: &dyn Any) -> Option<Vec<u8>> {
value.downcast_ref::<T>().map(T::key)
}
fn rebind_as<T: RebindUserdata>(key: &[u8], env: &HostEnv) -> Result<Decoded, RebindError> {
let value = T::rebind(key, env)?;
let size = value.logical_size();
Ok((Box::new(value), size))
}
fn size_as<T: HostUserdata>(value: &dyn Any) -> Option<u64> {
value.downcast_ref::<T>().map(T::logical_size)
}
fn encode_as<T: PortableUserdata>(value: &dyn Any) -> Option<Vec<u8>> {
value.downcast_ref::<T>().map(T::encode)
}
fn decode_as<T: PortableUserdata>(bytes: &[u8]) -> Option<Decoded> {
let value = T::decode(bytes)?;
let size = value.logical_size();
Some((Box::new(value), size))
}
pub(crate) enum Payload {
File(Box<crate::iolib::FileState>),
Bytes(Box<[u8]>),
Host {
symbol: &'static str,
value: Box<dyn Any>,
},
}
impl Payload {
pub(crate) fn bytes(&self) -> Option<&[u8]> {
match self {
Payload::Bytes(bytes) => Some(bytes),
Payload::Host { .. } | Payload::File(_) => None,
}
}
pub(crate) fn bytes_mut(&mut self) -> Option<&mut [u8]> {
match self {
Payload::Bytes(bytes) => Some(bytes),
Payload::Host { .. } | Payload::File(_) => None,
}
}
pub(crate) fn host<T: 'static>(&self) -> Option<&T> {
match self {
Payload::Host { value, .. } => value.downcast_ref::<T>(),
Payload::Bytes(_) | Payload::File(_) => None,
}
}
pub(crate) fn host_mut<T: 'static>(&mut self) -> Option<&mut T> {
match self {
Payload::Host { value, .. } => value.downcast_mut::<T>(),
Payload::Bytes(_) | Payload::File(_) => None,
}
}
pub(crate) fn symbol(&self) -> Option<&'static str> {
match self {
Payload::Host { symbol, .. } => Some(symbol),
Payload::Bytes(_) | Payload::File(_) => None,
}
}
}
impl std::fmt::Debug for Payload {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Payload::File(file) => write!(f, "File({})", file.id.0),
Payload::Bytes(bytes) => write!(f, "Bytes({})", bytes.len()),
Payload::Host { symbol, .. } => write!(f, "Host({symbol})"),
}
}
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub struct HostLightKey(pub u64);
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub struct LightUserdata {
pub(crate) domain: crate::value::LightDomain,
pub(crate) bits: u64,
}
impl LightUserdata {
pub fn host(key: HostLightKey) -> Self {
Self {
domain: crate::value::LightDomain::Host,
bits: key.0,
}
}
pub fn host_key(&self) -> Option<HostLightKey> {
(self.domain == crate::value::LightDomain::Host).then_some(HostLightKey(self.bits))
}
}