Lines
21.97 %
Functions
16 %
Branches
100 %
//! Hacks to extract the version and index from a slotmap key, using serde.
//!
//! This approach may fail in the future if `slotmap` changes its serde output;
//! but that would probably break a bunch other tools that depend on `slotmap`.
//! ## Performance
//! This serde-based approach might look inefficient, but the compiler is smart:
//! it can inline all of the code and turn `key_data_parts` into direct data lookups.
//! (Note that this performance property requires us to use `opt-level = 2` for this crate,
//! in contrast with the rest of Arti, which currently prefers `opt-level = "s"`.)
//! To conform that performance is likely acceptable, run
//! `cargo asm slotmap_careful::key_data::key_data_parts`,
//! and confirm that the result would fit on a napkin.
use serde::{
ser::{Impossible, SerializeStruct},
Serialize,
};
use slotmap::Key;
/// Return the version encoded in `key`.
///
/// (This version that starts with 0 when a slot is first created, and increments by 1 every
/// time the slot is re-used. It cannot grow larger than `0x7fff_ffff`.)
pub(crate) fn key_version_serde<K: Key>(key: K) -> u32 {
key_data_parts(key.data())
.expect("Slotmap has changed its serde format")
.0
>> 1
}
/// Decode a `slotmap::KeyData` into its `version` and `index` components.
/// Note that the `version` value here will include the trailing LSB=1 value,
/// to indicate that it is for an occupied slot.
/// The caller should right-shift the version result by 1
/// to get the actual "version" of the slot
/// (as we define "version" in the rest of this crate).
pub(crate) fn key_data_parts(key_data: slotmap::KeyData) -> Result<(u32, u32), Failed> {
let mut s = Ser {
version: None,
index: None,
key_data.serialize(&mut s)?;
Ok((s.version.ok_or(Failed)?, s.index.ok_or(Failed)?))
/// Serializer for slotmap::KeyData, to extract the version and index of a key.
struct Ser {
/// If present, a version we have found.
version: Option<u32>,
/// If present, a slot index we have found.
index: Option<u32>,
/// An unexpected failure from serializing a key.
#[derive(Clone, Debug, thiserror::Error)]
#[error("slotmap keydata did not serialize as expected")]
pub(crate) struct Failed;
impl serde::ser::Error for Failed {
fn custom<T>(_msg: T) -> Self
where
T: std::fmt::Display,
{
Failed
#[allow(unused_variables)] // for all the function arguments we'll ignore
impl<'a> serde::Serializer for &'a mut Ser {
type Ok = ();
type Error = Failed;
type SerializeSeq = Impossible<(), Failed>;
type SerializeTuple = Impossible<(), Failed>;
type SerializeTupleStruct = Impossible<(), Failed>;
type SerializeTupleVariant = Impossible<(), Failed>;
type SerializeMap = Impossible<(), Failed>;
type SerializeStruct = Self;
type SerializeStructVariant = Impossible<(), Failed>;
fn serialize_struct(
self,
name: &'static str,
len: usize,
) -> Result<Self::SerializeStruct, Self::Error> {
Ok(self)
fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
Err(Failed)
shared_no_ops! {}
impl<'a> SerializeStruct for &'a mut Ser {
fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
T: ?Sized + Serialize,
if key == "version" {
self.version = Some(value.serialize(&mut SerU32)?);
} else if key == "idx" {
self.index = Some(value.serialize(&mut SerU32)?);
Ok(())
fn end(self) -> Result<Self::Ok, Self::Error> {
/// Serializer that extracts a u32, and rejects anything else.
struct SerU32;
impl<'a> serde::Serializer for &'a mut SerU32 {
type Ok = u32;
type SerializeSeq = Impossible<u32, Failed>;
type SerializeTuple = Impossible<u32, Failed>;
type SerializeTupleStruct = Impossible<u32, Failed>;
type SerializeTupleVariant = Impossible<u32, Failed>;
type SerializeMap = Impossible<u32, Failed>;
type SerializeStruct = Impossible<u32, Failed>;
type SerializeStructVariant = Impossible<u32, Failed>;
Ok(v)
/// Helper: Define the common members of `Ser` and `SerU32`.
/// (These are just a bunch of methods that return `Err(Failed)`)
macro_rules! shared_no_ops {
{} => {
fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
fn serialize_unit_variant(
variant_index: u32,
variant: &'static str,
) -> Result<Self::Ok, Self::Error> {
fn serialize_newtype_struct<T>(
value: &T,
) -> Result<Self::Ok, Self::Error>
fn serialize_newtype_variant<T>(
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
fn serialize_tuple_struct(
) -> Result<Self::SerializeTupleStruct, Self::Error> {
fn serialize_tuple_variant(
) -> Result<Self::SerializeTupleVariant, Self::Error> {
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
fn serialize_struct_variant(
) -> Result<Self::SerializeStructVariant, Self::Error> {
use shared_no_ops;