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

stripe_shared/
person_race_details.rs
