casper_contract_schema/
ty.rs

1use schemars::JsonSchema;
2use serde::{
3    ser::{Serialize, SerializeStructVariant, Serializer},
4    Deserialize,
5};
6
7/// CLType representation. It is slight extension of the original CLType enum.
8/// Instead of `Any` variant, it uses `Custom` variant to represent custom
9/// types, that can have name.
10#[derive(PartialEq, PartialOrd, Ord, Eq, Clone, Deserialize, JsonSchema, Debug)]
11pub enum NamedCLType {
12    Bool,
13    I32,
14    I64,
15    U8,
16    U32,
17    U64,
18    U128,
19    U256,
20    U512,
21    Unit,
22    String,
23    Key,
24    URef,
25    PublicKey,
26    Option(Box<NamedCLType>),
27    List(Box<NamedCLType>),
28    ByteArray(u32),
29    Result {
30        ok: Box<NamedCLType>,
31        err: Box<NamedCLType>,
32    },
33    Map {
34        key: Box<NamedCLType>,
35        value: Box<NamedCLType>,
36    },
37    Tuple1([Box<NamedCLType>; 1]),
38    Tuple2([Box<NamedCLType>; 2]),
39    Tuple3([Box<NamedCLType>; 3]),
40    Custom(String),
41}
42
43impl Serialize for NamedCLType {
44    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
45    where
46        S: Serializer,
47    {
48        match self {
49            NamedCLType::Bool => serializer.serialize_unit_variant("NamedCLType", 0, "Bool"),
50            NamedCLType::I32 => serializer.serialize_unit_variant("NamedCLType", 1, "I32"),
51            NamedCLType::I64 => serializer.serialize_unit_variant("NamedCLType", 2, "I64"),
52            NamedCLType::U8 => serializer.serialize_unit_variant("NamedCLType", 3, "U8"),
53            NamedCLType::U32 => serializer.serialize_unit_variant("NamedCLType", 4, "U32"),
54            NamedCLType::U64 => serializer.serialize_unit_variant("NamedCLType", 5, "U64"),
55            NamedCLType::U128 => serializer.serialize_unit_variant("NamedCLType", 6, "U128"),
56            NamedCLType::U256 => serializer.serialize_unit_variant("NamedCLType", 7, "U256"),
57            NamedCLType::U512 => serializer.serialize_unit_variant("NamedCLType", 8, "U512"),
58            NamedCLType::Unit => serializer.serialize_unit_variant("NamedCLType", 9, "Unit"),
59            NamedCLType::String => serializer.serialize_unit_variant("NamedCLType", 10, "String"),
60            NamedCLType::Key => serializer.serialize_unit_variant("NamedCLType", 11, "Key"),
61            NamedCLType::URef => serializer.serialize_unit_variant("NamedCLType", 12, "URef"),
62            NamedCLType::PublicKey => {
63                serializer.serialize_unit_variant("NamedCLType", 13, "PublicKey")
64            }
65            NamedCLType::Option(f) => {
66                serializer.serialize_newtype_variant("NamedCLType", 14, "Option", f)
67            }
68            NamedCLType::List(f) => {
69                serializer.serialize_newtype_variant("NamedCLType", 15, "List", f)
70            }
71            NamedCLType::ByteArray(f) => {
72                serializer.serialize_newtype_variant("NamedCLType", 16, "ByteArray", f)
73            }
74            NamedCLType::Result { ok, err } => {
75                let mut s =
76                    serializer.serialize_struct_variant("NamedCLType", 17, "Result", 0 + 1 + 1)?;
77                s.serialize_field("ok", ok)?;
78                s.serialize_field("err", err)?;
79                s.end()
80            }
81            NamedCLType::Map { key, value } => {
82                let mut s =
83                    serializer.serialize_struct_variant("NamedCLType", 18, "Map", 0 + 1 + 1)?;
84                s.serialize_field("key", key)?;
85                s.serialize_field("value", value)?;
86                s.end()
87            }
88            NamedCLType::Tuple1(f) => {
89                serializer.serialize_newtype_variant("NamedCLType", 19, "Tuple1", f)
90            }
91            NamedCLType::Tuple2(f) => {
92                serializer.serialize_newtype_variant("NamedCLType", 20, "Tuple2", f)
93            }
94            NamedCLType::Tuple3(f) => {
95                serializer.serialize_newtype_variant("NamedCLType", 21, "Tuple3", f)
96            }
97            NamedCLType::Custom(name) => serializer.serialize_str(name),
98        }
99    }
100}