Enum Pattern

pub enum Pattern<'a> {
    Char(char),
    Str(&'a str),
    Pred(Box<dyn Fn(char) -> bool>),
    Multiple(Vec<Pattern<'a>>),
}

Pattern on which a string can be split.

Variants

Char(char)

Split on a matching char

Str(&'a str)

Split on a matching str

Pred(Box<dyn Fn(char) -> bool>)

Split if a char matches the predicate

Multiple(Vec<Pattern<'a>>)

Multiple patterns

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(vec![Pattern::Char('+'), Pattern::Char('-')]).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]);

Trait Implementations

impl<'a> From<&'a str> for Pattern<'a>

fn from(s: &'a str) -> Self

Converts to this type from the input type.

impl<'a, P> From<P> for Pattern<'a>

where P: Fn(char) -> bool + 'static,

fn from(pred: P) -> Self

Converts to this type from the input type.

impl<'a> From<Vec<Pattern<'a>>> for Pattern<'a>

fn from(patterns: Vec<Pattern<'a>>) -> Self

Converts to this type from the input type.

impl<'a> From<char> for Pattern<'a>

fn from(c: char) -> Self

Converts to this type from the input type.

impl<'a> FromIterator<&'a str> for Pattern<'a>

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = &'a str>,

Creates a value from an iterator.

impl<'a> FromIterator<Pattern<'a>> for Pattern<'a>

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(vec!['-', '+'].into_iter().collect::<Pattern>()).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]);

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = Pattern<'a>>,

Creates a value from an iterator.

impl<'a> FromIterator<char> for Pattern<'a>

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = char>,

Creates a value from an iterator.