stellar_xdr/generated/
claim_claimable_balance_result.rs

1#[allow(unused_imports, clippy::wildcard_imports)]
2use super::*;
3
4/// ClaimClaimableBalanceResult is an XDR Union defined as:
5///
6/// ```text
7/// union ClaimClaimableBalanceResult switch (ClaimClaimableBalanceResultCode code)
8/// {
9/// case CLAIM_CLAIMABLE_BALANCE_SUCCESS:
10///     void;
11/// case CLAIM_CLAIMABLE_BALANCE_DOES_NOT_EXIST:
12/// case CLAIM_CLAIMABLE_BALANCE_CANNOT_CLAIM:
13/// case CLAIM_CLAIMABLE_BALANCE_LINE_FULL:
14/// case CLAIM_CLAIMABLE_BALANCE_NO_TRUST:
15/// case CLAIM_CLAIMABLE_BALANCE_NOT_AUTHORIZED:
16/// case CLAIM_CLAIMABLE_BALANCE_TRUSTLINE_FROZEN:
17///     void;
18/// };
19/// ```
20///
21// union with discriminant ClaimClaimableBalanceResultCode
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 ClaimClaimableBalanceResult {
34    Success,
35    DoesNotExist,
36    CannotClaim,
37    LineFull,
38    NoTrust,
39    NotAuthorized,
40    TrustlineFrozen,
41}
42
43#[cfg(feature = "alloc")]
44impl Default for ClaimClaimableBalanceResult {
45    fn default() -> Self {
46        Self::Success
47    }
48}
49
50impl ClaimClaimableBalanceResult {
51    const _VARIANTS: &[ClaimClaimableBalanceResultCode] = &[
52        ClaimClaimableBalanceResultCode::Success,
53        ClaimClaimableBalanceResultCode::DoesNotExist,
54        ClaimClaimableBalanceResultCode::CannotClaim,
55        ClaimClaimableBalanceResultCode::LineFull,
56        ClaimClaimableBalanceResultCode::NoTrust,
57        ClaimClaimableBalanceResultCode::NotAuthorized,
58        ClaimClaimableBalanceResultCode::TrustlineFrozen,
59    ];
60    pub const VARIANTS: [ClaimClaimableBalanceResultCode; Self::_VARIANTS.len()] = {
61        let mut arr = [Self::_VARIANTS[0]; Self::_VARIANTS.len()];
62        let mut i = 1;
63        while i < Self::_VARIANTS.len() {
64            arr[i] = Self::_VARIANTS[i];
65            i += 1;
66        }
67        arr
68    };
69    const _VARIANTS_STR: &[&str] = &[
70        "Success",
71        "DoesNotExist",
72        "CannotClaim",
73        "LineFull",
74        "NoTrust",
75        "NotAuthorized",
76        "TrustlineFrozen",
77    ];
78    pub const VARIANTS_STR: [&'static str; Self::_VARIANTS_STR.len()] = {
79        let mut arr = [Self::_VARIANTS_STR[0]; Self::_VARIANTS_STR.len()];
80        let mut i = 1;
81        while i < Self::_VARIANTS_STR.len() {
82            arr[i] = Self::_VARIANTS_STR[i];
83            i += 1;
84        }
85        arr
86    };
87
88    #[must_use]
89    pub const fn name(&self) -> &'static str {
90        match self {
91            Self::Success => "Success",
92            Self::DoesNotExist => "DoesNotExist",
93            Self::CannotClaim => "CannotClaim",
94            Self::LineFull => "LineFull",
95            Self::NoTrust => "NoTrust",
96            Self::NotAuthorized => "NotAuthorized",
97            Self::TrustlineFrozen => "TrustlineFrozen",
98        }
99    }
100
101    #[must_use]
102    pub const fn discriminant(&self) -> ClaimClaimableBalanceResultCode {
103        #[allow(clippy::match_same_arms)]
104        match self {
105            Self::Success => ClaimClaimableBalanceResultCode::Success,
106            Self::DoesNotExist => ClaimClaimableBalanceResultCode::DoesNotExist,
107            Self::CannotClaim => ClaimClaimableBalanceResultCode::CannotClaim,
108            Self::LineFull => ClaimClaimableBalanceResultCode::LineFull,
109            Self::NoTrust => ClaimClaimableBalanceResultCode::NoTrust,
110            Self::NotAuthorized => ClaimClaimableBalanceResultCode::NotAuthorized,
111            Self::TrustlineFrozen => ClaimClaimableBalanceResultCode::TrustlineFrozen,
112        }
113    }
114
115    #[must_use]
116    pub const fn variants() -> [ClaimClaimableBalanceResultCode; Self::_VARIANTS.len()] {
117        Self::VARIANTS
118    }
119}
120
121impl Name for ClaimClaimableBalanceResult {
122    #[must_use]
123    fn name(&self) -> &'static str {
124        Self::name(self)
125    }
126}
127
128impl Discriminant<ClaimClaimableBalanceResultCode> for ClaimClaimableBalanceResult {
129    #[must_use]
130    fn discriminant(&self) -> ClaimClaimableBalanceResultCode {
131        Self::discriminant(self)
132    }
133}
134
135impl Variants<ClaimClaimableBalanceResultCode> for ClaimClaimableBalanceResult {
136    fn variants() -> slice::Iter<'static, ClaimClaimableBalanceResultCode> {
137        Self::VARIANTS.iter()
138    }
139}
140
141impl Union<ClaimClaimableBalanceResultCode> for ClaimClaimableBalanceResult {}
142
143impl ReadXdr for ClaimClaimableBalanceResult {
144    #[cfg(feature = "std")]
145    fn read_xdr<R: Read>(r: &mut Limited<R>) -> Result<Self, Error> {
146        r.with_limited_depth(|r| {
147            let dv: ClaimClaimableBalanceResultCode =
148                <ClaimClaimableBalanceResultCode as ReadXdr>::read_xdr(r)?;
149            #[allow(clippy::match_same_arms, clippy::match_wildcard_for_single_variants)]
150            let v = match dv {
151                ClaimClaimableBalanceResultCode::Success => Self::Success,
152                ClaimClaimableBalanceResultCode::DoesNotExist => Self::DoesNotExist,
153                ClaimClaimableBalanceResultCode::CannotClaim => Self::CannotClaim,
154                ClaimClaimableBalanceResultCode::LineFull => Self::LineFull,
155                ClaimClaimableBalanceResultCode::NoTrust => Self::NoTrust,
156                ClaimClaimableBalanceResultCode::NotAuthorized => Self::NotAuthorized,
157                ClaimClaimableBalanceResultCode::TrustlineFrozen => Self::TrustlineFrozen,
158                #[allow(unreachable_patterns)]
159                _ => return Err(Error::Invalid),
160            };
161            Ok(v)
162        })
163    }
164}
165
166impl WriteXdr for ClaimClaimableBalanceResult {
167    #[cfg(feature = "std")]
168    fn write_xdr<W: Write>(&self, w: &mut Limited<W>) -> Result<(), Error> {
169        w.with_limited_depth(|w| {
170            self.discriminant().write_xdr(w)?;
171            #[allow(clippy::match_same_arms)]
172            match self {
173                Self::Success => ().write_xdr(w)?,
174                Self::DoesNotExist => ().write_xdr(w)?,
175                Self::CannotClaim => ().write_xdr(w)?,
176                Self::LineFull => ().write_xdr(w)?,
177                Self::NoTrust => ().write_xdr(w)?,
178                Self::NotAuthorized => ().write_xdr(w)?,
179                Self::TrustlineFrozen => ().write_xdr(w)?,
180            };
181            Ok(())
182        })
183    }
184}
stellar_xdr/generated/claim_claimable_balance_result.rs

stellar_xdr/generated/
claim_claimable_balance_result.rs
