1 /// Auto-generated bindings for a pre-instantiated version of a
2 /// component which implements the world `empty`.
3 ///
4 /// This structure is created through [`EmptyPre::new`] which
5 /// takes a [`InstancePre`](wasmtime::component::InstancePre) that
6 /// has been created through a [`Linker`](wasmtime::component::Linker).
7 ///
8 /// For more information see [`Empty`] as well.
9 pub struct EmptyPre<T: 'static> {
10     instance_pre: wasmtime::component::InstancePre<T>,
11     indices: EmptyIndices,
12 }
13 impl<T: 'static> Clone for EmptyPre<T> {
clone(&self) -> Self14     fn clone(&self) -> Self {
15         Self {
16             instance_pre: self.instance_pre.clone(),
17             indices: self.indices.clone(),
18         }
19     }
20 }
21 impl<_T: 'static> EmptyPre<_T> {
22     /// Creates a new copy of `EmptyPre` bindings which can then
23     /// be used to instantiate into a particular store.
24     ///
25     /// This method may fail if the component behind `instance_pre`
26     /// does not have the required exports.
new( instance_pre: wasmtime::component::InstancePre<_T>, ) -> wasmtime::Result<Self>27     pub fn new(
28         instance_pre: wasmtime::component::InstancePre<_T>,
29     ) -> wasmtime::Result<Self> {
30         let indices = EmptyIndices::new(&instance_pre)?;
31         Ok(Self { instance_pre, indices })
32     }
engine(&self) -> &wasmtime::Engine33     pub fn engine(&self) -> &wasmtime::Engine {
34         self.instance_pre.engine()
35     }
instance_pre(&self) -> &wasmtime::component::InstancePre<_T>36     pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
37         &self.instance_pre
38     }
39     /// Instantiates a new instance of [`Empty`] within the
40     /// `store` provided.
41     ///
42     /// This function will use `self` as the pre-instantiated
43     /// instance to perform instantiation. Afterwards the preloaded
44     /// indices in `self` are used to lookup all exports on the
45     /// resulting instance.
instantiate( &self, mut store: impl wasmtime::AsContextMut<Data = _T>, ) -> wasmtime::Result<Empty>46     pub fn instantiate(
47         &self,
48         mut store: impl wasmtime::AsContextMut<Data = _T>,
49     ) -> wasmtime::Result<Empty> {
50         let mut store = store.as_context_mut();
51         let instance = self.instance_pre.instantiate(&mut store)?;
52         self.indices.load(&mut store, &instance)
53     }
54 }
55 impl<_T: Send + 'static> EmptyPre<_T> {
56     /// Same as [`Self::instantiate`], except with `async`.
instantiate_async( &self, mut store: impl wasmtime::AsContextMut<Data = _T>, ) -> wasmtime::Result<Empty>57     pub async fn instantiate_async(
58         &self,
59         mut store: impl wasmtime::AsContextMut<Data = _T>,
60     ) -> wasmtime::Result<Empty> {
61         let mut store = store.as_context_mut();
62         let instance = self.instance_pre.instantiate_async(&mut store).await?;
63         self.indices.load(&mut store, &instance)
64     }
65 }
66 /// Auto-generated bindings for index of the exports of
67 /// `empty`.
68 ///
69 /// This is an implementation detail of [`EmptyPre`] and can
70 /// be constructed if needed as well.
71 ///
72 /// For more information see [`Empty`] as well.
73 #[derive(Clone)]
74 pub struct EmptyIndices {}
75 /// Auto-generated bindings for an instance a component which
76 /// implements the world `empty`.
77 ///
78 /// This structure can be created through a number of means
79 /// depending on your requirements and what you have on hand:
80 ///
81 /// * The most convenient way is to use
82 ///   [`Empty::instantiate`] which only needs a
83 ///   [`Store`], [`Component`], and [`Linker`].
84 ///
85 /// * Alternatively you can create a [`EmptyPre`] ahead of
86 ///   time with a [`Component`] to front-load string lookups
87 ///   of exports once instead of per-instantiation. This
88 ///   method then uses [`EmptyPre::instantiate`] to
89 ///   create a [`Empty`].
90 ///
91 /// * If you've instantiated the instance yourself already
92 ///   then you can use [`Empty::new`].
93 ///
94 /// These methods are all equivalent to one another and move
95 /// around the tradeoff of what work is performed when.
96 ///
97 /// [`Store`]: wasmtime::Store
98 /// [`Component`]: wasmtime::component::Component
99 /// [`Linker`]: wasmtime::component::Linker
100 pub struct Empty {}
101 const _: () = {
102     impl EmptyIndices {
103         /// Creates a new copy of `EmptyIndices` bindings which can then
104         /// be used to instantiate into a particular store.
105         ///
106         /// This method may fail if the component does not have the
107         /// required exports.
new<_T>( _instance_pre: &wasmtime::component::InstancePre<_T>, ) -> wasmtime::Result<Self>108         pub fn new<_T>(
109             _instance_pre: &wasmtime::component::InstancePre<_T>,
110         ) -> wasmtime::Result<Self> {
111             let _component = _instance_pre.component();
112             let _instance_type = _instance_pre.instance_type();
113             Ok(EmptyIndices {})
114         }
115         /// Uses the indices stored in `self` to load an instance
116         /// of [`Empty`] from the instance provided.
117         ///
118         /// Note that at this time this method will additionally
119         /// perform type-checks of all exports.
load( &self, mut store: impl wasmtime::AsContextMut, instance: &wasmtime::component::Instance, ) -> wasmtime::Result<Empty>120         pub fn load(
121             &self,
122             mut store: impl wasmtime::AsContextMut,
123             instance: &wasmtime::component::Instance,
124         ) -> wasmtime::Result<Empty> {
125             let _ = &mut store;
126             let _instance = instance;
127             Ok(Empty {})
128         }
129     }
130     impl Empty {
131         /// Convenience wrapper around [`EmptyPre::new`] and
132         /// [`EmptyPre::instantiate`].
instantiate<_T>( store: impl wasmtime::AsContextMut<Data = _T>, component: &wasmtime::component::Component, linker: &wasmtime::component::Linker<_T>, ) -> wasmtime::Result<Empty>133         pub fn instantiate<_T>(
134             store: impl wasmtime::AsContextMut<Data = _T>,
135             component: &wasmtime::component::Component,
136             linker: &wasmtime::component::Linker<_T>,
137         ) -> wasmtime::Result<Empty> {
138             let pre = linker.instantiate_pre(component)?;
139             EmptyPre::new(pre)?.instantiate(store)
140         }
141         /// Convenience wrapper around [`EmptyIndices::new`] and
142         /// [`EmptyIndices::load`].
new( mut store: impl wasmtime::AsContextMut, instance: &wasmtime::component::Instance, ) -> wasmtime::Result<Empty>143         pub fn new(
144             mut store: impl wasmtime::AsContextMut,
145             instance: &wasmtime::component::Instance,
146         ) -> wasmtime::Result<Empty> {
147             let indices = EmptyIndices::new(&instance.instance_pre(&store))?;
148             indices.load(&mut store, instance)
149         }
150         /// Convenience wrapper around [`EmptyPre::new`] and
151         /// [`EmptyPre::instantiate_async`].
instantiate_async<_T>( store: impl wasmtime::AsContextMut<Data = _T>, component: &wasmtime::component::Component, linker: &wasmtime::component::Linker<_T>, ) -> wasmtime::Result<Empty> where _T: Send,152         pub async fn instantiate_async<_T>(
153             store: impl wasmtime::AsContextMut<Data = _T>,
154             component: &wasmtime::component::Component,
155             linker: &wasmtime::component::Linker<_T>,
156         ) -> wasmtime::Result<Empty>
157         where
158             _T: Send,
159         {
160             let pre = linker.instantiate_pre(component)?;
161             EmptyPre::new(pre)?.instantiate_async(store).await
162         }
163     }
164 };
165