radix-engine-interface 1.3.1

The interface between system layer and VM layer, from the Radix DLT project.
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

// TODO: Move this logic into procedural macro.
#[macro_export]
macro_rules! access_and_or {
    (|| $tt:tt) => {{
        let next = $crate::composite_requirement!($tt);
        move |e: $crate::blueprints::resource::CompositeRequirement| e.or(next)
    }};
    (|| $right1:ident $right2:tt) => {{
        let next = $crate::composite_requirement!($right1 $right2);
        move |e: $crate::blueprints::resource::CompositeRequirement| e.or(next)
    }};
    (|| $right:tt && $($rest:tt)+) => {{
        let f = $crate::access_and_or!(&& $($rest)+);
        let next = $crate::composite_requirement!($right);
        move |e: $crate::blueprints::resource::CompositeRequirement| e.or(f(next))
    }};
    (|| $right:tt || $($rest:tt)+) => {{
        let f = $crate::access_and_or!(|| $($rest)+);
        let next = $crate::composite_requirement!($right);
        move |e: $crate::blueprints::resource::CompositeRequirement| f(e.or(next))
    }};
    (|| $right1:ident $right2:tt && $($rest:tt)+) => {{
        let f = $crate::access_and_or!(&& $($rest)+);
        let next = $crate::composite_requirement!($right1 $right2);
        move |e: $crate::blueprints::resource::CompositeRequirement| e.or(f(next))
    }};
    (|| $right1:ident $right2:tt || $($rest:tt)+) => {{
        let f = $crate::access_and_or!(|| $($rest)+);
        let next = $crate::composite_requirement!($right1 $right2);
        move |e: $crate::blueprints::resource::CompositeRequirement| f(e.or(next))
    }};

    (&& $tt:tt) => {{
        let next = $crate::composite_requirement!($tt);
        move |e: $crate::blueprints::resource::CompositeRequirement| e.and(next)
    }};
    (&& $right1:ident $right2:tt) => {{
        let next = $crate::composite_requirement!($right1 $right2);
        move |e: $crate::blueprints::resource::CompositeRequirement| e.and(next)
    }};
    (&& $right:tt && $($rest:tt)+) => {{
        let f = $crate::access_and_or!(&& $($rest)+);
        let next = $crate::composite_requirement!($right);
        move |e: $crate::blueprints::resource::CompositeRequirement| f(e.and(next))
    }};
    (&& $right:tt || $($rest:tt)+) => {{
        let f = $crate::access_and_or!(|| $($rest)+);
        let next = $crate::composite_requirement!($right);
        move |e: $crate::blueprints::resource::CompositeRequirement| f(e.and(next))
    }};
    (&& $right1:ident $right2:tt && $($rest:tt)+) => {{
        let f = $crate::access_and_or!(&& $($rest)+);
        let next = $crate::composite_requirement!($right1 $right2);
        move |e: $crate::blueprints::resource::CompositeRequirement| f(e.and(next))
    }};
    (&& $right1:ident $right2:tt || $($rest:tt)+) => {{
        let f = $crate::access_and_or!(|| $($rest)+);
        let next = $crate::composite_requirement!($right1 $right2);
        move |e: $crate::blueprints::resource::CompositeRequirement| f(e.and(next))
    }};
}

#[macro_export]
macro_rules! composite_requirement {
    // Handle leaves
    ($rule:ident $args:tt) => {{
        $rule $args
    }};

    // Handle group
    (($($tt:tt)+)) => {{ $crate::composite_requirement!($($tt)+) }};

    // Handle and/or logic
    ($left1:ident $left2:tt $($right:tt)+) => {{
        let f = $crate::access_and_or!($($right)+);
        f($crate::composite_requirement!($left1 $left2))
    }};
    ($left:tt $($right:tt)+) => {{
        let f = $crate::access_and_or!($($right)+);
        f($crate::composite_requirement!($left))
    }};
}

#[macro_export]
macro_rules! rule {
    (allow_all) => {{
        $crate::blueprints::resource::AccessRule::AllowAll
    }};
    (deny_all) => {{
        $crate::blueprints::resource::AccessRule::DenyAll
    }};
    ($($tt:tt)+) => {{
        $crate::blueprints::resource::AccessRule::Protected($crate::composite_requirement!($($tt)+))
    }};
}

#[macro_export]
macro_rules! role_entry {
    ($roles: expr, $role: expr, $rule:expr) => {{
        $roles.define_role($role, $rule);
    }};
}

#[macro_export]
macro_rules! roles2 {
    ( ) => ({
        $crate::blueprints::resource::RoleAssignmentInit::new()
    });
    ( $($role:expr => $rule:expr $(, $updatable:ident)?;)* ) => ({
        let mut roles = $crate::blueprints::resource::RoleAssignmentInit::new();
        $(
            role_entry!(roles, $role, $rule);
        )*
        roles
    })
}

extern crate radix_common_derive;
pub use radix_common_derive::dec;
pub use radix_common_derive::pdec;