generator 0.6.6

Stackfull Generator Library in Rust
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

//! # yeild
//!
//! generator yield implmentation
//!

// use generator::Generator;
use gen_impl::GeneratorImpl;
use rt::{Context, ContextStack, Error};
use yield_::raw_yield_now;

/// passed in scope tpye
/// it not use the context to pass data, but keep it's own data ref
/// this struct provide both compile type info and runtime data
pub struct Scope<A, T> {
    para: *mut Option<A>,
    ret: *mut Option<T>,
}

impl<A, T> Scope<A, T> {
    /// create a new scope object
    pub fn new(para: *mut Option<A>, ret: *mut Option<T>) -> Self {
        Scope {
            para: para,
            ret: ret,
        }
    }

    /// set current generator return value
    #[inline]
    fn set_ret(&mut self, v: T) {
        let ret = unsafe { &mut *self.ret };
        *ret = Some(v);
    }

    /// raw yiled without catch passed in para
    #[inline]
    fn raw_yield(&mut self, env: &ContextStack, context: &mut Context, v: T) {
        // check the context
        if !context.is_generator() {
            panic!("yield from none generator context");
        }

        self.set_ret(v);
        context._ref -= 1;
        raw_yield_now(env, context);

        // here we just panic to exit the func
        if context._ref != 1 {
            panic!(Error::Cancel);
        }
    }

    /// yiled something without catch passed in para
    #[inline]
    pub fn yield_with(&mut self, v: T) {
        let env = ContextStack::current();
        let context = env.top();
        self.raw_yield(&env, context, v);
    }

    /// get current generator send para
    #[inline]
    pub fn get_yield(&mut self) -> Option<A> {
        let para = unsafe { &mut *self.para };
        para.take()
    }

    /// yiled and get the send para
    // it's totally safe that we can refer to the function block
    // since we will come back later
    #[inline]
    pub fn yield_(&mut self, v: T) -> Option<A> {
        self.yield_with(v);
        self.get_yield()
    }

    /// `yiled_from`
    /// the from generator must has the same type as itself
    pub fn yield_from(&mut self, mut g: Box<GeneratorImpl<A, T>>) -> Option<A> {
        let env = ContextStack::current();
        let context = env.top();
        let mut p = self.get_yield();
        while !g.is_done() {
            match g.raw_send(p) {
                None => return None,
                Some(r) => self.raw_yield(&env, context, r),
            }
            p = self.get_yield();
        }
        p
    }
}