stripe_shared/
reserve_transaction.rs1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
3pub struct ReserveTransaction {
4 pub amount: i64,
5 pub currency: stripe_types::Currency,
8 pub description: Option<String>,
10 pub id: stripe_shared::ReserveTransactionId,
12}
13#[doc(hidden)]
14pub struct ReserveTransactionBuilder {
15 amount: Option<i64>,
16 currency: Option<stripe_types::Currency>,
17 description: Option<Option<String>>,
18 id: Option<stripe_shared::ReserveTransactionId>,
19}
20
21#[allow(
22 unused_variables,
23 irrefutable_let_patterns,
24 clippy::let_unit_value,
25 clippy::match_single_binding,
26 clippy::single_match
27)]
28const _: () = {
29 use miniserde::de::{Map, Visitor};
30 use miniserde::json::Value;
31 use miniserde::{make_place, Deserialize, Result};
32 use stripe_types::miniserde_helpers::FromValueOpt;
33 use stripe_types::{MapBuilder, ObjectDeser};
34
35 make_place!(Place);
36
37 impl Deserialize for ReserveTransaction {
38 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
39 Place::new(out)
40 }
41 }
42
43 struct Builder<'a> {
44 out: &'a mut Option<ReserveTransaction>,
45 builder: ReserveTransactionBuilder,
46 }
47
48 impl Visitor for Place<ReserveTransaction> {
49 fn map(&mut self) -> Result<Box<dyn Map + '_>> {
50 Ok(Box::new(Builder {
51 out: &mut self.out,
52 builder: ReserveTransactionBuilder::deser_default(),
53 }))
54 }
55 }
56
57 impl MapBuilder for ReserveTransactionBuilder {
58 type Out = ReserveTransaction;
59 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
60 Ok(match k {
61 "amount" => Deserialize::begin(&mut self.amount),
62 "currency" => Deserialize::begin(&mut self.currency),
63 "description" => Deserialize::begin(&mut self.description),
64 "id" => Deserialize::begin(&mut self.id),
65
66 _ => <dyn Visitor>::ignore(),
67 })
68 }
69
70 fn deser_default() -> Self {
71 Self {
72 amount: Deserialize::default(),
73 currency: Deserialize::default(),
74 description: Deserialize::default(),
75 id: Deserialize::default(),
76 }
77 }
78
79 fn take_out(&mut self) -> Option<Self::Out> {
80 let (Some(amount), Some(currency), Some(description), Some(id)) =
81 (self.amount, self.currency, self.description.take(), self.id.take())
82 else {
83 return None;
84 };
85 Some(Self::Out { amount, currency, description, id })
86 }
87 }
88
89 impl<'a> Map for Builder<'a> {
90 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
91 self.builder.key(k)
92 }
93
94 fn finish(&mut self) -> Result<()> {
95 *self.out = self.builder.take_out();
96 Ok(())
97 }
98 }
99
100 impl ObjectDeser for ReserveTransaction {
101 type Builder = ReserveTransactionBuilder;
102 }
103
104 impl FromValueOpt for ReserveTransaction {
105 fn from_value(v: Value) -> Option<Self> {
106 let Value::Object(obj) = v else {
107 return None;
108 };
109 let mut b = ReserveTransactionBuilder::deser_default();
110 for (k, v) in obj {
111 match k.as_str() {
112 "amount" => b.amount = FromValueOpt::from_value(v),
113 "currency" => b.currency = FromValueOpt::from_value(v),
114 "description" => b.description = FromValueOpt::from_value(v),
115 "id" => b.id = FromValueOpt::from_value(v),
116
117 _ => {}
118 }
119 }
120 b.take_out()
121 }
122 }
123};
124#[cfg(feature = "serialize")]
125impl serde::Serialize for ReserveTransaction {
126 fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
127 use serde::ser::SerializeStruct;
128 let mut s = s.serialize_struct("ReserveTransaction", 5)?;
129 s.serialize_field("amount", &self.amount)?;
130 s.serialize_field("currency", &self.currency)?;
131 s.serialize_field("description", &self.description)?;
132 s.serialize_field("id", &self.id)?;
133
134 s.serialize_field("object", "reserve_transaction")?;
135 s.end()
136 }
137}
138impl stripe_types::Object for ReserveTransaction {
139 type Id = stripe_shared::ReserveTransactionId;
140 fn id(&self) -> &Self::Id {
141 &self.id
142 }
143
144 fn into_id(self) -> Self::Id {
145 self.id
146 }
147}
148stripe_types::def_id!(ReserveTransactionId);