Struct serde_aux::field_attributes::StringOrVecToVec

pub struct StringOrVecToVec<'a, T, E> { /* fields omitted */ }

Builder to create a parser, that parses a separated string or a vec into a vec.

Example:

use serde_aux::prelude::*;
use std::str::FromStr;

fn parser<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
where
    D: serde::Deserializer<'de>,
    T: FromStr + serde::Deserialize<'de> + 'static,
    <T as FromStr>::Err: std::fmt::Display,
{
    StringOrVecToVec::default().into_deserializer()(deserializer)
}

#[derive(serde::Serialize, serde::Deserialize, Debug)]
struct MyStruct {
    #[serde(deserialize_with = "parser")]
    list: Vec<i32>,
}

let s = r#" { "list": "1,2,3,4" } "#;
let a: MyStruct = serde_json::from_str(s).unwrap();
assert_eq!(&a.list, &[1, 2, 3, 4]);

let s = r#" { "list": [1,2,3,4] } "#;
let a: MyStruct = serde_json::from_str(s).unwrap();
assert_eq!(&a.list, &[1, 2, 3, 4]);

Implementations

impl<'a, 'de, T> StringOrVecToVec<'a, T, T::Err> where
    T: FromStr + Deserialize<'de> + 'static,
    <T as FromStr>::Err: Display, 

pub fn with_separator(separator: impl Into<Pattern<'a>>) -> Self

Create a StringOrVecToVec builder with a custom separator. T::from_str is used to parse the elements of the list.

Example:

use serde_aux::prelude::*;
use std::str::FromStr;

fn parser<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
where
    D: serde::Deserializer<'de>,
    T: FromStr + serde::Deserialize<'de> + 'static,
    <T as FromStr>::Err: std::fmt::Display,
{
    StringOrVecToVec::with_separator(|c| c == '-' || c == '+').into_deserializer()(deserializer)
}

#[derive(serde::Serialize, serde::Deserialize, Debug)]
struct MyStruct {
    #[serde(deserialize_with = "parser")]
    list: Vec<i32>,
}

let s = r#" { "list": "1-2+3-4" } "#;
let a: MyStruct = serde_json::from_str(s).unwrap();
assert_eq!(&a.list, &[1, 2, 3, 4]);

let s = r#" { "list": [1,2,3,4] } "#;
let a: MyStruct = serde_json::from_str(s).unwrap();
assert_eq!(&a.list, &[1, 2, 3, 4]);

impl<'a, T, E> StringOrVecToVec<'a, T, E>

pub fn new(
    separator: impl Into<Pattern<'a>>,
    parser: impl FnMut(&str) -> Result<T, E> + 'static
) -> Self

Create a deserializer with a custom separator and parsing function.

Example:

use serde_aux::prelude::*;
use std::str::FromStr;

fn parser<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
where
    D: serde::Deserializer<'de>,
    T: FromStr + serde::Deserialize<'de> + 'static,
    <T as FromStr>::Err: std::fmt::Display,
{
    StringOrVecToVec::new('-', |s| s.trim().parse()).into_deserializer()(deserializer)
}

#[derive(serde::Serialize, serde::Deserialize, Debug)]
struct MyStruct {
    #[serde(deserialize_with = "parser")]
    list: Vec<i32>,
}

let s = r#" { "list": "1 - 2    -  3-    4    " } "#;
let a: MyStruct = serde_json::from_str(s).unwrap();
assert_eq!(&a.list, &[1, 2, 3, 4]);

let s = r#" { "list": [1,2,3,4] } "#;
let a: MyStruct = serde_json::from_str(s).unwrap();
assert_eq!(&a.list, &[1, 2, 3, 4]);

pub fn with_parser(parser: impl FnMut(&str) -> Result<T, E> + 'static) -> Self

Create a deserializer with a custom parsing function. The input string will be separated on ,.

Example:

use serde_aux::prelude::*;
use std::str::FromStr;

fn parser<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
where
    D: serde::Deserializer<'de>,
    T: FromStr + serde::Deserialize<'de> + 'static,
    <T as FromStr>::Err: std::fmt::Display,
{
    StringOrVecToVec::with_parser(|s| s.trim().parse()).into_deserializer()(deserializer)
}

#[derive(serde::Serialize, serde::Deserialize, Debug)]
struct MyStruct {
    #[serde(deserialize_with = "parser")]
    list: Vec<i32>,
}

let s = r#" { "list": "1 , 2    ,  3,    4    " } "#;
let a: MyStruct = serde_json::from_str(s).unwrap();
assert_eq!(&a.list, &[1, 2, 3, 4]);

let s = r#" { "list": [1,2,3,4] } "#;
let a: MyStruct = serde_json::from_str(s).unwrap();
assert_eq!(&a.list, &[1, 2, 3, 4]);

pub fn into_deserializer<'de, D>(
    self
) -> impl FnMut(D) -> Result<Vec<T>, <D as Deserializer<'de>>::Error> where
    'a: 'de,
    D: Deserializer<'de>,
    T: Deserialize<'de>,
    E: Display, 

Creates the actual deserializer from this builder.

Trait Implementations

impl<'a, 'de, T> Default for StringOrVecToVec<'a, T, T::Err> where
    T: FromStr + Deserialize<'de> + 'static,
    <T as FromStr>::Err: Display, 

fn default() -> Self

Returns the “default value” for a type.