gentian 0.1.8

gentian: a proc macro that transforms generators to state machines
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

use gentian::gentian;
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum ProtocolType {
    SS,
    TLS,
    VMESS,
    WS,
    TROJAN,
    DIRECT,
}

pub trait Protocol {
    fn protocol_type(&self) -> ProtocolType;
}

struct ChainStreamBuilderProtocolTypeIter<'a> {
    builders: &'a Vec<Box<dyn Protocol>>,
    ty: Option<ProtocolType>,
    pos: usize,
    state: u32,
}
impl<'a> ChainStreamBuilderProtocolTypeIter<'a> {
    fn new(
        builders: &'a Vec<Box<dyn Protocol>>,
        last_builder: &'a Option<Box<dyn Protocol>>,
    ) -> Self {
        let mut ty = None;
        if let Some(b) = last_builder {
            ty = Some(b.protocol_type());
        }
        Self {
            builders,
            ty,
            pos: builders.len(),
            state: 0,
        }
    }
}

impl<'a> Iterator for ChainStreamBuilderProtocolTypeIter<'a> {
    type Item = ProtocolType;

    #[gentian]
    #[gentian_attr(ret_val=None)]
    fn next(&mut self) -> Option<Self::Item> {
        if self.ty.is_some() {
            co_yield(self.ty);
        }
        if self.pos == 0 {
            return None;
        }
        while self.pos != 0 {
            self.pos -= 1;
            co_yield(Some(self.builders[self.pos].protocol_type()));
        }
        return None;
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        if self.ty.is_some() {
            return (0, Some(self.pos + 1));
        }
        (0, Some(self.pos))
    }
}
macro_rules! impl_protocol {
    ($name:tt,$type:expr) => {
        struct $name;
        impl Protocol for $name {
            fn protocol_type(&self) -> ProtocolType {
                $type
            }
        }
    };
}
impl_protocol!(Trojan, ProtocolType::TROJAN);
impl_protocol!(Shadowsocks, ProtocolType::SS);
impl_protocol!(Vmess, ProtocolType::VMESS);
impl_protocol!(Direct, ProtocolType::DIRECT);
impl_protocol!(Tls, ProtocolType::TLS);
impl_protocol!(Ws, ProtocolType::WS);

#[test]
fn test_iter_impl() {
    use ProtocolType::{DIRECT, SS, TLS, TROJAN, VMESS, WS};
    let builders: Vec<Box<dyn Protocol>> = vec![
        Box::new(Vmess),
        Box::new(Tls),
        Box::new(Trojan),
        Box::new(Shadowsocks),
        Box::new(Ws),
        Box::new(Vmess),
        Box::new(Direct),
    ];
    let last_builder: Option<Box<dyn Protocol>> = Some(Box::new(Trojan));
    let expected = vec![TROJAN, DIRECT, VMESS, WS, SS, TROJAN, TLS, VMESS];
    let my_iter = ChainStreamBuilderProtocolTypeIter::new(&builders, &last_builder);
    for (real, expected) in my_iter.zip(expected.into_iter()) {
        assert_eq!(real, expected);
    }
    let last_builder = None;
    let expected = vec![DIRECT, VMESS, WS, SS, TROJAN, TLS, VMESS];
    let my_iter = ChainStreamBuilderProtocolTypeIter::new(&builders, &last_builder);
    for (real, expected) in my_iter.zip(expected.into_iter()) {
        assert_eq!(real, expected);
    }
}