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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use crate::collections::arena::ArenaKey;
use core::{fmt, marker::PhantomData};

/// A handle for a stored owned entity.
pub trait Handle: Copy {
    /// The raw representation of the handle.
    type Raw: ArenaKey;
    /// The store owned entity type of the handle.
    type Entity;
    /// The owner associating reference.
    type Owned<T>;

    /// Returns a shared reference to the raw handle to the store owned entity.
    fn as_raw(&self) -> &Self::Owned<RawHandle<Self>>;

    /// Creates `Self` from its raw representation.
    fn from_raw(raw: Self::Owned<RawHandle<Self>>) -> Self;
}

/// A raw handle with an associated handle type.
pub struct RawHandle<T: Handle> {
    /// The raw underlying handle.
    raw: <T as Handle>::Raw,
    /// Marker to signal the associated handle type.
    marker: PhantomData<T>,
}

impl<T: Handle> RawHandle<T> {
    /// Creates a new [`RawHandle`] from the underlying raw representation.]
    // TODO: this is pub for `Nullable<ExternRef,Func>::from_raw_parts`, not sure if really necessary
    #[inline]
    pub(crate) fn new(raw: <T as Handle>::Raw) -> Self {
        Self {
            raw,
            marker: PhantomData,
        }
    }

    /// Returns the raw underlying handle value.
    #[inline]
    pub(crate) fn raw(self) -> <T as Handle>::Raw {
        self.raw
    }
}

impl<T: Handle> ArenaKey for RawHandle<T> {
    #[inline]
    fn into_usize(self) -> usize {
        self.raw.into_usize()
    }

    #[inline]
    fn from_usize(value: usize) -> Option<Self> {
        <<T as Handle>::Raw as ArenaKey>::from_usize(value).map(Self::new)
    }
}

impl<T: Handle> Clone for RawHandle<T> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<T: Handle> Copy for RawHandle<T> {}

impl<T: Handle> PartialEq for RawHandle<T>
where
    T::Raw: PartialEq,
{
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.raw == other.raw
    }
}

impl<T: Handle> Eq for RawHandle<T> where T::Raw: Eq {}

impl<T: Handle> PartialOrd for RawHandle<T>
where
    T::Raw: PartialOrd,
{
    #[inline]
    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
        self.raw.partial_cmp(&other.raw)
    }
}

impl<T: Handle> Ord for RawHandle<T>
where
    T::Raw: Ord,
{
    #[inline]
    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
        self.raw.cmp(&other.raw)
    }
}

impl<T> fmt::Debug for RawHandle<T>
where
    T: Handle<Raw: fmt::Debug>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RawHandle")
            .field("key", &self.raw)
            .field("marker", &::core::any::type_name::<T>())
            .finish()
    }
}

macro_rules! define_handle {
    (
        $( #[$docs:meta] )*
        struct $name:ident($raw:ty, $owned:ident) => $entity:ty;
    ) => {
        $( #[$docs] )*
        #[derive(
            ::core::fmt::Debug,
            ::core::marker::Copy,
            ::core::clone::Clone,
        )]
        #[repr(transparent)]
        pub struct $name(<Self as $crate::Handle>::Owned<$crate::RawHandle<Self>>);

        impl $crate::Handle for $name {
            type Raw = $raw;
            type Entity = $entity;
            type Owned<T> = $owned<T>;

            #[inline]
            fn as_raw(&self) -> &Self::Owned<$crate::RawHandle<Self>> {
                &self.0
            }

            #[inline]
            fn from_raw(raw: <Self as $crate::Handle>::Owned::<$crate::RawHandle<Self>>) -> Self {
                Self(raw)
            }
        }
    };
}