schematic_types 0.11.5

Shapes and types for defining schemas for Rust types.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use crate::*;
use std::fmt;

#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
pub enum UnionOperator {
    #[default]
    AnyOf,
    OneOf,
}

#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
pub struct UnionType {
    #[cfg_attr(
        feature = "serde",
        serde(default, skip_serializing_if = "Option::is_none")
    )]
    pub default_index: Option<usize>,

    pub partial: bool,

    pub operator: UnionOperator,

    pub variants_types: Vec<Box<Schema>>,
}

impl UnionType {
    /// Create an "any of" union schema.
    pub fn new_any<I, V>(variants_types: I) -> Self
    where
        I: IntoIterator<Item = V>,
        V: Into<Schema>,
    {
        UnionType {
            variants_types: variants_types
                .into_iter()
                .map(|inner| Box::new(inner.into()))
                .collect(),
            ..UnionType::default()
        }
    }

    /// Create a "one of" union schema.
    pub fn new_one<I, V>(variants_types: I) -> Self
    where
        I: IntoIterator<Item = V>,
        V: Into<Schema>,
    {
        UnionType {
            operator: UnionOperator::OneOf,
            variants_types: variants_types
                .into_iter()
                .map(|inner| Box::new(inner.into()))
                .collect(),
            ..UnionType::default()
        }
    }

    pub fn has_null(&self) -> bool {
        self.variants_types.iter().any(|schema| schema.ty.is_null())
    }

    #[doc(hidden)]
    pub fn from_schemas<I, V>(variants_types: I, default_index: Option<usize>) -> Self
    where
        I: IntoIterator<Item = V>,
        V: Into<Schema>,
    {
        UnionType {
            default_index,
            variants_types: variants_types
                .into_iter()
                .map(|inner| Box::new(inner.into()))
                .collect(),
            ..UnionType::default()
        }
    }
}

impl fmt::Display for UnionType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{}",
            self.variants_types
                .iter()
                .map(|item| item.to_string())
                .collect::<Vec<_>>()
                .join(" | ")
        )
    }
}