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

pub mod element;
pub mod error;
pub mod traits;
#[macro_use]
pub mod macros;

#[macro_export]
macro_rules! noop_mutation {
    () => {
        pub mod noop {
            use $crate::impl_mutation;

            #[derive(Debug, PartialEq , Clone)]
            pub struct NoopMutation {}

            #[derive(Debug, PartialEq, Clone)]
            pub struct NoopMutationLog {}

            impl_mutation! {
                mutation = NoopMutation,
                log = NoopMutationLog,
                fn perform(&self, _state: &mut $crate::DocumentModel) -> $crate::mutation::error::MutationResult<Self::Log> {
                    Ok(Self::Log {})
                },
                fn revert(&self) -> Self::Mutation {
                    Self::Mutation {}
                }
            }
        }
    }
}

#[derive(Debug, derive_more::From, PartialEq, Clone)]
pub enum Mutation {
    Element(element::Mutation),
}

impl traits::Perform for Mutation {
    type Log = self::MutationLog;

    fn perform(&self, element: crate::data::ElementId) -> error::MutationResult<Self::Log> {
        match self {
            Mutation::Element(i) => i.perform(element).map(Into::into),
        }
    }

    fn to_mutation(self) -> self::Mutation {
        self
    }
}

#[derive(Debug, derive_more::From, Clone, PartialEq)]
pub enum MutationLog {
    Element(element::Log),
}
pub type Log = MutationLog;

impl traits::Revert for MutationLog {
    type Mutation = self::Mutation;

    fn revert(&self) -> Self::Mutation {
        match self {
            MutationLog::Element(i) => i.revert().into(),
        }
    }

    fn to_mutation_log(self) -> self::MutationLog {
        self
    }
}