treaty -


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

use std::any::TypeId;

use uniserde::{
    Build, Builder,
    impls::core::iterator::IterWalker,
    protocol::{implementer, AnyImpl, Implementation, Implementer},
    protocols::{sequence, ControlFlow},
    transform,
    WalkOnce,
};

#[test]
fn demo() {
    let a = vec![true, false, true];

    let mut builder = ArrayBuilder::default();
    IterWalker::new(a).walk_once(builder.as_visitor());
    dbg!(builder.build());

    todo!()
}

#[no_mangle]
fn example(a: [bool; 3]) -> [bool; 3] {
    let mut builder = ArrayBuilder::default();
    let _ = IterWalker::new(a).walk_once(builder.as_visitor());
    builder.build().unwrap()
}

#[derive(Default)]
struct ArrayBuilder([Option<bool>; 3]);

impl<'ctx> Builder<'ctx> for ArrayBuilder {
    type Error = ();

    type Value = [bool; 3];

    fn as_visitor(&mut self) -> &mut dyn uniserde::protocol::Implementer<'ctx> {
        self
    }

    fn build(self) -> Result<Self::Value, Self::Error> {
        Ok([self.0[0].unwrap(), self.0[1].unwrap(), self.0[2].unwrap()])
    }
}

implementer! {
    impl['ctx] ArrayBuilder = [sequence::Sequence];
}

impl<'ctx> sequence::Object<'ctx> for ArrayBuilder {
    fn visit(
        &mut self,
        accessor: &mut dyn sequence::Accessor<'ctx>,
    ) -> uniserde::protocols::ControlFlow {
        for slot in &mut self.0 {
            let mut builder = <bool as Build>::Builder::default();
            accessor.next(builder.as_visitor());
            *slot = Some(builder.build().unwrap());
        }
        ControlFlow::Done
    }
}