stellar_xdr/generated/
create_claimable_balance_result.rs

1#[allow(unused_imports, clippy::wildcard_imports)]
2use super::*;
3
4/// CreateClaimableBalanceResult is an XDR Union defined as:
5///
6/// ```text
7/// union CreateClaimableBalanceResult switch (
8///     CreateClaimableBalanceResultCode code)
9/// {
10/// case CREATE_CLAIMABLE_BALANCE_SUCCESS:
11///     ClaimableBalanceID balanceID;
12/// case CREATE_CLAIMABLE_BALANCE_MALFORMED:
13/// case CREATE_CLAIMABLE_BALANCE_LOW_RESERVE:
14/// case CREATE_CLAIMABLE_BALANCE_NO_TRUST:
15/// case CREATE_CLAIMABLE_BALANCE_NOT_AUTHORIZED:
16/// case CREATE_CLAIMABLE_BALANCE_UNDERFUNDED:
17///     void;
18/// };
19/// ```
20///
21// union with discriminant CreateClaimableBalanceResultCode
22#[cfg_attr(feature = "serde", cfg_eval::cfg_eval)]
23#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
24#[cfg_attr(feature = "arbitrary", derive(Arbitrary))]
25#[cfg_attr(
26    all(feature = "serde", feature = "alloc"),
27    serde_with::serde_as,
28    derive(serde::Serialize, serde::Deserialize),
29    serde(rename_all = "snake_case")
30)]
31#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
32#[allow(clippy::large_enum_variant)]
33pub enum CreateClaimableBalanceResult {
34    Success(ClaimableBalanceId),
35    Malformed,
36    LowReserve,
37    NoTrust,
38    NotAuthorized,
39    Underfunded,
40}
41
42#[cfg(feature = "alloc")]
43impl Default for CreateClaimableBalanceResult {
44    fn default() -> Self {
45        Self::Success(ClaimableBalanceId::default())
46    }
47}
48
49impl CreateClaimableBalanceResult {
50    const _VARIANTS: &[CreateClaimableBalanceResultCode] = &[
51        CreateClaimableBalanceResultCode::Success,
52        CreateClaimableBalanceResultCode::Malformed,
53        CreateClaimableBalanceResultCode::LowReserve,
54        CreateClaimableBalanceResultCode::NoTrust,
55        CreateClaimableBalanceResultCode::NotAuthorized,
56        CreateClaimableBalanceResultCode::Underfunded,
57    ];
58    pub const VARIANTS: [CreateClaimableBalanceResultCode; Self::_VARIANTS.len()] = {
59        let mut arr = [Self::_VARIANTS[0]; Self::_VARIANTS.len()];
60        let mut i = 1;
61        while i < Self::_VARIANTS.len() {
62            arr[i] = Self::_VARIANTS[i];
63            i += 1;
64        }
65        arr
66    };
67    const _VARIANTS_STR: &[&str] = &[
68        "Success",
69        "Malformed",
70        "LowReserve",
71        "NoTrust",
72        "NotAuthorized",
73        "Underfunded",
74    ];
75    pub const VARIANTS_STR: [&'static str; Self::_VARIANTS_STR.len()] = {
76        let mut arr = [Self::_VARIANTS_STR[0]; Self::_VARIANTS_STR.len()];
77        let mut i = 1;
78        while i < Self::_VARIANTS_STR.len() {
79            arr[i] = Self::_VARIANTS_STR[i];
80            i += 1;
81        }
82        arr
83    };
84
85    #[must_use]
86    pub const fn name(&self) -> &'static str {
87        match self {
88            Self::Success(_) => "Success",
89            Self::Malformed => "Malformed",
90            Self::LowReserve => "LowReserve",
91            Self::NoTrust => "NoTrust",
92            Self::NotAuthorized => "NotAuthorized",
93            Self::Underfunded => "Underfunded",
94        }
95    }
96
97    #[must_use]
98    pub const fn discriminant(&self) -> CreateClaimableBalanceResultCode {
99        #[allow(clippy::match_same_arms)]
100        match self {
101            Self::Success(_) => CreateClaimableBalanceResultCode::Success,
102            Self::Malformed => CreateClaimableBalanceResultCode::Malformed,
103            Self::LowReserve => CreateClaimableBalanceResultCode::LowReserve,
104            Self::NoTrust => CreateClaimableBalanceResultCode::NoTrust,
105            Self::NotAuthorized => CreateClaimableBalanceResultCode::NotAuthorized,
106            Self::Underfunded => CreateClaimableBalanceResultCode::Underfunded,
107        }
108    }
109
110    #[must_use]
111    pub const fn variants() -> [CreateClaimableBalanceResultCode; Self::_VARIANTS.len()] {
112        Self::VARIANTS
113    }
114}
115
116impl Name for CreateClaimableBalanceResult {
117    #[must_use]
118    fn name(&self) -> &'static str {
119        Self::name(self)
120    }
121}
122
123impl Discriminant<CreateClaimableBalanceResultCode> for CreateClaimableBalanceResult {
124    #[must_use]
125    fn discriminant(&self) -> CreateClaimableBalanceResultCode {
126        Self::discriminant(self)
127    }
128}
129
130impl Variants<CreateClaimableBalanceResultCode> for CreateClaimableBalanceResult {
131    fn variants() -> slice::Iter<'static, CreateClaimableBalanceResultCode> {
132        Self::VARIANTS.iter()
133    }
134}
135
136impl Union<CreateClaimableBalanceResultCode> for CreateClaimableBalanceResult {}
137
138impl ReadXdr for CreateClaimableBalanceResult {
139    #[cfg(feature = "std")]
140    fn read_xdr<R: Read>(r: &mut Limited<R>) -> Result<Self, Error> {
141        r.with_limited_depth(|r| {
142            let dv: CreateClaimableBalanceResultCode =
143                <CreateClaimableBalanceResultCode as ReadXdr>::read_xdr(r)?;
144            #[allow(clippy::match_same_arms, clippy::match_wildcard_for_single_variants)]
145            let v = match dv {
146                CreateClaimableBalanceResultCode::Success => {
147                    Self::Success(ClaimableBalanceId::read_xdr(r)?)
148                }
149                CreateClaimableBalanceResultCode::Malformed => Self::Malformed,
150                CreateClaimableBalanceResultCode::LowReserve => Self::LowReserve,
151                CreateClaimableBalanceResultCode::NoTrust => Self::NoTrust,
152                CreateClaimableBalanceResultCode::NotAuthorized => Self::NotAuthorized,
153                CreateClaimableBalanceResultCode::Underfunded => Self::Underfunded,
154                #[allow(unreachable_patterns)]
155                _ => return Err(Error::Invalid),
156            };
157            Ok(v)
158        })
159    }
160}
161
162impl WriteXdr for CreateClaimableBalanceResult {
163    #[cfg(feature = "std")]
164    fn write_xdr<W: Write>(&self, w: &mut Limited<W>) -> Result<(), Error> {
165        w.with_limited_depth(|w| {
166            self.discriminant().write_xdr(w)?;
167            #[allow(clippy::match_same_arms)]
168            match self {
169                Self::Success(v) => v.write_xdr(w)?,
170                Self::Malformed => ().write_xdr(w)?,
171                Self::LowReserve => ().write_xdr(w)?,
172                Self::NoTrust => ().write_xdr(w)?,
173                Self::NotAuthorized => ().write_xdr(w)?,
174                Self::Underfunded => ().write_xdr(w)?,
175            };
176            Ok(())
177        })
178    }
179}
stellar_xdr/generated/create_claimable_balance_result.rs

stellar_xdr/generated/
create_claimable_balance_result.rs
