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 => Ok(Unknown(v.to_owned())),
200        }
201    }
202}
203impl std::fmt::Display for PersonRaceDetailsRace {
204    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
205        f.write_str(self.as_str())
206    }
207}
208
209impl std::fmt::Debug for PersonRaceDetailsRace {
210    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
211        f.write_str(self.as_str())
212    }
213}
214#[cfg(feature = "serialize")]
215impl serde::Serialize for PersonRaceDetailsRace {
216    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
217    where
218        S: serde::Serializer,
219    {
220        serializer.serialize_str(self.as_str())
221    }
222}
223impl miniserde::Deserialize for PersonRaceDetailsRace {
224    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
225        crate::Place::new(out)
226    }
227}
228
229impl miniserde::de::Visitor for crate::Place<PersonRaceDetailsRace> {
230    fn string(&mut self, s: &str) -> miniserde::Result<()> {
231        use std::str::FromStr;
232        self.out = Some(PersonRaceDetailsRace::from_str(s).unwrap());
233        Ok(())
234    }
235}
236
237stripe_types::impl_from_val_with_from_str!(PersonRaceDetailsRace);
238#[cfg(feature = "deserialize")]
239impl<'de> serde::Deserialize<'de> for PersonRaceDetailsRace {
240    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
241        use std::str::FromStr;
242        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
243        Ok(Self::from_str(&s).unwrap())
244    }
245}
stripe_shared/person_race_details.rs

stripe_shared/
person_race_details.rs
