radix_common/data/manifest/
custom_value.rs

1use crate::data::manifest::model::*;
2use crate::internal_prelude::*;
3
4#[cfg_attr(
5    feature = "fuzzing",
6    derive(::arbitrary::Arbitrary, ::serde::Serialize, ::serde::Deserialize)
7)]
8#[derive(Debug, Clone, PartialEq, Eq)]
9pub enum ManifestCustomValue {
10    Address(ManifestAddress),
11    Bucket(ManifestBucket),
12    Proof(ManifestProof),
13    Expression(ManifestExpression),
14    Blob(ManifestBlobRef),
15    Decimal(ManifestDecimal),
16    PreciseDecimal(ManifestPreciseDecimal),
17    NonFungibleLocalId(ManifestNonFungibleLocalId),
18    AddressReservation(ManifestAddressReservation),
19}
20
21impl CustomValue<ManifestCustomValueKind> for ManifestCustomValue {
22    fn get_custom_value_kind(&self) -> ManifestCustomValueKind {
23        match self {
24            ManifestCustomValue::Address(_) => ManifestCustomValueKind::Address,
25            ManifestCustomValue::Bucket(_) => ManifestCustomValueKind::Bucket,
26            ManifestCustomValue::Proof(_) => ManifestCustomValueKind::Proof,
27            ManifestCustomValue::Expression(_) => ManifestCustomValueKind::Expression,
28            ManifestCustomValue::Blob(_) => ManifestCustomValueKind::Blob,
29            ManifestCustomValue::Decimal(_) => ManifestCustomValueKind::Decimal,
30            ManifestCustomValue::PreciseDecimal(_) => ManifestCustomValueKind::PreciseDecimal,
31            ManifestCustomValue::NonFungibleLocalId(_) => {
32                ManifestCustomValueKind::NonFungibleLocalId
33            }
34            ManifestCustomValue::AddressReservation(_) => {
35                ManifestCustomValueKind::AddressReservation
36            }
37        }
38    }
39}
40
41impl<E: Encoder<ManifestCustomValueKind>> Encode<ManifestCustomValueKind, E>
42    for ManifestCustomValue
43{
44    fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError> {
45        match self {
46            ManifestCustomValue::Address(_) => {
47                encoder.write_value_kind(ValueKind::Custom(ManifestCustomValueKind::Address))
48            }
49            ManifestCustomValue::Bucket(_) => {
50                encoder.write_value_kind(ValueKind::Custom(ManifestCustomValueKind::Bucket))
51            }
52            ManifestCustomValue::Proof(_) => {
53                encoder.write_value_kind(ValueKind::Custom(ManifestCustomValueKind::Proof))
54            }
55            ManifestCustomValue::Expression(_) => {
56                encoder.write_value_kind(ValueKind::Custom(ManifestCustomValueKind::Expression))
57            }
58            ManifestCustomValue::Blob(_) => {
59                encoder.write_value_kind(ValueKind::Custom(ManifestCustomValueKind::Blob))
60            }
61            ManifestCustomValue::Decimal(_) => {
62                encoder.write_value_kind(ValueKind::Custom(ManifestCustomValueKind::Decimal))
63            }
64            ManifestCustomValue::PreciseDecimal(_) => {
65                encoder.write_value_kind(ValueKind::Custom(ManifestCustomValueKind::PreciseDecimal))
66            }
67            ManifestCustomValue::NonFungibleLocalId(_) => encoder.write_value_kind(
68                ValueKind::Custom(ManifestCustomValueKind::NonFungibleLocalId),
69            ),
70            ManifestCustomValue::AddressReservation(_) => encoder.write_value_kind(
71                ValueKind::Custom(ManifestCustomValueKind::AddressReservation),
72            ),
73        }
74    }
75
76    fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError> {
77        match self {
78            // TODO: vector free
79            ManifestCustomValue::Address(v) => v.encode_body(encoder),
80            ManifestCustomValue::Bucket(v) => v.encode_body(encoder),
81            ManifestCustomValue::Proof(v) => v.encode_body(encoder),
82            ManifestCustomValue::Expression(v) => v.encode_body(encoder),
83            ManifestCustomValue::Blob(v) => v.encode_body(encoder),
84            ManifestCustomValue::Decimal(v) => v.encode_body(encoder),
85            ManifestCustomValue::PreciseDecimal(v) => v.encode_body(encoder),
86            ManifestCustomValue::NonFungibleLocalId(v) => v.encode_body(encoder),
87            ManifestCustomValue::AddressReservation(v) => v.encode_body(encoder),
88        }
89    }
90}
91
92impl<D: Decoder<ManifestCustomValueKind>> Decode<ManifestCustomValueKind, D>
93    for ManifestCustomValue
94{
95    fn decode_body_with_value_kind(
96        decoder: &mut D,
97        value_kind: ValueKind<ManifestCustomValueKind>,
98    ) -> Result<Self, DecodeError> {
99        match value_kind {
100            ValueKind::Custom(cti) => match cti {
101                ManifestCustomValueKind::Address => {
102                    ManifestAddress::decode_body_with_value_kind(decoder, value_kind)
103                        .map(Self::Address)
104                }
105                ManifestCustomValueKind::Blob => {
106                    ManifestBlobRef::decode_body_with_value_kind(decoder, value_kind)
107                        .map(Self::Blob)
108                }
109                ManifestCustomValueKind::Bucket => {
110                    ManifestBucket::decode_body_with_value_kind(decoder, value_kind)
111                        .map(Self::Bucket)
112                }
113                ManifestCustomValueKind::Proof => {
114                    ManifestProof::decode_body_with_value_kind(decoder, value_kind).map(Self::Proof)
115                }
116                ManifestCustomValueKind::Expression => {
117                    ManifestExpression::decode_body_with_value_kind(decoder, value_kind)
118                        .map(Self::Expression)
119                }
120                ManifestCustomValueKind::Decimal => {
121                    ManifestDecimal::decode_body_with_value_kind(decoder, value_kind)
122                        .map(Self::Decimal)
123                }
124                ManifestCustomValueKind::PreciseDecimal => {
125                    ManifestPreciseDecimal::decode_body_with_value_kind(decoder, value_kind)
126                        .map(Self::PreciseDecimal)
127                }
128                ManifestCustomValueKind::NonFungibleLocalId => {
129                    ManifestNonFungibleLocalId::decode_body_with_value_kind(decoder, value_kind)
130                        .map(Self::NonFungibleLocalId)
131                }
132                ManifestCustomValueKind::AddressReservation => {
133                    ManifestAddressReservation::decode_body_with_value_kind(decoder, value_kind)
134                        .map(Self::AddressReservation)
135                }
136            },
137            _ => Err(DecodeError::UnexpectedCustomValueKind {
138                actual: value_kind.as_u8(),
139            }),
140        }
141    }
142}
radix_common/data/manifest/custom_value.rs

radix_common/data/manifest/
custom_value.rs
