stripe_shared/
person_race_details.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct PersonRaceDetails {
5    /// The persons race.
6    pub race: Option<Vec<PersonRaceDetailsRace>>,
7    /// Please specify your race, when other is selected.
8    pub race_other: Option<String>,
9}
10#[doc(hidden)]
11pub struct PersonRaceDetailsBuilder {
12    race: Option<Option<Vec<PersonRaceDetailsRace>>>,
13    race_other: Option<Option<String>>,
14}
15
16#[allow(
17    unused_variables,
18    irrefutable_let_patterns,
19    clippy::let_unit_value,
20    clippy::match_single_binding,
21    clippy::single_match
22)]
23const _: () = {
24    use miniserde::de::{Map, Visitor};
25    use miniserde::json::Value;
26    use miniserde::{Deserialize, Result, make_place};
27    use stripe_types::miniserde_helpers::FromValueOpt;
28    use stripe_types::{MapBuilder, ObjectDeser};
29
30    make_place!(Place);
31
32    impl Deserialize for PersonRaceDetails {
33        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
34            Place::new(out)
35        }
36    }
37
38    struct Builder<'a> {
39        out: &'a mut Option<PersonRaceDetails>,
40        builder: PersonRaceDetailsBuilder,
41    }
42
43    impl Visitor for Place<PersonRaceDetails> {
44        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
45            Ok(Box::new(Builder {
46                out: &mut self.out,
47                builder: PersonRaceDetailsBuilder::deser_default(),
48            }))
49        }
50    }
51
52    impl MapBuilder for PersonRaceDetailsBuilder {
53        type Out = PersonRaceDetails;
54        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
55            Ok(match k {
56                "race" => Deserialize::begin(&mut self.race),
57                "race_other" => Deserialize::begin(&mut self.race_other),
58                _ => <dyn Visitor>::ignore(),
59            })
60        }
61
62        fn deser_default() -> Self {
63            Self { race: Deserialize::default(), race_other: Deserialize::default() }
64        }
65
66        fn take_out(&mut self) -> Option<Self::Out> {
67            let (Some(race), Some(race_other)) = (self.race.take(), self.race_other.take()) else {
68                return None;
69            };
70            Some(Self::Out { race, race_other })
71        }
72    }
73
74    impl Map for Builder<'_> {
75        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
76            self.builder.key(k)
77        }
78
79        fn finish(&mut self) -> Result<()> {
80            *self.out = self.builder.take_out();
81            Ok(())
82        }
83    }
84
85    impl ObjectDeser for PersonRaceDetails {
86        type Builder = PersonRaceDetailsBuilder;
87    }
88
89    impl FromValueOpt for PersonRaceDetails {
90        fn from_value(v: Value) -> Option<Self> {
91            let Value::Object(obj) = v else {
92                return None;
93            };
94            let mut b = PersonRaceDetailsBuilder::deser_default();
95            for (k, v) in obj {
96                match k.as_str() {
97                    "race" => b.race = FromValueOpt::from_value(v),
98                    "race_other" => b.race_other = FromValueOpt::from_value(v),
99                    _ => {}
100                }
101            }
102            b.take_out()
103        }
104    }
105};
106/// The persons race.
107#[derive(Clone, Eq, PartialEq)]
108#[non_exhaustive]
109pub enum PersonRaceDetailsRace {
110    AfricanAmerican,
111    AmericanIndianOrAlaskaNative,
112    Asian,
113    AsianIndian,
114    BlackOrAfricanAmerican,
115    Chinese,
116    Ethiopian,
117    Filipino,
118    GuamanianOrChamorro,
119    Haitian,
120    Jamaican,
121    Japanese,
122    Korean,
123    NativeHawaiian,
124    NativeHawaiianOrOtherPacificIslander,
125    Nigerian,
126    OtherAsian,
127    OtherBlackOrAfricanAmerican,
128    OtherPacificIslander,
129    PreferNotToAnswer,
130    Samoan,
131    Somali,
132    Vietnamese,
133    White,
134    /// An unrecognized value from Stripe. Should not be used as a request parameter.
135    Unknown(String),
136}
137impl PersonRaceDetailsRace {
138    pub fn as_str(&self) -> &str {
139        use PersonRaceDetailsRace::*;
140        match self {
141            AfricanAmerican => "african_american",
142            AmericanIndianOrAlaskaNative => "american_indian_or_alaska_native",
143            Asian => "asian",
144            AsianIndian => "asian_indian",
145            BlackOrAfricanAmerican => "black_or_african_american",
146            Chinese => "chinese",
147            Ethiopian => "ethiopian",
148            Filipino => "filipino",
149            GuamanianOrChamorro => "guamanian_or_chamorro",
150            Haitian => "haitian",
151            Jamaican => "jamaican",
152            Japanese => "japanese",
153            Korean => "korean",
154            NativeHawaiian => "native_hawaiian",
155            NativeHawaiianOrOtherPacificIslander => "native_hawaiian_or_other_pacific_islander",
156            Nigerian => "nigerian",
157            OtherAsian => "other_asian",
158            OtherBlackOrAfricanAmerican => "other_black_or_african_american",
159            OtherPacificIslander => "other_pacific_islander",
160            PreferNotToAnswer => "prefer_not_to_answer",
161            Samoan => "samoan",
162            Somali => "somali",
163            Vietnamese => "vietnamese",
164            White => "white",
165            Unknown(v) => v,
166        }
167    }
168}
169
170impl std::str::FromStr for PersonRaceDetailsRace {
171    type Err = std::convert::Infallible;
172    fn from_str(s: &str) -> Result<Self, Self::Err> {
173        use PersonRaceDetailsRace::*;
174        match s {
175            "african_american" => Ok(AfricanAmerican),
176            "american_indian_or_alaska_native" => Ok(AmericanIndianOrAlaskaNative),
177            "asian" => Ok(Asian),
178            "asian_indian" => Ok(AsianIndian),
179            "black_or_african_american" => Ok(BlackOrAfricanAmerican),
180            "chinese" => Ok(Chinese),
181            "ethiopian" => Ok(Ethiopian),
182            "filipino" => Ok(Filipino),
183            "guamanian_or_chamorro" => Ok(GuamanianOrChamorro),
184            "haitian" => Ok(Haitian),
185            "jamaican" => Ok(Jamaican),
186            "japanese" => Ok(Japanese),
187            "korean" => Ok(Korean),
188            "native_hawaiian" => Ok(NativeHawaiian),
189            "native_hawaiian_or_other_pacific_islander" => Ok(NativeHawaiianOrOtherPacificIslander),
190            "nigerian" => Ok(Nigerian),
191            "other_asian" => Ok(OtherAsian),
192            "other_black_or_african_american" => Ok(OtherBlackOrAfricanAmerican),
193            "other_pacific_islander" => Ok(OtherPacificIslander),
194            "prefer_not_to_answer" => Ok(PreferNotToAnswer),
195            "samoan" => Ok(Samoan),
196            "somali" => Ok(Somali),
197            "vietnamese" => Ok(Vietnamese),
198            "white" => Ok(White),
199            v => {
200                tracing::warn!("Unknown value '{}' for enum '{}'", v, "PersonRaceDetailsRace");
201                Ok(Unknown(v.to_owned()))
202            }
203        }
204    }
205}
206impl std::fmt::Display for PersonRaceDetailsRace {
207    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
208        f.write_str(self.as_str())
209    }
210}
211
212impl std::fmt::Debug for PersonRaceDetailsRace {
213    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
214        f.write_str(self.as_str())
215    }
216}
217#[cfg(feature = "serialize")]
218impl serde::Serialize for PersonRaceDetailsRace {
219    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
220    where
221        S: serde::Serializer,
222    {
223        serializer.serialize_str(self.as_str())
224    }
225}
226impl miniserde::Deserialize for PersonRaceDetailsRace {
227    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
228        crate::Place::new(out)
229    }
230}
231
232impl miniserde::de::Visitor for crate::Place<PersonRaceDetailsRace> {
233    fn string(&mut self, s: &str) -> miniserde::Result<()> {
234        use std::str::FromStr;
235        self.out = Some(PersonRaceDetailsRace::from_str(s).expect("infallible"));
236        Ok(())
237    }
238}
239
240stripe_types::impl_from_val_with_from_str!(PersonRaceDetailsRace);
241#[cfg(feature = "deserialize")]
242impl<'de> serde::Deserialize<'de> for PersonRaceDetailsRace {
243    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
244        use std::str::FromStr;
245        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
246        Ok(Self::from_str(&s).expect("infallible"))
247    }
248}
stripe_shared/person_race_details.rs

stripe_shared/
person_race_details.rs
