More error cleanup
This commit is contained in:
parent
3f5e431717
commit
450b73a4d2
|
@ -392,7 +392,7 @@ mod samples_tests {
|
||||||
12345,
|
12345,
|
||||||
Value::from("hi").wrap());
|
Value::from("hi").wrap());
|
||||||
println!("== v: {:#?}", v);
|
println!("== v: {:#?}", v);
|
||||||
let w: PlainValue<Dom> = to_value(&v).unwrap();
|
let w: PlainValue<Dom> = to_value(&v);
|
||||||
println!("== w: {:#?}", w);
|
println!("== w: {:#?}", w);
|
||||||
let x = from_value(&w).unwrap();
|
let x = from_value(&w).unwrap();
|
||||||
println!("== x: {:#?}", &x);
|
println!("== x: {:#?}", &x);
|
||||||
|
|
|
@ -1,6 +1,5 @@
|
||||||
use crate::value::{Value, NestedValue, Map, Domain};
|
use crate::value::{Value, NestedValue, Map, Domain};
|
||||||
use crate::value::value::{Float, Double};
|
use crate::value::value::{Float, Double};
|
||||||
use crate::value::error::{Error, Result, ExpectedKind};
|
|
||||||
use num::traits::cast::ToPrimitive;
|
use num::traits::cast::ToPrimitive;
|
||||||
use serde::Deserialize;
|
use serde::Deserialize;
|
||||||
use serde::de::{Visitor, SeqAccess, MapAccess, EnumAccess, VariantAccess, DeserializeSeed};
|
use serde::de::{Visitor, SeqAccess, MapAccess, EnumAccess, VariantAccess, DeserializeSeed};
|
||||||
|
@ -8,6 +7,63 @@ use std::convert::TryFrom;
|
||||||
use std::iter::Iterator;
|
use std::iter::Iterator;
|
||||||
use std::marker::PhantomData;
|
use std::marker::PhantomData;
|
||||||
|
|
||||||
|
pub mod error {
|
||||||
|
use num::bigint::BigInt;
|
||||||
|
use crate::value::{PlainValue, Domain};
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Error<D: Domain> {
|
||||||
|
Message(String),
|
||||||
|
InvalidUnicodeScalar(u32),
|
||||||
|
NumberTooLarge(BigInt),
|
||||||
|
CannotDeserializeAny,
|
||||||
|
Expected(ExpectedKind, PlainValue<D>),
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum ExpectedKind {
|
||||||
|
Boolean,
|
||||||
|
Float,
|
||||||
|
Double,
|
||||||
|
|
||||||
|
SignedInteger,
|
||||||
|
String,
|
||||||
|
ByteString,
|
||||||
|
Symbol,
|
||||||
|
|
||||||
|
Record(Option<usize>),
|
||||||
|
SimpleRecord(&'static str, Option<usize>),
|
||||||
|
Option,
|
||||||
|
Sequence,
|
||||||
|
Dictionary,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<D: Domain> serde::ser::Error for Error<D> {
|
||||||
|
fn custom<T: std::fmt::Display>(msg: T) -> Self {
|
||||||
|
Self::Message(msg.to_string())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<D: Domain> serde::de::Error for Error<D> {
|
||||||
|
fn custom<T: std::fmt::Display>(msg: T) -> Self {
|
||||||
|
Self::Message(msg.to_string())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<D: Domain> std::error::Error for Error<D> {}
|
||||||
|
|
||||||
|
impl<D: Domain> std::fmt::Display for Error<D> {
|
||||||
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||||
|
write!(f, "{:?}", self)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub use error::Error;
|
||||||
|
use error::ExpectedKind;
|
||||||
|
|
||||||
|
pub type Result<T, D> = std::result::Result<T, Error<D>>;
|
||||||
|
|
||||||
pub struct Deserializer<'de, N: NestedValue<D>, D: Domain> {
|
pub struct Deserializer<'de, N: NestedValue<D>, D: Domain> {
|
||||||
input: &'de N,
|
input: &'de N,
|
||||||
phantom: PhantomData<D>,
|
phantom: PhantomData<D>,
|
||||||
|
|
|
@ -1,51 +0,0 @@
|
||||||
use num::bigint::BigInt;
|
|
||||||
use crate::value::{PlainValue, Domain};
|
|
||||||
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub enum Error<D: Domain> {
|
|
||||||
Message(String),
|
|
||||||
InvalidUnicodeScalar(u32),
|
|
||||||
NumberTooLarge(BigInt),
|
|
||||||
CannotDeserializeAny,
|
|
||||||
Expected(ExpectedKind, PlainValue<D>),
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub enum ExpectedKind {
|
|
||||||
Boolean,
|
|
||||||
Float,
|
|
||||||
Double,
|
|
||||||
|
|
||||||
SignedInteger,
|
|
||||||
String,
|
|
||||||
ByteString,
|
|
||||||
Symbol,
|
|
||||||
|
|
||||||
Record(Option<usize>),
|
|
||||||
SimpleRecord(&'static str, Option<usize>),
|
|
||||||
Option,
|
|
||||||
Sequence,
|
|
||||||
Dictionary,
|
|
||||||
}
|
|
||||||
|
|
||||||
pub type Result<T, D> = std::result::Result<T, Error<D>>;
|
|
||||||
|
|
||||||
impl<D: Domain> serde::ser::Error for Error<D> {
|
|
||||||
fn custom<T: std::fmt::Display>(msg: T) -> Self {
|
|
||||||
Self::Message(msg.to_string())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<D: Domain> serde::de::Error for Error<D> {
|
|
||||||
fn custom<T: std::fmt::Display>(msg: T) -> Self {
|
|
||||||
Self::Message(msg.to_string())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<D: Domain> std::error::Error for Error<D> {}
|
|
||||||
|
|
||||||
impl<D: Domain> std::fmt::Display for Error<D> {
|
|
||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
||||||
write!(f, "{:?}", self)
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -3,7 +3,6 @@ pub mod constants;
|
||||||
pub mod de;
|
pub mod de;
|
||||||
pub mod decoder;
|
pub mod decoder;
|
||||||
pub mod encoder;
|
pub mod encoder;
|
||||||
pub mod error;
|
|
||||||
pub mod reader;
|
pub mod reader;
|
||||||
pub mod ser;
|
pub mod ser;
|
||||||
pub mod value;
|
pub mod value;
|
||||||
|
|
|
@ -1,8 +1,23 @@
|
||||||
use crate::value::{Value, NestedValue, Map, Domain};
|
use crate::value::{Value, NestedValue, Map, Domain};
|
||||||
use serde::Serialize;
|
use serde::Serialize;
|
||||||
use crate::value::error::{Error, Result};
|
|
||||||
use std::marker::PhantomData;
|
use std::marker::PhantomData;
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Error {}
|
||||||
|
impl serde::ser::Error for Error {
|
||||||
|
fn custom<T>(_: T) -> Self where T: std::fmt::Display {
|
||||||
|
unreachable!()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::error::Error for Error {}
|
||||||
|
impl std::fmt::Display for Error {
|
||||||
|
fn fmt(&self, _fmt: &mut std::fmt::Formatter) -> std::result::Result<(), std::fmt::Error> {
|
||||||
|
unreachable!()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
type Result<T> = std::result::Result<T, Error>;
|
||||||
|
|
||||||
pub struct Serializer<N: NestedValue<D>, D: Domain> {
|
pub struct Serializer<N: NestedValue<D>, D: Domain> {
|
||||||
phantom: PhantomData<(N, D)>,
|
phantom: PhantomData<(N, D)>,
|
||||||
}
|
}
|
||||||
|
@ -26,7 +41,7 @@ pub struct SerializeSequence<N: NestedValue<D>, D: Domain> {
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
|
impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
|
||||||
type Ok = N;
|
type Ok = N;
|
||||||
type Error = Error<D>;
|
type Error = Error;
|
||||||
type SerializeSeq = SerializeSequence<N, D>;
|
type SerializeSeq = SerializeSequence<N, D>;
|
||||||
type SerializeTuple = SerializeRecord<N, D>;
|
type SerializeTuple = SerializeRecord<N, D>;
|
||||||
type SerializeTupleStruct = SerializeRecord<N, D>;
|
type SerializeTupleStruct = SerializeRecord<N, D>;
|
||||||
|
@ -35,75 +50,75 @@ impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
|
||||||
type SerializeStruct = SerializeRecord<N, D>;
|
type SerializeStruct = SerializeRecord<N, D>;
|
||||||
type SerializeStructVariant = SerializeRecord<N, D>;
|
type SerializeStructVariant = SerializeRecord<N, D>;
|
||||||
|
|
||||||
fn serialize_bool(self, v: bool) -> Result<Self::Ok, D> {
|
fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_i8(self, v: i8) -> Result<Self::Ok, D> {
|
fn serialize_i8(self, v: i8) -> Result<Self::Ok> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_i16(self, v: i16) -> Result<Self::Ok, D> {
|
fn serialize_i16(self, v: i16) -> Result<Self::Ok> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_i32(self, v: i32) -> Result<Self::Ok, D> {
|
fn serialize_i32(self, v: i32) -> Result<Self::Ok> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_i64(self, v: i64) -> Result<Self::Ok, D> {
|
fn serialize_i64(self, v: i64) -> Result<Self::Ok> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_u8(self, v: u8) -> Result<Self::Ok, D> {
|
fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_u16(self, v: u16) -> Result<Self::Ok, D> {
|
fn serialize_u16(self, v: u16) -> Result<Self::Ok> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_u32(self, v: u32) -> Result<Self::Ok, D> {
|
fn serialize_u32(self, v: u32) -> Result<Self::Ok> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_u64(self, v: u64) -> Result<Self::Ok, D> {
|
fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_f32(self, v: f32) -> Result<Self::Ok, D> {
|
fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_f64(self, v: f64) -> Result<Self::Ok, D> {
|
fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_char(self, v: char) -> Result<Self::Ok, D> {
|
fn serialize_char(self, v: char) -> Result<Self::Ok> {
|
||||||
Ok(Value::simple_record("UnicodeScalar", vec![Value::from(v as u32).wrap()]).wrap())
|
Ok(Value::simple_record("UnicodeScalar", vec![Value::from(v as u32).wrap()]).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_str(self, v: &str) -> Result<Self::Ok, D> {
|
fn serialize_str(self, v: &str) -> Result<Self::Ok> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, D> {
|
fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok> {
|
||||||
Ok(Value::from(v).wrap())
|
Ok(Value::from(v).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_none(self) -> Result<Self::Ok, D> {
|
fn serialize_none(self) -> Result<Self::Ok> {
|
||||||
Ok(Value::simple_record("None", vec![]).wrap())
|
Ok(Value::simple_record("None", vec![]).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_some<T: ?Sized>(self, v: &T) -> Result<Self::Ok, D> where T: Serialize {
|
fn serialize_some<T: ?Sized>(self, v: &T) -> Result<Self::Ok> where T: Serialize {
|
||||||
Ok(Value::simple_record("Some", vec![to_value(v)?]).wrap())
|
Ok(Value::simple_record("Some", vec![to_value(v)]).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_unit(self) -> Result<Self::Ok, D> {
|
fn serialize_unit(self) -> Result<Self::Ok> {
|
||||||
Ok(Value::simple_record("tuple", vec![]).wrap())
|
Ok(Value::simple_record("tuple", vec![]).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, D> {
|
fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok> {
|
||||||
Ok(Value::simple_record(name, vec![]).wrap())
|
Ok(Value::simple_record(name, vec![]).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -111,13 +126,13 @@ impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
|
||||||
_name: &'static str,
|
_name: &'static str,
|
||||||
_variant: u32,
|
_variant: u32,
|
||||||
variant_name: &'static str) ->
|
variant_name: &'static str) ->
|
||||||
Result<Self::Ok, D>
|
Result<Self::Ok>
|
||||||
{
|
{
|
||||||
Ok(Value::simple_record(variant_name, vec![]).wrap())
|
Ok(Value::simple_record(variant_name, vec![]).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_newtype_struct<T: ?Sized>(self, name: &'static str, value: &T) ->
|
fn serialize_newtype_struct<T: ?Sized>(self, name: &'static str, value: &T) ->
|
||||||
Result<Self::Ok, D> where T: Serialize
|
Result<Self::Ok> where T: Serialize
|
||||||
{
|
{
|
||||||
if name == crate::value::value::MAGIC_VALUE {
|
if name == crate::value::value::MAGIC_VALUE {
|
||||||
let b = unsafe { Box::from_raw(*((value as *const T) as *const u64) as *mut &Value<N, D>) };
|
let b = unsafe { Box::from_raw(*((value as *const T) as *const u64) as *mut &Value<N, D>) };
|
||||||
|
@ -129,7 +144,7 @@ impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
|
||||||
Ok(v.clone())
|
Ok(v.clone())
|
||||||
} else {
|
} else {
|
||||||
// TODO: This is apparently discouraged, and we should apparently just serialize `value`?
|
// TODO: This is apparently discouraged, and we should apparently just serialize `value`?
|
||||||
Ok(Value::simple_record(name, vec![to_value(value)?]).wrap())
|
Ok(Value::simple_record(name, vec![to_value(value)]).wrap())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -138,22 +153,22 @@ impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
|
||||||
_variant: u32,
|
_variant: u32,
|
||||||
variant_name: &'static str,
|
variant_name: &'static str,
|
||||||
value: &T) ->
|
value: &T) ->
|
||||||
Result<Self::Ok, D> where T: Serialize
|
Result<Self::Ok> where T: Serialize
|
||||||
{
|
{
|
||||||
Ok(Value::simple_record(variant_name, vec![to_value(value)?]).wrap())
|
Ok(Value::simple_record(variant_name, vec![to_value(value)]).wrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_seq(self, count: Option<usize>) -> Result<Self::SerializeSeq, D> {
|
fn serialize_seq(self, count: Option<usize>) -> Result<Self::SerializeSeq> {
|
||||||
let vec = match count { Some(n) => Vec::with_capacity(n), None => Vec::new() };
|
let vec = match count { Some(n) => Vec::with_capacity(n), None => Vec::new() };
|
||||||
Ok(SerializeSequence{ vec, phantom: PhantomData })
|
Ok(SerializeSequence{ vec, phantom: PhantomData })
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_tuple(self, count: usize) -> Result<Self::SerializeTuple, D> {
|
fn serialize_tuple(self, count: usize) -> Result<Self::SerializeTuple> {
|
||||||
Ok(SerializeRecord{ name: "tuple", vec: Vec::with_capacity(count), phantom: PhantomData })
|
Ok(SerializeRecord{ name: "tuple", vec: Vec::with_capacity(count), phantom: PhantomData })
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_tuple_struct(self, name: &'static str, count: usize) ->
|
fn serialize_tuple_struct(self, name: &'static str, count: usize) ->
|
||||||
Result<Self::SerializeTupleStruct, D>
|
Result<Self::SerializeTupleStruct>
|
||||||
{
|
{
|
||||||
Ok(SerializeRecord{ name, vec: Vec::with_capacity(count), phantom: PhantomData })
|
Ok(SerializeRecord{ name, vec: Vec::with_capacity(count), phantom: PhantomData })
|
||||||
}
|
}
|
||||||
|
@ -163,16 +178,16 @@ impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
|
||||||
_variant: u32,
|
_variant: u32,
|
||||||
variant_name: &'static str,
|
variant_name: &'static str,
|
||||||
count: usize) ->
|
count: usize) ->
|
||||||
Result<Self::SerializeTupleVariant, D>
|
Result<Self::SerializeTupleVariant>
|
||||||
{
|
{
|
||||||
Ok(SerializeRecord{ name: variant_name, vec: Vec::with_capacity(count), phantom: PhantomData })
|
Ok(SerializeRecord{ name: variant_name, vec: Vec::with_capacity(count), phantom: PhantomData })
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_map(self, _count: Option<usize>) -> Result<Self::SerializeMap, D> {
|
fn serialize_map(self, _count: Option<usize>) -> Result<Self::SerializeMap> {
|
||||||
Ok(SerializeDictionary{ next_key: None, items: Map::new(), phantom: PhantomData })
|
Ok(SerializeDictionary{ next_key: None, items: Map::new(), phantom: PhantomData })
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_struct(self, name: &'static str, count: usize) -> Result<Self::SerializeStruct, D> {
|
fn serialize_struct(self, name: &'static str, count: usize) -> Result<Self::SerializeStruct> {
|
||||||
Ok(SerializeRecord{ name, vec: Vec::with_capacity(count), phantom: PhantomData })
|
Ok(SerializeRecord{ name, vec: Vec::with_capacity(count), phantom: PhantomData })
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -181,7 +196,7 @@ impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
|
||||||
_variant: u32,
|
_variant: u32,
|
||||||
variant_name: &'static str,
|
variant_name: &'static str,
|
||||||
count: usize) ->
|
count: usize) ->
|
||||||
Result<Self::SerializeStructVariant, D>
|
Result<Self::SerializeStructVariant>
|
||||||
{
|
{
|
||||||
Ok(SerializeRecord{ name: variant_name, vec: Vec::with_capacity(count), phantom: PhantomData })
|
Ok(SerializeRecord{ name: variant_name, vec: Vec::with_capacity(count), phantom: PhantomData })
|
||||||
}
|
}
|
||||||
|
@ -189,118 +204,118 @@ impl<N: NestedValue<D>, D: Domain> serde::Serializer for Serializer<N, D> {
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeMap for SerializeDictionary<N, D> {
|
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeMap for SerializeDictionary<N, D> {
|
||||||
type Ok = N;
|
type Ok = N;
|
||||||
type Error = Error<D>;
|
type Error = Error;
|
||||||
|
|
||||||
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), D> where T: Serialize {
|
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<()> where T: Serialize {
|
||||||
self.next_key = Some(to_value(key)?);
|
self.next_key = Some(to_value(key));
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), D> where T: Serialize {
|
fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
||||||
let key = self.next_key.take().unwrap();
|
let key = self.next_key.take().unwrap();
|
||||||
self.items.insert(key, to_value(value)?);
|
self.items.insert(key, to_value(value));
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok, D> {
|
fn end(self) -> Result<Self::Ok> {
|
||||||
Ok(Value::from(self.items).wrap())
|
Ok(Value::from(self.items).wrap())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> SerializeRecord<N, D> {
|
impl<N: NestedValue<D>, D: Domain> SerializeRecord<N, D> {
|
||||||
fn push(&mut self, value: N) -> Result<(), D> {
|
fn push(&mut self, value: N) -> Result<()> {
|
||||||
self.vec.push(value);
|
self.vec.push(value);
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn finish(self) -> Result<N, D> {
|
fn finish(self) -> Result<N> {
|
||||||
Ok(Value::simple_record(self.name, self.vec).wrap())
|
Ok(Value::simple_record(self.name, self.vec).wrap())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeStruct for SerializeRecord<N, D> {
|
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeStruct for SerializeRecord<N, D> {
|
||||||
type Ok = N;
|
type Ok = N;
|
||||||
type Error = Error<D>;
|
type Error = Error;
|
||||||
|
|
||||||
fn serialize_field<T: ?Sized>(&mut self, _name: &'static str, value: &T) -> Result<(), D>
|
fn serialize_field<T: ?Sized>(&mut self, _name: &'static str, value: &T) -> Result<()>
|
||||||
where T: Serialize
|
where T: Serialize
|
||||||
{
|
{
|
||||||
self.push(to_value(value)?)
|
self.push(to_value(value))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok, D> {
|
fn end(self) -> Result<Self::Ok> {
|
||||||
self.finish()
|
self.finish()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeStructVariant for SerializeRecord<N, D> {
|
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeStructVariant for SerializeRecord<N, D> {
|
||||||
type Ok = N;
|
type Ok = N;
|
||||||
type Error = Error<D>;
|
type Error = Error;
|
||||||
|
|
||||||
fn serialize_field<T: ?Sized>(&mut self, _name: &'static str, value: &T) -> Result<(), D>
|
fn serialize_field<T: ?Sized>(&mut self, _name: &'static str, value: &T) -> Result<()>
|
||||||
where T: Serialize
|
where T: Serialize
|
||||||
{
|
{
|
||||||
self.push(to_value(value)?)
|
self.push(to_value(value))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok, D> {
|
fn end(self) -> Result<Self::Ok> {
|
||||||
self.finish()
|
self.finish()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTuple for SerializeRecord<N, D> {
|
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTuple for SerializeRecord<N, D> {
|
||||||
type Ok = N;
|
type Ok = N;
|
||||||
type Error = Error<D>;
|
type Error = Error;
|
||||||
|
|
||||||
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), D> where T: Serialize {
|
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
||||||
self.push(to_value(value)?)
|
self.push(to_value(value))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok, D> {
|
fn end(self) -> Result<Self::Ok> {
|
||||||
self.finish()
|
self.finish()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleStruct for SerializeRecord<N, D> {
|
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleStruct for SerializeRecord<N, D> {
|
||||||
type Ok = N;
|
type Ok = N;
|
||||||
type Error = Error<D>;
|
type Error = Error;
|
||||||
|
|
||||||
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), D> where T: Serialize {
|
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
||||||
self.push(to_value(value)?)
|
self.push(to_value(value))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok, D> {
|
fn end(self) -> Result<Self::Ok> {
|
||||||
self.finish()
|
self.finish()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleVariant for SerializeRecord<N, D> {
|
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleVariant for SerializeRecord<N, D> {
|
||||||
type Ok = N;
|
type Ok = N;
|
||||||
type Error = Error<D>;
|
type Error = Error;
|
||||||
|
|
||||||
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), D> where T: Serialize {
|
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
||||||
self.push(to_value(value)?)
|
self.push(to_value(value))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok, D> {
|
fn end(self) -> Result<Self::Ok> {
|
||||||
self.finish()
|
self.finish()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeSeq for SerializeSequence<N, D> {
|
impl<N: NestedValue<D>, D: Domain> serde::ser::SerializeSeq for SerializeSequence<N, D> {
|
||||||
type Ok = N;
|
type Ok = N;
|
||||||
type Error = Error<D>;
|
type Error = Error;
|
||||||
|
|
||||||
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), D> where T: Serialize {
|
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()> where T: Serialize {
|
||||||
self.vec.push(to_value(value)?);
|
self.vec.push(to_value(value));
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok, D> {
|
fn end(self) -> Result<Self::Ok> {
|
||||||
Ok(Value::from(self.vec).wrap())
|
Ok(Value::from(self.vec).wrap())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn to_value<T, N, D: Domain>(value: T) -> Result<N, D> where T: Serialize, N: NestedValue<D> {
|
pub fn to_value<T, N, D: Domain>(value: T) -> N where T: Serialize, N: NestedValue<D> {
|
||||||
value.serialize(Serializer{ phantom: PhantomData })
|
value.serialize(Serializer{ phantom: PhantomData }).unwrap()
|
||||||
}
|
}
|
||||||
|
|
Loading…
Reference in New Issue