stellar_xdr/generated/
set_trust_line_flags_result_code.rs

1#[allow(unused_imports, clippy::wildcard_imports)]
2use super::*;
3
4/// SetTrustLineFlagsResultCode is an XDR Enum defined as:
5///
6/// ```text
7/// enum SetTrustLineFlagsResultCode
8/// {
9///     // codes considered as "success" for the operation
10///     SET_TRUST_LINE_FLAGS_SUCCESS = 0,
11///
12///     // codes considered as "failure" for the operation
13///     SET_TRUST_LINE_FLAGS_MALFORMED = -1,
14///     SET_TRUST_LINE_FLAGS_NO_TRUST_LINE = -2,
15///     SET_TRUST_LINE_FLAGS_CANT_REVOKE = -3,
16///     SET_TRUST_LINE_FLAGS_INVALID_STATE = -4,
17///     SET_TRUST_LINE_FLAGS_LOW_RESERVE = -5 // claimable balances can't be created
18///                                           // on revoke due to low reserves
19/// };
20/// ```
21///
22// enum
23#[cfg_attr(feature = "alloc", derive(Default))]
24#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
25#[cfg_attr(feature = "arbitrary", derive(Arbitrary))]
26#[cfg_attr(
27    all(feature = "serde", feature = "alloc"),
28    derive(serde::Serialize, serde::Deserialize),
29    serde(rename_all = "snake_case")
30)]
31#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
32#[repr(i32)]
33pub enum SetTrustLineFlagsResultCode {
34    #[cfg_attr(feature = "alloc", default)]
35    Success = 0,
36    Malformed = -1,
37    NoTrustLine = -2,
38    CantRevoke = -3,
39    InvalidState = -4,
40    LowReserve = -5,
41}
42
43impl SetTrustLineFlagsResultCode {
44    const _VARIANTS: &[SetTrustLineFlagsResultCode] = &[
45        SetTrustLineFlagsResultCode::Success,
46        SetTrustLineFlagsResultCode::Malformed,
47        SetTrustLineFlagsResultCode::NoTrustLine,
48        SetTrustLineFlagsResultCode::CantRevoke,
49        SetTrustLineFlagsResultCode::InvalidState,
50        SetTrustLineFlagsResultCode::LowReserve,
51    ];
52    pub const VARIANTS: [SetTrustLineFlagsResultCode; Self::_VARIANTS.len()] = {
53        let mut arr = [Self::_VARIANTS[0]; Self::_VARIANTS.len()];
54        let mut i = 1;
55        while i < Self::_VARIANTS.len() {
56            arr[i] = Self::_VARIANTS[i];
57            i += 1;
58        }
59        arr
60    };
61    const _VARIANTS_STR: &[&str] = &[
62        "Success",
63        "Malformed",
64        "NoTrustLine",
65        "CantRevoke",
66        "InvalidState",
67        "LowReserve",
68    ];
69    pub const VARIANTS_STR: [&'static str; Self::_VARIANTS_STR.len()] = {
70        let mut arr = [Self::_VARIANTS_STR[0]; Self::_VARIANTS_STR.len()];
71        let mut i = 1;
72        while i < Self::_VARIANTS_STR.len() {
73            arr[i] = Self::_VARIANTS_STR[i];
74            i += 1;
75        }
76        arr
77    };
78
79    #[must_use]
80    pub const fn name(&self) -> &'static str {
81        match self {
82            Self::Success => "Success",
83            Self::Malformed => "Malformed",
84            Self::NoTrustLine => "NoTrustLine",
85            Self::CantRevoke => "CantRevoke",
86            Self::InvalidState => "InvalidState",
87            Self::LowReserve => "LowReserve",
88        }
89    }
90
91    #[must_use]
92    pub const fn variants() -> [SetTrustLineFlagsResultCode; Self::_VARIANTS.len()] {
93        Self::VARIANTS
94    }
95}
96
97impl Name for SetTrustLineFlagsResultCode {
98    #[must_use]
99    fn name(&self) -> &'static str {
100        Self::name(self)
101    }
102}
103
104impl Variants<SetTrustLineFlagsResultCode> for SetTrustLineFlagsResultCode {
105    fn variants() -> slice::Iter<'static, SetTrustLineFlagsResultCode> {
106        Self::VARIANTS.iter()
107    }
108}
109
110impl Enum for SetTrustLineFlagsResultCode {}
111
112impl fmt::Display for SetTrustLineFlagsResultCode {
113    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
114        f.write_str(self.name())
115    }
116}
117
118impl TryFrom<i32> for SetTrustLineFlagsResultCode {
119    type Error = Error;
120
121    fn try_from(i: i32) -> Result<Self, Error> {
122        let e = match i {
123            0 => SetTrustLineFlagsResultCode::Success,
124            -1 => SetTrustLineFlagsResultCode::Malformed,
125            -2 => SetTrustLineFlagsResultCode::NoTrustLine,
126            -3 => SetTrustLineFlagsResultCode::CantRevoke,
127            -4 => SetTrustLineFlagsResultCode::InvalidState,
128            -5 => SetTrustLineFlagsResultCode::LowReserve,
129            #[allow(unreachable_patterns)]
130            _ => return Err(Error::Invalid),
131        };
132        Ok(e)
133    }
134}
135
136impl From<SetTrustLineFlagsResultCode> for i32 {
137    #[must_use]
138    fn from(e: SetTrustLineFlagsResultCode) -> Self {
139        e as Self
140    }
141}
142
143impl ReadXdr for SetTrustLineFlagsResultCode {
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 e = i32::read_xdr(r)?;
148            let v: Self = e.try_into()?;
149            Ok(v)
150        })
151    }
152}
153
154impl WriteXdr for SetTrustLineFlagsResultCode {
155    #[cfg(feature = "std")]
156    fn write_xdr<W: Write>(&self, w: &mut Limited<W>) -> Result<(), Error> {
157        w.with_limited_depth(|w| {
158            let i: i32 = (*self).into();
159            i.write_xdr(w)
160        })
161    }
162}
stellar_xdr/generated/set_trust_line_flags_result_code.rs

stellar_xdr/generated/
set_trust_line_flags_result_code.rs
