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

handle serde_json for deserialized()

Browse source 
Signed-off-by: Jason Volk <jason@zemos.net>
This commit is contained in:
Jason Volk 2024-09-28 15:14:48 +00:00 • committed by strawberry
parent 946ca364e0
commit 4776fe66c4
13 changed files with 95 additions and 107 deletions
Download patch file Download diff file Expand all files Collapse all files

94
src/database/de.rs
View file

@ -58,10 +58,15 @@ impl<'de> Deserializer<'de> {
}
#[inline]
fn record_trail(&mut self) -> &'de [u8] {
let record = &self.buf[self.pos..];
self.inc_pos(record.len());
record
fn record_next_peek_byte(&self) -> Option<u8> {
let started = self.pos != 0;
let buf = &self.buf[self.pos..];
debug_assert!(
!started || buf[0] == Self::SEP,
"Missing expected record separator at current position"
);
buf.get::<usize>(started.into()).copied()
}
#[inline]
@ -75,6 +80,13 @@ impl<'de> Deserializer<'de> {
self.inc_pos(started.into());
}
#[inline]
fn record_trail(&mut self) -> &'de [u8] {
let record = &self.buf[self.pos..];
self.inc_pos(record.len());
record
}
#[inline]
fn inc_pos(&mut self, n: usize) {
self.pos = self.pos.saturating_add(n);
@ -85,13 +97,6 @@ impl<'de> Deserializer<'de> {
impl<'a, 'de: 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
type Error = Error;
fn deserialize_map<V>(self, _visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
unimplemented!("deserialize Map not implemented")
}
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
@ -113,13 +118,23 @@ impl<'a, 'de: 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
visitor.visit_seq(self)
}
fn deserialize_struct<V>(
self, _name: &'static str, _fields: &'static [&'static str], _visitor: V,
) -> Result<V::Value>
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
unimplemented!("deserialize Struct not implemented")
let input = self.record_next();
let mut d = serde_json::Deserializer::from_slice(input);
d.deserialize_map(visitor).map_err(Into::into)
}
fn deserialize_struct<V>(self, name: &'static str, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
let input = self.record_next();
let mut d = serde_json::Deserializer::from_slice(input);
d.deserialize_struct(name, fields, visitor)
.map_err(Into::into)
}
fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
@ -134,11 +149,14 @@ impl<'a, 'de: 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
visitor.visit_unit()
}
fn deserialize_newtype_struct<V>(self, _name: &'static str, _visitor: V) -> Result<V::Value>
fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
unimplemented!("deserialize Newtype Struct not implemented")
match name {
"$serde_json::private::RawValue" => visitor.visit_map(self),
_ => visitor.visit_newtype_struct(self),
}
}
fn deserialize_enum<V>(
@ -228,19 +246,31 @@ impl<'a, 'de: 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
}
fn deserialize_unit<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize Unit Struct not implemented")
unimplemented!("deserialize Unit not implemented")
}
fn deserialize_identifier<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize Identifier not implemented")
// this only used for $serde_json::private::RawValue at this time; see MapAccess
fn deserialize_identifier<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
let input = "$serde_json::private::RawValue";
visitor.visit_borrowed_str(input)
}
fn deserialize_ignored_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize Ignored Any not implemented")
}
fn deserialize_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
unimplemented!("deserialize any not implemented")
fn deserialize_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
debug_assert_eq!(
conduit::debug::type_name::<V>(),
"serde_json::value::de::<impl serde::de::Deserialize for \
serde_json::value::Value>::deserialize::ValueVisitor",
"deserialize_any: type not expected"
);
match self.record_next_peek_byte() {
Some(b'{') => self.deserialize_map(visitor),
_ => self.deserialize_str(visitor),
}
}
}
@ -259,3 +289,23 @@ impl<'a, 'de: 'a> de::SeqAccess<'de> for &'a mut Deserializer<'de> {
seed.deserialize(&mut **self).map(Some)
}
}
// this only used for $serde_json::private::RawValue at this time. our db
// schema doesn't have its own map format; we use json for that anyway
impl<'a, 'de: 'a> de::MapAccess<'de> for &'a mut Deserializer<'de> {
type Error = Error;
fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
where
K: DeserializeSeed<'de>,
{
seed.deserialize(&mut **self).map(Some)
}
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
where
V: DeserializeSeed<'de>,
{
seed.deserialize(&mut **self)
}
}

14
src/database/deserialized.rs
View file

@ -9,11 +9,6 @@ pub trait Deserialized {
F: FnOnce(T) -> U,
T: for<'de> Deserialize<'de>;
fn map_json<T, U, F>(self, f: F) -> Result<U>
where
F: FnOnce(T) -> U,
T: for<'de> Deserialize<'de>;
#[inline]
fn deserialized<T>(self) -> Result<T>
where
@ -22,13 +17,4 @@ pub trait Deserialized {
{
self.map_de(identity::<T>)
}
#[inline]
fn deserialized_json<T>(self) -> Result<T>
where
T: for<'de> Deserialize<'de>,
Self: Sized,
{
self.map_json(identity::<T>)
}
}

28
src/database/handle.rs
View file

@ -48,15 +48,6 @@ impl AsRef<Slice> for Handle<'_> {
}
impl Deserialized for Result<Handle<'_>> {
#[inline]
fn map_json<T, U, F>(self, f: F) -> Result<U>
where
F: FnOnce(T) -> U,
T: for<'de> Deserialize<'de>,
{
self?.map_json(f)
}
#[inline]
fn map_de<T, U, F>(self, f: F) -> Result<U>
where
@ -68,15 +59,6 @@ impl Deserialized for Result<Handle<'_>> {
}
impl<'a> Deserialized for Result<&'a Handle<'a>> {
#[inline]
fn map_json<T, U, F>(self, f: F) -> Result<U>
where
F: FnOnce(T) -> U,
T: for<'de> Deserialize<'de>,
{
self.and_then(|handle| handle.map_json(f))
}
#[inline]
fn map_de<T, U, F>(self, f: F) -> Result<U>
where
@ -88,16 +70,6 @@ impl<'a> Deserialized for Result<&'a Handle<'a>> {
}
impl<'a> Deserialized for &'a Handle<'a> {
fn map_json<T, U, F>(self, f: F) -> Result<U>
where
F: FnOnce(T) -> U,
T: for<'de> Deserialize<'de>,
{
serde_json::from_slice::<T>(self.as_ref())
.map_err(Into::into)
.map(f)
}
fn map_de<T, U, F>(self, f: F) -> Result<U>
where
F: FnOnce(T) -> U,