use core::marker::PhantomData;
use super::{decode, encode, size, MessageTable};
use crate::encode_sink::{write_to_new_vec, PreSized};
use crate::encoding::encode_varint;
use crate::{DecodeContext, DecodeError, EncodeSink, Message, SizeCache};
pub(super) struct DynVt {
size: unsafe fn(*const u8, &mut SizeCache) -> u32,
write: unsafe fn(*const u8, &mut SizeCache, &mut PreSized<'_>),
merge: unsafe fn(*mut u8, &mut &[u8], DecodeContext<'_>) -> Result<(), DecodeError>,
}
unsafe fn size_thunk<T: Message>(msg: *const u8, cache: &mut SizeCache) -> u32 {
unsafe { (*msg.cast::<T>()).compute_size(cache) }
}
unsafe fn write_thunk<T: Message>(msg: *const u8, cache: &mut SizeCache, buf: &mut PreSized<'_>) {
unsafe { (*msg.cast::<T>()).write_to(cache, buf) }
}
unsafe fn merge_thunk<T: Message>(
msg: *mut u8,
buf: &mut &[u8],
ctx: DecodeContext<'_>,
) -> Result<(), DecodeError> {
unsafe { (*msg.cast::<T>()).merge_length_delimited(buf, ctx) }
}
struct Thunks<T>(PhantomData<fn() -> T>);
impl<T: Message> Thunks<T> {
const VT: &'static DynVt = &DynVt {
size: size_thunk::<T>,
write: write_thunk::<T>,
merge: merge_thunk::<T>,
};
}
#[derive(Clone, Copy)]
pub(super) enum Child {
Table(&'static MessageTable),
Dyn(&'static DynVt),
}
impl Child {
pub(super) const fn of<T: Message>() -> Self {
Self::Dyn(Thunks::<T>::VT)
}
#[inline]
pub(super) unsafe fn compute_size(self, base: *const u8, cache: &mut SizeCache) -> u32 {
unsafe {
match self {
Self::Table(table) => size::compute_size(table, base, cache),
Self::Dyn(vt) => (vt.size)(base, cache),
}
}
}
#[inline]
pub(super) unsafe fn write_to<K: EncodeSink>(
self,
base: *const u8,
len: u32,
cache: &mut SizeCache,
buf: &mut K,
) {
unsafe {
match self {
Self::Table(table) => encode::write_message(table, base, cache, buf),
Self::Dyn(vt) => write_dyn(vt, base, len, cache, buf),
}
}
}
#[inline]
pub(super) unsafe fn merge_sub(
self,
base: *mut u8,
buf: &mut &[u8],
ctx: DecodeContext<'_>,
) -> Result<(), DecodeError> {
unsafe {
match self {
Self::Table(table) => decode::merge_sub(table, base, buf, ctx),
Self::Dyn(vt) => (vt.merge)(base, buf, ctx),
}
}
}
}
#[inline(never)]
unsafe fn write_dyn<K: EncodeSink>(
vt: &DynVt,
base: *const u8,
len: u32,
cache: &mut SizeCache,
buf: &mut K,
) {
let mut through_cursor = |cursor: &mut PreSized<'_>| {
unsafe { (vt.write)(base, &mut *cache, cursor) }
};
if buf.__with_pre_sized(&mut through_cursor) {
return;
}
let len = len as usize;
let scratch = write_to_new_vec(len, |cursor| {
unsafe { (vt.write)(base, &mut *cache, cursor) }
});
crate::message::debug_assert_two_pass(scratch.len(), len);
buf.put_slice(&scratch);
}
#[inline]
pub(super) unsafe fn write_field_value<K: EncodeSink>(
child: Child,
base: *const u8,
cache: &mut SizeCache,
buf: &mut K,
) {
let len = cache.consume_next();
encode_varint(u64::from(len), buf);
unsafe { child.write_to(base, len, cache, buf) };
}