[−][src]Trait serde_test::Configure

pub trait Configure {
    fn readable(self) -> Readable<Self>
    where
        Self: Sized,
    { ... }

    fn compact(self) -> Compact<Self>
    where
        Self: Sized,
    { ... }
}
[−]

Trait to determine whether a value is represented in human-readable or compact form.

extern crate serde;
extern crate serde_test;

use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_test::{assert_tokens, Configure, Token};

#[derive(Debug, PartialEq)]
struct Example(u8, u8);

impl Serialize for Example {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        if serializer.is_human_readable() {
            format!("{}.{}", self.0, self.1).serialize(serializer)
        } else {
            (self.0, self.1).serialize(serializer)
        }
    }
}

impl<'de> Deserialize<'de> for Example {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        use serde::de::Error;
        if deserializer.is_human_readable() {
            let s = String::deserialize(deserializer)?;
            let parts: Vec<_> = s.split('.').collect();
            Ok(Example(
                parts[0].parse().map_err(D::Error::custom)?,
                parts[1].parse().map_err(D::Error::custom)?,
            ))
        } else {
            let (x, y) = Deserialize::deserialize(deserializer)?;
            Ok(Example(x, y))
        }
    }
}

fn main() {
    assert_tokens(
        &Example(1, 0).compact(),
        &[
            Token::Tuple { len: 2 },
            Token::U8(1),
            Token::U8(0),
            Token::TupleEnd,
        ],
    );
    assert_tokens(&Example(1, 0).readable(), &[Token::Str("1.0")]);
}

Provided Methods

[−]

Marks self as using is_human_readable == true

[−]

Marks self as using is_human_readable == false

Implementors

impl<T: ?Sized> Configure for T
[src]
[−]