magmaus3/continuwuity
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

wrap unimplemented ser/de branches with internal macro

Browse source 
Signed-off-by: Jason Volk <jason@zemos.net>
This commit is contained in:
Jason Volk 2024-11-01 22:43:26 +00:00
parent ba1c134689
commit 8742437036
4 changed files with 66 additions and 41 deletions
Download patch file Download diff file Expand all files Collapse all files

34
src/database/de.rs
View file

@ -5,6 +5,8 @@ use serde::{
Deserialize,
};
use crate::util::unhandled;
/// Deserialize into T from buffer.
pub(crate) fn from_slice<'a, T>(buf: &'a [u8]) -> Result<T>
where
@ -192,7 +194,7 @@ impl<'a, 'de: 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
match name {
"Ignore" => self.record_ignore(),
"IgnoreAll" => self.record_ignore_all(),
_ => unimplemented!("Unrecognized deserialization Directive {name:?}"),
_ => unhandled!("Unrecognized deserialization Directive {name:?}"),
};
visitor.visit_unit()
@ -214,27 +216,27 @@ impl<'a, 'de: 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
where
V: Visitor<'de>,
{
unimplemented!("deserialize Enum not implemented")
unhandled!("deserialize Enum not implemented")
}
fn deserialize_option<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize Option not implemented")
unhandled!("deserialize Option not implemented")
}
fn deserialize_bool<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize bool not implemented")
unhandled!("deserialize bool not implemented")
}
fn deserialize_i8<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize i8 not implemented")
unhandled!("deserialize i8 not implemented")
}
fn deserialize_i16<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize i16 not implemented")
unhandled!("deserialize i16 not implemented")
}
fn deserialize_i32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize i32 not implemented")
unhandled!("deserialize i32 not implemented")
}
fn deserialize_i64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
@ -244,15 +246,15 @@ impl<'a, 'de: 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
}
fn deserialize_u8<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize u8 not implemented; try dereferencing the Handle for [u8] access instead")
unhandled!("deserialize u8 not implemented; try dereferencing the Handle for [u8] access instead")
}
fn deserialize_u16<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize u16 not implemented")
unhandled!("deserialize u16 not implemented")
}
fn deserialize_u32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize u32 not implemented")
unhandled!("deserialize u32 not implemented")
}
fn deserialize_u64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
@ -262,15 +264,15 @@ impl<'a, 'de: 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
}
fn deserialize_f32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize f32 not implemented")
unhandled!("deserialize f32 not implemented")
}
fn deserialize_f64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize f64 not implemented")
unhandled!("deserialize f64 not implemented")
}
fn deserialize_char<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize char not implemented")
unhandled!("deserialize char not implemented")
}
fn deserialize_str<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
@ -291,11 +293,11 @@ impl<'a, 'de: 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
}
fn deserialize_byte_buf<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize Byte Buf not implemented")
unhandled!("deserialize Byte Buf not implemented")
}
fn deserialize_unit<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize Unit not implemented")
unhandled!("deserialize Unit not implemented")
}
// this only used for $serde_json::private::RawValue at this time; see MapAccess
@ -305,7 +307,7 @@ impl<'a, 'de: 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
}
fn deserialize_ignored_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize Ignored Any not implemented")
unhandled!("deserialize Ignored Any not implemented")
}
fn deserialize_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {

2
src/database/mod.rs
View file

@ -11,7 +11,7 @@ mod opts;
mod ser;
mod stream;
mod tests;
mod util;
pub(crate) mod util;
mod watchers;
pub(crate) use self::{

48
src/database/ser.rs
View file

@ -4,6 +4,8 @@ use arrayvec::ArrayVec;
use conduit::{debug::type_name, err, result::DebugInspect, utils::exchange, Error, Result};
use serde::{ser, Serialize};
use crate::util::unhandled;
#[inline]
pub fn serialize_to_array<const MAX: usize, T>(val: T) -> Result<ArrayVec<u8, MAX>>
where
@ -146,17 +148,15 @@ impl<W: Write> ser::Serializer for &mut Serializer<'_, W> {
fn serialize_tuple_variant(
self, _name: &'static str, _idx: u32, _var: &'static str, _len: usize,
) -> Result<Self::SerializeTupleVariant> {
unimplemented!("serialize Tuple Variant not implemented")
unhandled!("serialize Tuple Variant not implemented")
}
fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
unimplemented!(
"serialize Map not implemented; did you mean to use database::Json() around your serde_json::Value?"
)
unhandled!("serialize Map not implemented; did you mean to use database::Json() around your serde_json::Value?")
}
fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
unimplemented!(
unhandled!(
"serialize Struct not implemented at this time; did you mean to use database::Json() around your struct?"
)
}
@ -164,7 +164,7 @@ impl<W: Write> ser::Serializer for &mut Serializer<'_, W> {
fn serialize_struct_variant(
self, _name: &'static str, _idx: u32, _var: &'static str, _len: usize,
) -> Result<Self::SerializeStructVariant> {
unimplemented!("serialize Struct Variant not implemented")
unhandled!("serialize Struct Variant not implemented")
}
#[allow(clippy::needless_borrows_for_generic_args)] // buggy
@ -179,14 +179,14 @@ impl<W: Write> ser::Serializer for &mut Serializer<'_, W> {
match name {
"Json" => serde_json::to_writer(&mut self.out, value).map_err(Into::into),
_ => unimplemented!("Unrecognized serialization Newtype {name:?}"),
_ => unhandled!("Unrecognized serialization Newtype {name:?}"),
}
}
fn serialize_newtype_variant<T: Serialize + ?Sized>(
self, _name: &'static str, _idx: u32, _var: &'static str, _value: &T,
) -> Result<Self::Ok> {
unimplemented!("serialize Newtype Variant not implemented")
unhandled!("serialize Newtype Variant not implemented")
}
fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok> {
@ -197,14 +197,14 @@ impl<W: Write> ser::Serializer for &mut Serializer<'_, W> {
"Separator" => {
self.separator()?;
},
_ => unimplemented!("Unrecognized serialization directive: {name:?}"),
_ => unhandled!("Unrecognized serialization directive: {name:?}"),
};
Ok(())
}
fn serialize_unit_variant(self, _name: &'static str, _idx: u32, _var: &'static str) -> Result<Self::Ok> {
unimplemented!("serialize Unit Variant not implemented")
unhandled!("serialize Unit Variant not implemented")
}
fn serialize_some<T: Serialize + ?Sized>(self, val: &T) -> Result<Self::Ok> { val.serialize(self) }
@ -234,29 +234,29 @@ impl<W: Write> ser::Serializer for &mut Serializer<'_, W> {
self.write(v)
}
fn serialize_f64(self, _v: f64) -> Result<Self::Ok> { unimplemented!("serialize f64 not implemented") }
fn serialize_f64(self, _v: f64) -> Result<Self::Ok> { unhandled!("serialize f64 not implemented") }
fn serialize_f32(self, _v: f32) -> Result<Self::Ok> { unimplemented!("serialize f32 not implemented") }
fn serialize_f32(self, _v: f32) -> Result<Self::Ok> { unhandled!("serialize f32 not implemented") }
fn serialize_i64(self, v: i64) -> Result<Self::Ok> { self.write(&v.to_be_bytes()) }
fn serialize_i32(self, v: i32) -> Result<Self::Ok> { self.write(&v.to_be_bytes()) }
fn serialize_i16(self, _v: i16) -> Result<Self::Ok> { unimplemented!("serialize i16 not implemented") }
fn serialize_i16(self, _v: i16) -> Result<Self::Ok> { unhandled!("serialize i16 not implemented") }
fn serialize_i8(self, _v: i8) -> Result<Self::Ok> { unimplemented!("serialize i8 not implemented") }
fn serialize_i8(self, _v: i8) -> Result<Self::Ok> { unhandled!("serialize i8 not implemented") }
fn serialize_u64(self, v: u64) -> Result<Self::Ok> { self.write(&v.to_be_bytes()) }
fn serialize_u32(self, v: u32) -> Result<Self::Ok> { self.write(&v.to_be_bytes()) }
fn serialize_u16(self, _v: u16) -> Result<Self::Ok> { unimplemented!("serialize u16 not implemented") }
fn serialize_u16(self, _v: u16) -> Result<Self::Ok> { unhandled!("serialize u16 not implemented") }
fn serialize_u8(self, v: u8) -> Result<Self::Ok> { self.write(&[v]) }
fn serialize_bool(self, _v: bool) -> Result<Self::Ok> { unimplemented!("serialize bool not implemented") }
fn serialize_bool(self, _v: bool) -> Result<Self::Ok> { unhandled!("serialize bool not implemented") }
fn serialize_unit(self) -> Result<Self::Ok> { unimplemented!("serialize unit not implemented") }
fn serialize_unit(self) -> Result<Self::Ok> { unhandled!("serialize unit not implemented") }
}
impl<W: Write> ser::SerializeSeq for &mut Serializer<'_, W> {
@ -309,14 +309,14 @@ impl<W: Write> ser::SerializeMap for &mut Serializer<'_, W> {
type Ok = ();
fn serialize_key<T: Serialize + ?Sized>(&mut self, _key: &T) -> Result<Self::Ok> {
unimplemented!("serialize Map Key not implemented")
unhandled!("serialize Map Key not implemented")
}
fn serialize_value<T: Serialize + ?Sized>(&mut self, _val: &T) -> Result<Self::Ok> {
unimplemented!("serialize Map Val not implemented")
unhandled!("serialize Map Val not implemented")
}
fn end(self) -> Result<Self::Ok> { unimplemented!("serialize Map End not implemented") }
fn end(self) -> Result<Self::Ok> { unhandled!("serialize Map End not implemented") }
}
impl<W: Write> ser::SerializeStruct for &mut Serializer<'_, W> {
@ -324,10 +324,10 @@ impl<W: Write> ser::SerializeStruct for &mut Serializer<'_, W> {
type Ok = ();
fn serialize_field<T: Serialize + ?Sized>(&mut self, _key: &'static str, _val: &T) -> Result<Self::Ok> {
unimplemented!("serialize Struct Field not implemented")
unhandled!("serialize Struct Field not implemented")
}
fn end(self) -> Result<Self::Ok> { unimplemented!("serialize Struct End not implemented") }
fn end(self) -> Result<Self::Ok> { unhandled!("serialize Struct End not implemented") }
}
impl<W: Write> ser::SerializeStructVariant for &mut Serializer<'_, W> {
@ -335,8 +335,8 @@ impl<W: Write> ser::SerializeStructVariant for &mut Serializer<'_, W> {
type Ok = ();
fn serialize_field<T: Serialize + ?Sized>(&mut self, _key: &'static str, _val: &T) -> Result<Self::Ok> {
unimplemented!("serialize Struct Variant Field not implemented")
unhandled!("serialize Struct Variant Field not implemented")
}
fn end(self) -> Result<Self::Ok> { unimplemented!("serialize Struct Variant End not implemented") }
fn end(self) -> Result<Self::Ok> { unhandled!("serialize Struct Variant End not implemented") }
}

23
src/database/util.rs
View file

@ -1,6 +1,29 @@
use conduit::{err, Result};
use rocksdb::{Direction, IteratorMode};
//#[cfg(debug_assertions)]
macro_rules! unhandled {
($msg:literal) => {
unimplemented!($msg)
};
}
// activate when stable; we're not ready for this yet
#[cfg(disable)] // #[cfg(not(debug_assertions))]
macro_rules! unhandled {
($msg:literal) => {
// SAFETY: Eliminates branches for serializing and deserializing types never
// encountered in the codebase. This can promote optimization and reduce
// codegen. The developer must verify for every invoking callsite that the
// unhandled type is in no way involved and could not possibly be encountered.
unsafe {
std::hint::unreachable_unchecked();
}
};
}
pub(crate) use unhandled;
#[inline]
pub(crate) fn _into_direction(mode: &IteratorMode<'_>) -> Direction {
use Direction::{Forward, Reverse};