Struct UntaggedEnumVisitor

pub struct UntaggedEnumVisitor<'closure, 'de, Value> { /* private fields */ }

Implementations

impl<'closure, 'de, Value> UntaggedEnumVisitor<'closure, 'de, Value>

pub fn new() -> Self

pub fn expecting(self, expecting: impl Display + 'closure) -> Self

Provide a message stating what data this untagged enum expects to receive.

This is used in error messages when deserialization fails. The message should complete the sentence “This Visitor expects to receive …”, for example the message could be “an integer, or map containing the keys ‘min’ and ‘max’”. The message should not be capitalized and should not end with a period.

UntaggedEnumVisitor::new()
    .expecting(format_args!("a string or number between 0 and {max}"))
    /* ... */
    .deserialize(deserializer)

If expecting is not called, then UntaggedEnumVisitor constructs a default message based on the set of closures given to it.

// by default, this enum expects "a boolean, string, or map"
UntaggedEnumVisitor::new()
    .bool(|b| ...)
    .string(|s| ...)
    .map(|m| ...)
    .deserialize(deserializer)

pub fn bool( self, visit: impl FnOnce(bool) -> Result<Value, Error> + 'closure, ) -> Self

pub fn i8( self, visit: impl FnOnce(i8) -> Result<Value, Error> + 'closure, ) -> Self

pub fn i16( self, visit: impl FnOnce(i16) -> Result<Value, Error> + 'closure, ) -> Self

pub fn i32( self, visit: impl FnOnce(i32) -> Result<Value, Error> + 'closure, ) -> Self

pub fn i64( self, visit: impl FnOnce(i64) -> Result<Value, Error> + 'closure, ) -> Self

pub fn i128( self, visit: impl FnOnce(i128) -> Result<Value, Error> + 'closure, ) -> Self

pub fn u8( self, visit: impl FnOnce(u8) -> Result<Value, Error> + 'closure, ) -> Self

pub fn u16( self, visit: impl FnOnce(u16) -> Result<Value, Error> + 'closure, ) -> Self

pub fn u32( self, visit: impl FnOnce(u32) -> Result<Value, Error> + 'closure, ) -> Self

pub fn u64( self, visit: impl FnOnce(u64) -> Result<Value, Error> + 'closure, ) -> Self

pub fn u128( self, visit: impl FnOnce(u128) -> Result<Value, Error> + 'closure, ) -> Self

pub fn f32( self, visit: impl FnOnce(f32) -> Result<Value, Error> + 'closure, ) -> Self

pub fn f64( self, visit: impl FnOnce(f64) -> Result<Value, Error> + 'closure, ) -> Self

pub fn char( self, visit: impl FnOnce(char) -> Result<Value, Error> + 'closure, ) -> Self

pub fn string( self, visit: impl FnOnce(&str) -> Result<Value, Error> + 'closure, ) -> Self

pub fn borrowed_str( self, visit: impl FnOnce(&'de str) -> Result<Value, Error> + 'closure, ) -> Self

pub fn bytes( self, visit: impl FnOnce(&[u8]) -> Result<Value, Error> + 'closure, ) -> Self

pub fn borrowed_bytes( self, visit: impl FnOnce(&'de [u8]) -> Result<Value, Error> + 'closure, ) -> Self

pub fn byte_buf( self, visit: impl FnOnce(Vec<u8>) -> Result<Value, Error> + 'closure, ) -> Self

pub fn none( self, visit: impl FnOnce() -> Result<Value, Error> + 'closure, ) -> Self

pub fn unit( self, visit: impl FnOnce() -> Result<Value, Error> + 'closure, ) -> Self

pub fn seq( self, visit: impl for<'access> FnOnce(Seq<'access, 'de>) -> Result<Value, Error> + 'closure, ) -> Self

Deserialize a sequence. The argument implements serde::de::SeqAccess.

pub fn map( self, visit: impl for<'access> FnOnce(Map<'access, 'de>) -> Result<Value, Error> + 'closure, ) -> Self

Deserialize a key-value map. The argument implements serde::de::MapAccess.

use serde::de::MapAccess;
use serde_untagged::UntaggedEnumVisitor;
use std::collections::HashMap;

UntaggedEnumVisitor::new()
    .map(|mut map| {
        let mut hashmap = HashMap::new();
        while let Some(key) = map.next_key()? {
            let value = map.next_value()?;
            hashmap.insert(key, value);
        }
        Ok(hashmap)
    })
    .deserialize(deserializer)

If you need to inspect the contents of the map to decide how to deserialize, you can buffer it into some kind of Value and deserialize from there.

enum Response {
    // {"failure":"..."}
    Failure(String),
    // Anything else. {"ok":200}
    Success(serde_json::Value),
}

impl<'de> Deserialize<'de> for Response {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        UntaggedEnumVisitor::new()
            .map(|map| {
                let value: serde_json::Value = map.deserialize()?;
                if let Some(failure) = value["failure"].as_str() {
                    Ok(Response::Failure(failure.to_owned()))
                } else {
                    Ok(Response::Success(value))
                }
            })
            .deserialize(deserializer)
    }
}

pub fn deserialize<D>(self, deserializer: D) -> Result<Value, D::Error>

where D: Deserializer<'de>,

Trait Implementations

impl<'closure, 'de, Value> Visitor<'de> for UntaggedEnumVisitor<'closure, 'de, Value>

type Value = Value

The value produced by this visitor.

fn expecting(&self, formatter: &mut Formatter<'_>) -> Result

Format a message stating what data this Visitor expects to receive.

fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>

where E: Error,

The input contains a boolean.

fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>

where E: Error,

The input contains an i8.

fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>

where E: Error,

The input contains an i16.

fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>

where E: Error,

The input contains an i32.

fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>

where E: Error,

The input contains an i64.

fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>

where E: Error,

The input contains a i128.

fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>

where E: Error,

The input contains a u8.

fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>

where E: Error,

The input contains a u16.

fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>

where E: Error,

The input contains a u32.

fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>

where E: Error,

The input contains a u64.

fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>

where E: Error,

The input contains a u128.

fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>

where E: Error,

The input contains an f32.

fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>

where E: Error,

The input contains an f64.

fn visit_char<E>(self, v: char) -> Result<Self::Value, E>

where E: Error,

The input contains a char.

fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>

where E: Error,

The input contains a string. The lifetime of the string is ephemeral and it may be destroyed after this method returns.

fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>

where E: Error,

The input contains a string that lives at least as long as the Deserializer.

fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>

where E: Error,

The input contains a byte array. The lifetime of the byte array is ephemeral and it may be destroyed after this method returns.

fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>

where E: Error,

The input contains a byte array that lives at least as long as the Deserializer.

fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>

where E: Error,

The input contains a byte array and ownership of the byte array is being given to the Visitor.

fn visit_none<E>(self) -> Result<Self::Value, E>

where E: Error,

The input contains an optional that is absent.

fn visit_unit<E>(self) -> Result<Self::Value, E>

where E: Error,

The input contains a unit ().

fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>

where A: SeqAccess<'de>,

The input contains a sequence of elements.

fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>

where A: MapAccess<'de>,

The input contains a key-value map.

fn visit_string<E>(self, v: String) -> Result<Self::Value, E>

where E: Error,

The input contains a string and ownership of the string is being given to the Visitor.

fn visit_some<D>( self, deserializer: D, ) -> Result<Self::Value, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

The input contains an optional that is present.

fn visit_newtype_struct<D>( self, deserializer: D, ) -> Result<Self::Value, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

The input contains a newtype struct.

fn visit_enum<A>( self, data: A, ) -> Result<Self::Value, <A as EnumAccess<'de>>::Error>

where A: EnumAccess<'de>,

The input contains an enum.