use super::decode::{merge_kind, take_len_delimited};
use super::encode::{put_tag, write_kind};
use super::shape::{DirectMsgVt, EnumVtOf};
use super::size::size_kind;
use super::{Aux, Entry, EnumShape, Kind, KindSlot, MessageTable, IMPLICIT, NO_UNKNOWN, REQUIRED};
use crate::encoding::{check_wire_type, encode_varint, varint_len, Tag, WireType};
use crate::map_codec::MapStorage;
use crate::{
types, DecodeContext, DecodeError, EncodeSink, SizeCache, UnknownField, UnknownFieldData,
UnknownFields,
};
pub struct MapVt {
entries: [Entry; 2],
value_aux: Option<Aux>,
footprint: usize,
for_each: unsafe fn(*const u8, &mut dyn FnMut(*const u8, *const u8)),
decode_entry: unsafe fn(*mut u8, &mut EntryReader<'_>) -> Result<bool, DecodeError>,
}
type EntryReader<'a> = dyn FnMut(*mut u8, *mut u8) -> Result<bool, DecodeError> + 'a;
#[cfg(all(test, feature = "zeroize"))]
mod cleanup_tests {
use super::*;
use alloc::collections::BTreeMap;
use core::sync::atomic::{AtomicUsize, Ordering};
static KEYS: AtomicUsize = AtomicUsize::new(0);
static VALUES: AtomicUsize = AtomicUsize::new(0);
#[derive(Default)]
struct Map(BTreeMap<u32, u64>);
impl MapStorage for Map {
type Key = u32;
type Value = u64;
fn storage_len(&self) -> usize {
self.0.len()
}
fn storage_clear(&mut self) {
self.0.clear();
}
fn storage_insert(&mut self, key: u32, value: u64) {
self.0.insert(key, value);
}
fn storage_erase_key(key: &mut u32) {
assert_eq!(*key, 7);
*key = 0;
KEYS.fetch_add(1, Ordering::SeqCst);
}
fn storage_erase_value(value: &mut u64) {
assert_eq!(*value, 37);
*value = 0;
VALUES.fetch_add(1, Ordering::SeqCst);
}
fn storage_iter<'a>(&'a self) -> impl Iterator<Item = (&'a u32, &'a u64)>
where
Self::Key: 'a,
Self::Value: 'a,
{
self.0.iter()
}
}
#[test]
fn manual_table_map_slots_follow_the_destination_cleanup_policy() {
KEYS.store(0, Ordering::SeqCst);
VALUES.store(0, Ordering::SeqCst);
let mut map = Map::default();
for outcome in 0..3 {
let mut read = |key: *mut u8, value: *mut u8| {
unsafe {
*key.cast::<u32>() = 7;
*value.cast::<u64>() = 37;
}
if outcome == 0 {
Err(DecodeError::UnexpectedEof)
} else {
Ok(outcome == 2)
}
};
let result =
unsafe { decode_entry_impl::<Map>((&mut map as *mut Map).cast(), &mut read) };
match outcome {
0 => assert_eq!(result, Err(DecodeError::UnexpectedEof)),
1 => assert_eq!(result, Ok(false)),
_ => assert_eq!(result, Ok(true)),
}
let erased = if outcome == 0 { 1 } else { 2 };
assert_eq!(KEYS.load(Ordering::SeqCst), erased);
assert_eq!(VALUES.load(Ordering::SeqCst), erased);
}
assert_eq!(map.0.get(&7), Some(&37));
}
}
unsafe fn for_each_impl<Mp: MapStorage>(map: *const u8, f: &mut dyn FnMut(*const u8, *const u8)) {
let map = unsafe { &*map.cast::<Mp>() };
for (key, value) in map.storage_iter() {
f(
(key as *const Mp::Key).cast(),
(value as *const Mp::Value).cast(),
);
}
}
unsafe fn decode_entry_impl<Mp: MapStorage>(
map: *mut u8,
f: &mut EntryReader<'_>,
) -> Result<bool, DecodeError>
where
Mp::Key: Default,
Mp::Value: Default,
{
let mut key = crate::erasing::Erasing::new(Mp::Key::default(), Mp::storage_erase_key);
let mut value = crate::erasing::Erasing::new(Mp::Value::default(), Mp::storage_erase_value);
let keep = f(
(&mut *key as *mut Mp::Key).cast(),
(&mut *value as *mut Mp::Value).cast(),
)?;
if keep {
unsafe { (*map.cast::<Mp>()).storage_insert(key.into_inner(), value.into_inner()) };
}
Ok(keep)
}
impl MapVt {
#[must_use]
pub const fn new<Mp, KK, VK>() -> Self
where
KK: KindSlot,
VK: KindSlot,
Mp: MapStorage<Key = KK::Slot, Value = VK::Slot>,
KK::Slot: Default,
VK::Slot: Default,
{
Self::build::<Mp>(KK::KIND, VK::KIND, None)
}
#[must_use]
pub const fn with_enum<Mp, KK, S>() -> Self
where
KK: KindSlot,
S: EnumShape,
Mp: MapStorage<Key = KK::Slot, Value = S::Slot>,
KK::Slot: Default,
S::Slot: Default,
{
assert!(
S::CARD == IMPLICIT,
"buffa table: a map's enum values must have an implicit shape"
);
Self::build::<Mp>(
KK::KIND,
Kind::EnumRequired,
Some(Aux::Enum(&EnumVtOf::<S>::VT)),
)
}
#[must_use]
pub const fn with_msg<Mp, KK, M>(vt: &'static DirectMsgVt<M>) -> Self
where
KK: KindSlot,
Mp: MapStorage<Key = KK::Slot, Value = M>,
KK::Slot: Default,
M: Default,
{
Self::build::<Mp>(KK::KIND, Kind::MsgSingular, Some(Aux::Msg(&vt.vt)))
}
const fn build<Mp: MapStorage>(key: Kind, value: Kind, value_aux: Option<Aux>) -> Self
where
Mp::Key: Default,
Mp::Value: Default,
{
assert!(
key.card() == REQUIRED,
"buffa table: a map key must be of a required scalar or string kind"
);
assert!(
value as u8 == Kind::MsgSingular as u8 || value.card() == REQUIRED,
"buffa table: a map value must be of a required kind or a singular message"
);
Self {
entries: [Entry::new(key, 1, 0, 0), Entry::new(value, 2, 0, 0)],
value_aux,
footprint: core::mem::size_of::<Mp::Key>() + core::mem::size_of::<Mp::Value>(),
for_each: for_each_impl::<Mp>,
decode_entry: decode_entry_impl::<Mp>,
}
}
#[inline]
fn entry_table(&'static self) -> MessageTable {
MessageTable {
entries: &self.entries,
dense: &[],
aux: match &self.value_aux {
Some(aux) => core::slice::from_ref(aux),
None => &[],
},
unknown: NO_UNKNOWN,
}
}
}
#[inline(never)]
pub(super) unsafe fn size_map(
table: &MessageTable,
e: &Entry,
slot: *const u8,
cache: &mut SizeCache,
) -> u64 {
let tl = u64::from(e.tag_len);
let vt = table.map_vt(e);
let entry_table = vt.entry_table();
let mut size = 0u64;
unsafe {
(vt.for_each)(slot, &mut |key, value| {
let entry = size_kind(&entry_table, &vt.entries[0], key, cache)
+ size_kind(&entry_table, &vt.entries[1], value, cache);
size += tl + varint_len(entry) as u64 + entry;
});
}
size
}
#[inline(never)]
pub(super) unsafe fn write_map<K: EncodeSink>(
table: &MessageTable,
e: &Entry,
slot: *const u8,
cache: &mut SizeCache,
buf: &mut K,
) {
let vt = table.map_vt(e);
let entry_table = vt.entry_table();
let [key_entry, value_entry] = &vt.entries;
unsafe {
(vt.for_each)(slot, &mut |key, value| {
let key_len = size_kind(&entry_table, key_entry, key, cache);
if value_entry.kind == Kind::MsgSingular {
let len = cache.consume_next();
let inner = u64::from(len);
let entry =
key_len + u64::from(value_entry.tag_len) + varint_len(inner) as u64 + inner;
put_tag(e, buf);
encode_varint(entry, buf);
write_kind(&entry_table, key_entry, key, cache, buf);
put_tag(value_entry, buf);
encode_varint(inner, buf);
let msg = entry_table.msg_vt(value_entry);
msg.child.write_to((msg.get)(value), len, cache, buf);
} else {
let entry = key_len + size_kind(&entry_table, value_entry, value, cache);
put_tag(e, buf);
encode_varint(entry, buf);
write_kind(&entry_table, key_entry, key, cache, buf);
write_kind(&entry_table, value_entry, value, cache, buf);
}
});
}
}
#[inline(never)]
pub(super) unsafe fn merge_map(
table: &MessageTable,
e: &Entry,
base: *mut u8,
slot: *mut u8,
tag: Tag,
buf: &mut &[u8],
ctx: DecodeContext<'_>,
) -> Result<(), DecodeError> {
check_wire_type(tag, WireType::LengthDelimited)?;
let vt = table.map_vt(e);
let payload = take_len_delimited(buf)?;
ctx.register_element_memory(vt.footprint)?;
let entry_table = vt.entry_table();
let inserted = unsafe {
(vt.decode_entry)(slot, &mut |key, value| {
merge_entry(&entry_table, key, value, payload, ctx)
})?
};
if !inserted && table.unknown != NO_UNKNOWN {
ctx.register_unknown_field()?;
unsafe {
(*base.add(table.unknown as usize).cast::<UnknownFields>()).push(UnknownField {
number: e.tag >> 3,
data: UnknownFieldData::LengthDelimited(payload.to_vec()),
});
}
}
Ok(())
}
unsafe fn merge_entry(
table: &MessageTable,
key: *mut u8,
value: *mut u8,
mut payload: &[u8],
ctx: DecodeContext<'_>,
) -> Result<bool, DecodeError> {
let [key_entry, value_entry] = table.entries else {
unreachable!("an entry table has a key and a value")
};
let mut known = true;
while !payload.is_empty() {
let tag = Tag::decode(&mut payload)?;
match tag.field_number() {
1 => {
unsafe {
merge_kind(
table,
key_entry,
core::ptr::null_mut(),
key,
tag,
&mut payload,
ctx,
)
}?;
}
2 if value_entry.kind == Kind::EnumRequired => {
check_wire_type(tag, WireType::Varint)?;
let raw = types::decode_int32(&mut payload)?;
known = unsafe { (table.enum_vt(value_entry).set)(value, raw) };
if !known {
ctx.check_unknown_field()?;
}
}
2 => {
unsafe {
merge_kind(
table,
value_entry,
core::ptr::null_mut(),
value,
tag,
&mut payload,
ctx,
)
}?;
}
_ => crate::encoding::skip_unknown_field(tag, &mut payload, ctx)?,
}
}
Ok(known)
}