moverox-traits 0.1.3

Traits for rusty Move types and their type tags.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use std::str::FromStr;

use moverox_types::{Address, TypeTag, U256};

use crate::{
    ConstTypeTag,
    MoveDatatypeTag,
    MoveType,
    MoveTypeTag,
    ParseTypeTagError,
    TypeTagError,
};

macro_rules! impl_primitive_type_tags {
    ($($typ:ty: ($type_tag:ident, $variant:ident)),*) => {
        $(
            #[derive(
                Clone,
                Debug,
                PartialEq,
                Eq,
                Hash,
                PartialOrd,
                Ord,
            )]
            #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
            pub struct $type_tag;

            impl MoveTypeTag for $type_tag {
                fn as_datatype_tag(&self) -> Option<&dyn MoveDatatypeTag> {
                    None
                }

                fn from_type_tag(value: &TypeTag) -> Result<Self, TypeTagError> {
                    match value {
                        TypeTag::$variant => Ok(Self),
                        _ => Err(TypeTagError::Variant {
                            expected: stringify!($variant).to_owned(),
                            got: crate::type_tag_variant_name(value) }
                        )
                    }
                }

                fn to_type_tag(&self) -> TypeTag {
                    TypeTag::$variant
                }
            }

            impl std::fmt::Display for $type_tag {
                fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                    let stag = MoveTypeTag::to_type_tag(self);
                    write!(f, "{}", stag)
                }
            }

            impl FromStr for $type_tag {
                type Err = ParseTypeTagError;

                fn from_str(s: &str) -> Result<Self, Self::Err> {
                    let tag: TypeTag = s.parse().map_err(ParseTypeTagError::from_str)?;
                    Ok(MoveTypeTag::from_type_tag(&tag)?)
                }
            }

            impl MoveType for $typ {
                type TypeTag = $type_tag;
            }

            impl ConstTypeTag for $typ {
                const TYPE_TAG: $type_tag = $type_tag;
            }
        )*
    };
}

impl_primitive_type_tags! {
    Address: (AddressTypeTag, Address),
    bool: (BoolTypeTag, Bool),
    u8: (U8TypeTag, U8),
    u16: (U16TypeTag, U16),
    u32: (U32TypeTag, U32),
    u64: (U64TypeTag, U64),
    u128: (U128TypeTag, U128),
    U256: (U256TypeTag, U256)
}