state-shift 2.1.1

Macros for implementing Type-State-Pattern on your structs and methods
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

mod example {
    use core::marker::PhantomData;
    use core::mem::MaybeUninit;

    use state_shift::{impl_state, type_state};

    pub struct MyParentObject<'base> {
        #[allow(unused)]
        inner: MaybeUninit<*mut core::ffi::c_void>,
        _marker: PhantomData<&'base ()>,
    }

    impl<'base> MyParentObject<'base> {
        pub fn new() -> Self {
            MyParentObject {
                inner: MaybeUninit::zeroed(),
                _marker: PhantomData,
            }
        }

        // ...

        pub fn method(&'base self) -> MethodBuilder {
            MethodBuilder::new()
        }
    }

    pub struct Method {}

    impl Method {
        pub fn start(self) -> Result<(), String> {
            Ok(())
        }
    }

    #[type_state(states = (Unset, ASet, BSet, AOrBSet), slots = (Unset, Unset, Unset))]
    pub struct MethodBuilder {
        #[allow(unused)]
        slot_a: Option<u8>,
        slot_b: Option<u8>,
    }

    impl MethodBuilder {}

    #[impl_state]
    impl MethodBuilder {
        #[require(Unset, Unset, Unset)] // require the default state for the constructor
        pub fn new() -> MethodBuilder {
            MethodBuilder {
                slot_a: None,
                slot_b: None,
            }
        }

        #[require(Unset, B, C)]
        #[switch_to(ASet, B, AOrBSet)]
        pub fn set_slot_a(self, slot_a: u8) -> MethodBuilder {
            MethodBuilder {
                slot_a: Some(slot_a),
                slot_b: self.slot_b,
            }
        }

        #[require(A, BSet, C)]
        #[switch_to(A, BSet, AOrBSet)]
        pub fn set_slot_b(self, slot_b: u8) -> MethodBuilder {
            MethodBuilder {
                slot_a: self.slot_a,
                slot_b: Some(slot_b),
            }
        }

        #[require(A, B, AOrBSet)]
        pub fn build(self) -> Method {
            Method {}
        }

        #[require(A, B, AOrBSet)]
        pub fn start(self) -> Result<(), String> {
            Ok(())
        }
    }
}

#[test]
fn test_method_builder() {
    let myparentobj = example::MyParentObject::new();

    // using the clean builder pattern within the parent
    let meth = myparentobj.method().set_slot_a(42).build();
    let res = meth.start();
    assert!(res.is_ok())
}