chris/ruwuma
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use void for the unreachable serializers

Browse Source
This commit is contained in:
Anthony Ramine 2017-01-28 23:52:52 +01:00
parent fa8fb69da0
commit e140c2b5c5
6 changed files with 198 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.toml
View File

@ -14,3 +14,4 @@ test = false
[dependencies]
serde = "0.9.2"
url = "1.0.0"
void = "1.0.2"

1
src/lib.rs
View File

@ -3,6 +3,7 @@
#[macro_use]
extern crate serde;
extern crate url;
extern crate void;
pub mod de;
pub mod ser;

36
src/ser/mod.rs
View File

@ -4,12 +4,12 @@ mod key;
mod pair;
mod part;
mod value;
mod void;
use serde::ser;
use std::borrow::Cow;
use std::error;
use std::fmt;
use std::marker::PhantomData;
use std::str;
use url::form_urlencoded::Serializer as UrlEncodedSerializer;
use url::form_urlencoded::Target as UrlEncodedTarget;
@ -102,21 +102,21 @@ pub struct SeqSerializer<'output, Target: 'output + UrlEncodedTarget> {
///
/// Never instantiated, tuples are not supported at top-level.
pub struct TupleSerializer<'output, T: 'output + UrlEncodedTarget> {
_marker: PhantomData<&'output T>,
inner: void::VoidSerializer<&'output mut UrlEncodedSerializer<T>>,
}
/// Tuple struct serializer.
///
/// Never instantiated, tuple structs are not supported.
pub struct TupleStructSerializer<'output, T: 'output + UrlEncodedTarget> {
_marker: PhantomData<&'output T>,
inner: void::VoidSerializer<&'output mut UrlEncodedSerializer<T>>,
}
/// Tuple variant serializer.
///
/// Never instantiated, tuple variants are not supported.
pub struct TupleVariantSerializer<'output, T: 'output + UrlEncodedTarget> {
_marker: PhantomData<&'output T>,
inner: void::VoidSerializer<&'output mut UrlEncodedSerializer<T>>,
}
/// Map serializer.
@ -134,7 +134,7 @@ pub struct StructSerializer<'output, Target: 'output + UrlEncodedTarget> {
///
/// Never instantiated, struct variants are not supported.
pub struct StructVariantSerializer<'output, T: 'output + UrlEncodedTarget> {
_marker: PhantomData<&'output T>,
inner: void::VoidSerializer<&'output mut UrlEncodedSerializer<T>>,
}
impl<'output, Target> ser::Serializer for Serializer<'output, Target>
@ -368,13 +368,13 @@ impl<'output, Target> ser::SerializeTuple for TupleSerializer<'output, Target>
type Error = Error;
fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
_value: &T)
value: &T)
-> Result<(), Error> {
unreachable!()
self.inner.serialize_element(value)
}
fn end(self) -> Result<Self::Ok, Error> {
unreachable!()
self.inner.end()
}
}
@ -386,13 +386,13 @@ impl<'output, Target> ser::SerializeTupleStruct
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
_value: &T)
value: &T)
-> Result<(), Error> {
unreachable!()
self.inner.serialize_field(value)
}
fn end(self) -> Result<Self::Ok, Error> {
unreachable!()
self.inner.end()
}
}
@ -404,13 +404,13 @@ impl<'output, Target> ser::SerializeTupleVariant
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
_value: &T)
value: &T)
-> Result<(), Error> {
unreachable!()
self.inner.serialize_field(value)
}
fn end(self) -> Result<Self::Ok, Error> {
unreachable!()
self.inner.end()
}
}
@ -488,14 +488,14 @@ impl<'output, Target> ser::SerializeStructVariant
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
_key: &'static str,
_value: &T)
key: &'static str,
value: &T)
-> Result<(), Error> {
unreachable!()
self.inner.serialize_field(key, value)
}
fn end(self) -> Result<Self::Ok, Error> {
unreachable!()
self.inner.end()
}
}

146
src/ser/pair.rs
View File

@ -2,6 +2,7 @@ use ser::Error;
use ser::key::KeySink;
use ser::part::PartSerializer;
use ser::value::ValueSink;
use ser::void::VoidSerializer;
use serde::ser;
use std::borrow::Cow;
use std::mem;
@ -29,13 +30,13 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
{
type Ok = ();
type Error = Error;
type SerializeSeq = Self;
type SerializeSeq = VoidSerializer<()>;
type SerializeTuple = Self;
type SerializeTupleStruct = Self;
type SerializeTupleVariant = Self;
type SerializeMap = Self;
type SerializeStruct = Self;
type SerializeStructVariant = Self;
type SerializeTupleStruct = VoidSerializer<()>;
type SerializeTupleVariant = VoidSerializer<()>;
type SerializeMap = VoidSerializer<()>;
type SerializeStruct = VoidSerializer<()>;
type SerializeStructVariant = VoidSerializer<()>;
fn serialize_bool(self, _v: bool) -> Result<(), Error> {
Err(Error::unsupported_pair())
@ -137,11 +138,15 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
value.serialize(self)
}
fn serialize_seq(self, _len: Option<usize>) -> Result<Self, Error> {
fn serialize_seq(self,
_len: Option<usize>)
-> Result<VoidSerializer<()>, Error> {
Err(Error::unsupported_pair())
}
fn serialize_seq_fixed_size(self, _len: usize) -> Result<Self, Error> {
fn serialize_seq_fixed_size(self,
_len: usize)
-> Result<VoidSerializer<()>, Error> {
Err(Error::unsupported_pair())
}
@ -156,7 +161,7 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
fn serialize_tuple_struct(self,
_name: &'static str,
_len: usize)
-> Result<Self, Error> {
-> Result<VoidSerializer<()>, Error> {
Err(Error::unsupported_pair())
}
@ -165,18 +170,20 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
_variant_index: usize,
_variant: &'static str,
_len: usize)
-> Result<Self, Error> {
-> Result<VoidSerializer<()>, Error> {
Err(Error::unsupported_pair())
}
fn serialize_map(self, _len: Option<usize>) -> Result<Self, Error> {
fn serialize_map(self,
_len: Option<usize>)
-> Result<VoidSerializer<()>, Error> {
Err(Error::unsupported_pair())
}
fn serialize_struct(self,
_name: &'static str,
_len: usize)
-> Result<Self, Error> {
-> Result<VoidSerializer<()>, Error> {
Err(Error::unsupported_pair())
}
@ -185,28 +192,11 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
_variant_index: usize,
_variant: &'static str,
_len: usize)
-> Result<Self, Error> {
-> Result<VoidSerializer<()>, Error> {
Err(Error::unsupported_pair())
}
}
impl<'target, Target> ser::SerializeSeq for PairSerializer<'target, Target>
where Target: 'target + UrlEncodedTarget,
{
type Ok = ();
type Error = Error;
fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
_value: &T)
-> Result<(), Error> {
unreachable!()
}
fn end(self) -> Result<(), Error> {
unreachable!()
}
}
impl<'target, Target> ser::SerializeTuple for PairSerializer<'target, Target>
where Target: 'target + UrlEncodedTarget,
{
@ -251,102 +241,6 @@ impl<'target, Target> ser::SerializeTuple for PairSerializer<'target, Target>
}
}
impl<'target, Target> ser::SerializeTupleStruct
for PairSerializer<'target, Target>
where Target: 'target + UrlEncodedTarget,
{
type Ok = ();
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
_value: &T)
-> Result<(), Error> {
unreachable!()
}
fn end(self) -> Result<(), Error> {
unreachable!()
}
}
impl<'target, Target> ser::SerializeTupleVariant
for PairSerializer<'target, Target>
where Target: 'target + UrlEncodedTarget,
{
type Ok = ();
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
_value: &T)
-> Result<(), Error> {
unreachable!()
}
fn end(self) -> Result<(), Error> {
unreachable!()
}
}
impl<'target, Target> ser::SerializeMap for PairSerializer<'target, Target>
where Target: 'target + UrlEncodedTarget,
{
type Ok = ();
type Error = Error;
fn serialize_key<T: ?Sized + ser::Serialize>(&mut self,
_key: &T)
-> Result<(), Error> {
unreachable!()
}
fn serialize_value<T: ?Sized + ser::Serialize>(&mut self,
_value: &T)
-> Result<(), Error> {
unreachable!()
}
fn end(self) -> Result<(), Error> {
unreachable!()
}
}
impl<'target, Target> ser::SerializeStruct for PairSerializer<'target, Target>
where Target: 'target + UrlEncodedTarget,
{
type Ok = ();
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
_key: &'static str,
_value: &T)
-> Result<(), Error> {
unreachable!()
}
fn end(self) -> Result<(), Error> {
unreachable!()
}
}
impl<'target, Target> ser::SerializeStructVariant
for PairSerializer<'target, Target>
where Target: 'target + UrlEncodedTarget,
{
type Ok = ();
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
_key: &'static str,
_value: &T)
-> Result<(), Error> {
unreachable!()
}
fn end(self) -> Result<(), Error> {
unreachable!()
}
}
enum PairState {
WaitingForKey,
WaitingForValue { key: Cow<'static, str> },

174
src/ser/part.rs
View File

@ -1,4 +1,5 @@
use ser::Error;
use ser::void::VoidSerializer;
use serde::ser;
use std::str;
@ -36,13 +37,13 @@ pub trait Sink: Sized {
impl<S: Sink> ser::Serializer for PartSerializer<S> {
type Ok = S::Ok;
type Error = Error;
type SerializeSeq = Self;
type SerializeTuple = Self;
type SerializeTupleStruct = Self;
type SerializeTupleVariant = Self;
type SerializeMap = Self;
type SerializeStruct = Self;
type SerializeStructVariant = Self;
type SerializeSeq = VoidSerializer<S::Ok>;
type SerializeTuple = VoidSerializer<S::Ok>;
type SerializeTupleStruct = VoidSerializer<S::Ok>;
type SerializeTupleVariant = VoidSerializer<S::Ok>;
type SerializeMap = VoidSerializer<S::Ok>;
type SerializeStruct = VoidSerializer<S::Ok>;
type SerializeStructVariant = VoidSerializer<S::Ok>;
fn serialize_bool(self, v: bool) -> Result<S::Ok, Error> {
self.sink.serialize_bool(v)
@ -147,165 +148,62 @@ impl<S: Sink> ser::Serializer for PartSerializer<S> {
self.sink.serialize_some(value)
}
fn serialize_seq(self, _len: Option<usize>) -> Result<Self, Error> {
fn serialize_seq(self,
_len: Option<usize>)
-> Result<Self::SerializeSeq, Error> {
Err(self.sink.unsupported())
}
fn serialize_seq_fixed_size(self, _len: usize) -> Result<Self, Error> {
fn serialize_seq_fixed_size(self,
_len: usize)
-> Result<Self::SerializeSeq, Error> {
Err(self.sink.unsupported())
}
fn serialize_tuple(self, _len: usize) -> Result<Self, Error> {
fn serialize_tuple(self,
_len: usize)
-> Result<Self::SerializeTuple, Error> {
Err(self.sink.unsupported())
}
fn serialize_tuple_struct(self,
_name: &'static str,
_len: usize)
-> Result<Self, Error> {
-> Result<Self::SerializeTuple, Error> {
Err(self.sink.unsupported())
}
fn serialize_tuple_variant(self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
_len: usize)
-> Result<Self, Error> {
fn serialize_tuple_variant
(self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
_len: usize)
-> Result<Self::SerializeTupleVariant, Error> {
Err(self.sink.unsupported())
}
fn serialize_map(self, _len: Option<usize>) -> Result<Self, Error> {
fn serialize_map(self,
_len: Option<usize>)
-> Result<Self::SerializeMap, Error> {
Err(self.sink.unsupported())
}
fn serialize_struct(self,
_name: &'static str,
_len: usize)
-> Result<Self, Error> {
-> Result<Self::SerializeStruct, Error> {
Err(self.sink.unsupported())
}
fn serialize_struct_variant(self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
_len: usize)
-> Result<Self, Error> {
fn serialize_struct_variant
(self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
_len: usize)
-> Result<Self::SerializeStructVariant, Error> {
Err(self.sink.unsupported())
}
}
impl<S: Sink> ser::SerializeSeq for PartSerializer<S> {
type Ok = S::Ok;
type Error = Error;
fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
_value: &T)
-> Result<(), Error> {
unreachable!()
}
fn end(self) -> Result<S::Ok, Error> {
unreachable!()
}
}
impl<S: Sink> ser::SerializeTuple for PartSerializer<S> {
type Ok = S::Ok;
type Error = Error;
fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
_value: &T)
-> Result<(), Error> {
unreachable!()
}
fn end(self) -> Result<S::Ok, Error> {
unreachable!()
}
}
impl<S: Sink> ser::SerializeTupleStruct for PartSerializer<S> {
type Ok = S::Ok;
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
_value: &T)
-> Result<(), Error> {
unreachable!()
}
fn end(self) -> Result<S::Ok, Error> {
unreachable!()
}
}
impl<S: Sink> ser::SerializeTupleVariant for PartSerializer<S> {
type Ok = S::Ok;
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
_value: &T)
-> Result<(), Error> {
unreachable!()
}
fn end(self) -> Result<S::Ok, Error> {
unreachable!()
}
}
impl<S: Sink> ser::SerializeMap for PartSerializer<S> {
type Ok = S::Ok;
type Error = Error;
fn serialize_key<T: ?Sized + ser::Serialize>(&mut self,
_key: &T)
-> Result<(), Error> {
unreachable!()
}
fn serialize_value<T: ?Sized + ser::Serialize>(&mut self,
_value: &T)
-> Result<(), Error> {
unreachable!()
}
fn end(self) -> Result<S::Ok, Error> {
unreachable!()
}
}
impl<S: Sink> ser::SerializeStruct for PartSerializer<S> {
type Ok = S::Ok;
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
_key: &'static str,
_value: &T)
-> Result<(), Error> {
unreachable!()
}
fn end(self) -> Result<S::Ok, Error> {
unreachable!()
}
}
impl<S: Sink> ser::SerializeStructVariant for PartSerializer<S> {
type Ok = S::Ok;
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
_key: &'static str,
_value: &T)
-> Result<(), Error> {
unreachable!()
}
fn end(self) -> Result<S::Ok, Error> {
unreachable!()
}
}

122
src/ser/void.rs Normal file
View File

@ -0,0 +1,122 @@
use ser::Error;
use serde::ser;
use std::marker::PhantomData;
use void;
pub struct VoidSerializer<Ok> {
void: void::Void,
_marker: PhantomData<Ok>,
}
impl<Ok> ser::SerializeSeq for VoidSerializer<Ok> {
type Ok = Ok;
type Error = Error;
fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
_value: &T)
-> Result<(), Error> {
void::unreachable(self.void)
}
fn end(self) -> Result<Ok, Error> {
void::unreachable(self.void)
}
}
impl<Ok> ser::SerializeTuple for VoidSerializer<Ok> {
type Ok = Ok;
type Error = Error;
fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
_value: &T)
-> Result<(), Error> {
void::unreachable(self.void)
}
fn end(self) -> Result<Ok, Error> {
void::unreachable(self.void)
}
}
impl<Ok> ser::SerializeTupleStruct for VoidSerializer<Ok> {
type Ok = Ok;
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
_value: &T)
-> Result<(), Error> {
void::unreachable(self.void)
}
fn end(self) -> Result<Ok, Error> {
void::unreachable(self.void)
}
}
impl<Ok> ser::SerializeTupleVariant for VoidSerializer<Ok> {
type Ok = Ok;
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
_value: &T)
-> Result<(), Error> {
void::unreachable(self.void)
}
fn end(self) -> Result<Ok, Error> {
void::unreachable(self.void)
}
}
impl<Ok> ser::SerializeMap for VoidSerializer<Ok> {
type Ok = Ok;
type Error = Error;
fn serialize_key<T: ?Sized + ser::Serialize>(&mut self,
_key: &T)
-> Result<(), Error> {
void::unreachable(self.void)
}
fn serialize_value<T: ?Sized + ser::Serialize>(&mut self,
_value: &T)
-> Result<(), Error> {
void::unreachable(self.void)
}
fn end(self) -> Result<Ok, Error> {
void::unreachable(self.void)
}
}
impl<Ok> ser::SerializeStruct for VoidSerializer<Ok> {
type Ok = Ok;
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
_key: &'static str,
_value: &T)
-> Result<(), Error> {
void::unreachable(self.void)
}
fn end(self) -> Result<Ok, Error> {
void::unreachable(self.void)
}
}
impl<Ok> ser::SerializeStructVariant for VoidSerializer<Ok> {
type Ok = Ok;
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
_key: &'static str,
_value: &T)
-> Result<(), Error> {
void::unreachable(self.void)
}
fn end(self) -> Result<Ok, Error> {
void::unreachable(self.void)
}
}