pd-vm 0.23.1

RustScript bytecode compiler and VM
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

use self_cell::self_cell;

use crate::bytecode::{SharedMap, Value, VmMapIter};

self_cell!(
    struct OwnedMapIter {
        owner: SharedMap,

        #[covariant]
        dependent: VmMapIter,
    }
);

pub(crate) struct MapIteratorState {
    iter: OwnedMapIter,
    current_key: Option<Value>,
    current_value: Option<Value>,
}

impl MapIteratorState {
    pub(crate) fn new(map: SharedMap) -> Self {
        Self {
            iter: OwnedMapIter::new(map, |map| map.iter()),
            current_key: None,
            current_value: None,
        }
    }

    pub(crate) fn advance(&mut self) -> bool {
        let next = self.iter.with_dependent_mut(|_, iter| {
            iter.next().map(|(key, value)| (key.clone(), value.clone()))
        });
        match next {
            Some((key, value)) => {
                self.current_key = Some(key);
                self.current_value = Some(value);
                true
            }
            None => {
                self.current_key = None;
                self.current_value = None;
                false
            }
        }
    }

    pub(crate) fn take_key(&mut self) -> Option<Value> {
        self.current_key.take()
    }

    pub(crate) fn take_value(&mut self) -> Option<Value> {
        self.current_value.take()
    }
}