stellar_xdr/generated/
claim_predicate.rs

1#[allow(unused_imports, clippy::wildcard_imports)]
2use super::*;
3
4/// ClaimPredicate is an XDR Union defined as:
5///
6/// ```text
7/// union ClaimPredicate switch (ClaimPredicateType type)
8/// {
9/// case CLAIM_PREDICATE_UNCONDITIONAL:
10///     void;
11/// case CLAIM_PREDICATE_AND:
12///     ClaimPredicate andPredicates<2>;
13/// case CLAIM_PREDICATE_OR:
14///     ClaimPredicate orPredicates<2>;
15/// case CLAIM_PREDICATE_NOT:
16///     ClaimPredicate* notPredicate;
17/// case CLAIM_PREDICATE_BEFORE_ABSOLUTE_TIME:
18///     int64 absBefore; // Predicate will be true if closeTime < absBefore
19/// case CLAIM_PREDICATE_BEFORE_RELATIVE_TIME:
20///     int64 relBefore; // Seconds since closeTime of the ledger in which the
21///                      // ClaimableBalanceEntry was created
22/// };
23/// ```
24///
25// union with discriminant ClaimPredicateType
26#[cfg_attr(feature = "serde", cfg_eval::cfg_eval)]
27#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
28#[cfg_attr(feature = "arbitrary", derive(Arbitrary))]
29#[cfg_attr(
30    all(feature = "serde", feature = "alloc"),
31    serde_with::serde_as,
32    derive(serde::Serialize, serde::Deserialize),
33    serde(rename_all = "snake_case")
34)]
35#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
36#[allow(clippy::large_enum_variant)]
37pub enum ClaimPredicate {
38    Unconditional,
39    And(VecM<ClaimPredicate, 2>),
40    Or(VecM<ClaimPredicate, 2>),
41    Not(Option<Box<ClaimPredicate>>),
42    BeforeAbsoluteTime(
43        #[cfg_attr(
44            all(feature = "serde", feature = "alloc"),
45            serde_as(as = "NumberOrString")
46        )]
47        i64,
48    ),
49    BeforeRelativeTime(
50        #[cfg_attr(
51            all(feature = "serde", feature = "alloc"),
52            serde_as(as = "NumberOrString")
53        )]
54        i64,
55    ),
56}
57
58#[cfg(feature = "alloc")]
59impl Default for ClaimPredicate {
60    fn default() -> Self {
61        Self::Unconditional
62    }
63}
64
65impl ClaimPredicate {
66    const _VARIANTS: &[ClaimPredicateType] = &[
67        ClaimPredicateType::Unconditional,
68        ClaimPredicateType::And,
69        ClaimPredicateType::Or,
70        ClaimPredicateType::Not,
71        ClaimPredicateType::BeforeAbsoluteTime,
72        ClaimPredicateType::BeforeRelativeTime,
73    ];
74    pub const VARIANTS: [ClaimPredicateType; Self::_VARIANTS.len()] = {
75        let mut arr = [Self::_VARIANTS[0]; Self::_VARIANTS.len()];
76        let mut i = 1;
77        while i < Self::_VARIANTS.len() {
78            arr[i] = Self::_VARIANTS[i];
79            i += 1;
80        }
81        arr
82    };
83    const _VARIANTS_STR: &[&str] = &[
84        "Unconditional",
85        "And",
86        "Or",
87        "Not",
88        "BeforeAbsoluteTime",
89        "BeforeRelativeTime",
90    ];
91    pub const VARIANTS_STR: [&'static str; Self::_VARIANTS_STR.len()] = {
92        let mut arr = [Self::_VARIANTS_STR[0]; Self::_VARIANTS_STR.len()];
93        let mut i = 1;
94        while i < Self::_VARIANTS_STR.len() {
95            arr[i] = Self::_VARIANTS_STR[i];
96            i += 1;
97        }
98        arr
99    };
100
101    #[must_use]
102    pub const fn name(&self) -> &'static str {
103        match self {
104            Self::Unconditional => "Unconditional",
105            Self::And(_) => "And",
106            Self::Or(_) => "Or",
107            Self::Not(_) => "Not",
108            Self::BeforeAbsoluteTime(_) => "BeforeAbsoluteTime",
109            Self::BeforeRelativeTime(_) => "BeforeRelativeTime",
110        }
111    }
112
113    #[must_use]
114    pub const fn discriminant(&self) -> ClaimPredicateType {
115        #[allow(clippy::match_same_arms)]
116        match self {
117            Self::Unconditional => ClaimPredicateType::Unconditional,
118            Self::And(_) => ClaimPredicateType::And,
119            Self::Or(_) => ClaimPredicateType::Or,
120            Self::Not(_) => ClaimPredicateType::Not,
121            Self::BeforeAbsoluteTime(_) => ClaimPredicateType::BeforeAbsoluteTime,
122            Self::BeforeRelativeTime(_) => ClaimPredicateType::BeforeRelativeTime,
123        }
124    }
125
126    #[must_use]
127    pub const fn variants() -> [ClaimPredicateType; Self::_VARIANTS.len()] {
128        Self::VARIANTS
129    }
130}
131
132impl Name for ClaimPredicate {
133    #[must_use]
134    fn name(&self) -> &'static str {
135        Self::name(self)
136    }
137}
138
139impl Discriminant<ClaimPredicateType> for ClaimPredicate {
140    #[must_use]
141    fn discriminant(&self) -> ClaimPredicateType {
142        Self::discriminant(self)
143    }
144}
145
146impl Variants<ClaimPredicateType> for ClaimPredicate {
147    fn variants() -> slice::Iter<'static, ClaimPredicateType> {
148        Self::VARIANTS.iter()
149    }
150}
151
152impl Union<ClaimPredicateType> for ClaimPredicate {}
153
154impl ReadXdr for ClaimPredicate {
155    #[cfg(feature = "std")]
156    fn read_xdr<R: Read>(r: &mut Limited<R>) -> Result<Self, Error> {
157        r.with_limited_depth(|r| {
158            let dv: ClaimPredicateType = <ClaimPredicateType as ReadXdr>::read_xdr(r)?;
159            #[allow(clippy::match_same_arms, clippy::match_wildcard_for_single_variants)]
160            let v = match dv {
161                ClaimPredicateType::Unconditional => Self::Unconditional,
162                ClaimPredicateType::And => Self::And(VecM::<ClaimPredicate, 2>::read_xdr(r)?),
163                ClaimPredicateType::Or => Self::Or(VecM::<ClaimPredicate, 2>::read_xdr(r)?),
164                ClaimPredicateType::Not => Self::Not(Option::<Box<ClaimPredicate>>::read_xdr(r)?),
165                ClaimPredicateType::BeforeAbsoluteTime => {
166                    Self::BeforeAbsoluteTime(i64::read_xdr(r)?)
167                }
168                ClaimPredicateType::BeforeRelativeTime => {
169                    Self::BeforeRelativeTime(i64::read_xdr(r)?)
170                }
171                #[allow(unreachable_patterns)]
172                _ => return Err(Error::Invalid),
173            };
174            Ok(v)
175        })
176    }
177}
178
179impl WriteXdr for ClaimPredicate {
180    #[cfg(feature = "std")]
181    fn write_xdr<W: Write>(&self, w: &mut Limited<W>) -> Result<(), Error> {
182        w.with_limited_depth(|w| {
183            self.discriminant().write_xdr(w)?;
184            #[allow(clippy::match_same_arms)]
185            match self {
186                Self::Unconditional => ().write_xdr(w)?,
187                Self::And(v) => v.write_xdr(w)?,
188                Self::Or(v) => v.write_xdr(w)?,
189                Self::Not(v) => v.write_xdr(w)?,
190                Self::BeforeAbsoluteTime(v) => v.write_xdr(w)?,
191                Self::BeforeRelativeTime(v) => v.write_xdr(w)?,
192            };
193            Ok(())
194        })
195    }
196}
stellar_xdr/generated/claim_predicate.rs

stellar_xdr/generated/
claim_predicate.rs
