korvin-core 0.2.1

The core for korvin frontend framework
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

#[macro_export]
macro_rules! impl_complex_mutation {
    (mutation = $mutation:ty, log = $log:ty, reverse = $reverse:ty, $perform:item, $revert:item) => {
        pub type Mutation = $mutation;
        pub type Log = $log;

        impl $crate::mutation::traits::Perform for $mutation {
            type Log = $log;
            fn to_mutation(self) -> $crate::mutation::Mutation {
                $crate::mutation::traits::Perform::to_mutation(super::Mutation::from(self))
            }
            $perform
        }

        impl $crate::mutation::traits::Revert for $log {
            type Mutation = $reverse;
            fn to_mutation_log(self) -> $crate::mutation::MutationLog {
                $crate::mutation::traits::Revert::to_mutation_log(super::Log::from(self))
            }
            $revert
        }
    }
}

#[macro_export]
macro_rules! impl_mutation {
    (mutation = $mutation:ty, log = $log:ty, $perform:item, $revert:item) => {
        $crate::impl_complex_mutation! {
            mutation = $mutation,
            log = $log,
            reverse = $mutation,
            $perform,
            $revert
        }
    };
}

#[macro_export]
macro_rules! impl_complex_mutation_wrapper {
    (
        reverse = $reverse_mutation:ty,
        $(#[$mutation_meta:meta])* enum $mutation:ident {
            $(
                $(#[$mutation_variant_meta:meta])*
                $mutation_variant:ident($mutation_inner:ty)
            ),* $(,)?
        },
        $(#[$log_meta:meta])* enum $mutation_log:ident {
            $(
                $(#[$log_variant_meta:meta])*
                $log_variant:ident($log_inner:ty)
            ),* $(,)?
        }
    ) => {
        $(#[$mutation_meta])*
        #[derive(Debug, derive_more::From, PartialEq, Clone)]
        #[derive(derive_more::TryInto)]
        #[try_into(owned, ref, ref_mut)]
        pub enum $mutation {
            $(
                $(#[$mutation_variant_meta])*
                $mutation_variant($mutation_inner)
            ),*
        }

        $(#[$log_meta])*
        #[derive(Debug, derive_more::From, PartialEq, Clone)]
        #[derive(derive_more::TryInto)]
        #[try_into(owned, ref, ref_mut)]
        pub enum $mutation_log{
            $(
                $(#[$log_variant_meta])*
                $log_variant($log_inner)
            ),*
        }

        $crate::impl_complex_mutation! {
            mutation = $mutation,
            log = $mutation_log,
            reverse = $reverse_mutation,
            fn perform(&self, state: $crate::data::ElementId) -> $crate::mutation::error::MutationResult<Self::Log> {
                match self {
                    $(Self::$mutation_variant(inner) => inner.perform(state).map(Into::into)),*
                }
            },
            fn revert(&self) -> Self::Mutation {
                match self {
                    $(Self::$log_variant(inner) => inner.revert().into()),*
                }
            }
        }
    }
}

#[macro_export]
macro_rules! impl_mutation_wrapper {
    (
        $(#[$mutation_meta:meta])* enum $mutation:ident {
            $(
                $(#[$mutation_variant_meta:meta])*
                $mutation_variant:ident($mutation_inner:ty)
            ),* $(,)?
        },
        $(#[$log_meta:meta])* enum $mutation_log:ident {
            $(
                $(#[$log_variant_meta:meta])*
                $log_variant:ident($log_inner:ty)
            ),* $(,)?
        }
    ) => {
        $(#[$mutation_meta])*
        #[derive(Debug, derive_more::From, PartialEq, Clone)]
        pub enum $mutation {
            $(
                $(#[$mutation_variant_meta])*
                $mutation_variant($mutation_inner)
            ),*
        }

        $(#[$log_meta])*
        #[derive(Debug, derive_more::From, PartialEq, Clone)]
        pub enum $mutation_log{
            $(
                $(#[$log_variant_meta])*
                $log_variant($log_inner)
            ),*
        }

        $crate::impl_mutation! {
            mutation = $mutation,
            log = $mutation_log,
            fn perform(&self, state: $crate::data::ElementId) -> $crate::mutation::error::MutationResult<Self::Log> {
                match self {
                    $(Self::$mutation_variant(inner) => inner.perform(state).map(Into::into)),*
                }
            },
            fn revert(&self) -> Self::Mutation {
                match self {
                    $(Self::$log_variant(inner) => inner.revert().into()),*
                }
            }
        }
    }
}