wasmi 2.0.0-beta.2

WebAssembly interpreter
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
108
109
110
111
112
113
114
115
116
117
118

use crate::{
    StoreContext,
    store::{PrunedStore, Store, StoreInner},
};

/// A unique store identifier.
///
/// # Note
///
/// Used to differentiate different store instances.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct StoreId(u32);

impl StoreId {
    /// Returns a new unique [`StoreId`].
    pub(super) fn new() -> Self {
        use core::sync::atomic::{AtomicU32, Ordering};
        /// An atomic, static store identifier counter.
        static STORE_ID: AtomicU32 = AtomicU32::new(0);
        let next = STORE_ID.fetch_add(1, Ordering::AcqRel);
        Self(next)
    }
}

/// A value associated to a [`Store`].
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct Stored<T> {
    /// The identifier of the associated store.
    store: StoreId,
    /// The stored value.
    value: T,
}

/// Trait implemented by utilities that can wrap or unwrap [`Stored`] values.
pub trait AsStoreId: Copy {
    /// Wraps the given `value` as [`Stored<T>`] associating it with `self`.
    fn wrap<T>(self, value: T) -> Stored<T>;

    /// Unwraps the given [`Stored<T>`] reference and returns the `T`.
    ///
    /// Returns `None` if `value` does not originate from `self`.
    fn unwrap<T>(self, value: &Stored<T>) -> Option<&T>;
}

impl AsStoreId for StoreId {
    #[inline]
    fn wrap<T>(self, value: T) -> Stored<T> {
        Stored { store: self, value }
    }

    #[inline]
    fn unwrap<T>(self, value: &Stored<T>) -> Option<&T> {
        if value.store != self {
            return None;
        }
        Some(&value.value)
    }
}

impl AsStoreId for &'_ StoreId {
    #[inline]
    fn wrap<T>(self, value: T) -> Stored<T> {
        <StoreId as AsStoreId>::wrap(*self, value)
    }

    #[inline]
    fn unwrap<T>(self, value: &Stored<T>) -> Option<&T> {
        <StoreId as AsStoreId>::unwrap(*self, value)
    }
}

impl AsStoreId for &'_ StoreInner {
    #[inline]
    fn wrap<T>(self, value: T) -> Stored<T> {
        self.id().wrap(value)
    }

    #[inline]
    fn unwrap<T>(self, value: &Stored<T>) -> Option<&T> {
        self.id().unwrap(value)
    }
}

impl<D> AsStoreId for &'_ Store<D> {
    #[inline]
    fn wrap<T>(self, value: T) -> Stored<T> {
        self.inner.wrap(value)
    }

    #[inline]
    fn unwrap<T>(self, value: &Stored<T>) -> Option<&T> {
        self.inner.unwrap(value)
    }
}

impl AsStoreId for &'_ PrunedStore {
    #[inline]
    fn wrap<T>(self, value: T) -> Stored<T> {
        self.inner().wrap(value)
    }

    #[inline]
    fn unwrap<T>(self, value: &Stored<T>) -> Option<&T> {
        self.inner().unwrap(value)
    }
}

impl<S> AsStoreId for StoreContext<'_, S> {
    #[inline]
    fn wrap<T>(self, value: T) -> Stored<T> {
        self.store.wrap(value)
    }

    #[inline]
    fn unwrap<T>(self, value: &Stored<T>) -> Option<&T> {
        self.store.unwrap(value)
    }
}