1 /// Auto-generated bindings for a pre-instantiated version of a
2 /// component which implements the world `the-world`.
3 ///
4 /// This structure is created through [`TheWorldPre::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 [`TheWorld`] as well.
9 pub struct TheWorldPre<T: 'static> {
10     instance_pre: wasmtime::component::InstancePre<T>,
11     indices: TheWorldIndices,
12 }
13 impl<T: 'static> Clone for TheWorldPre<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> TheWorldPre<_T> {
22     /// Creates a new copy of `TheWorldPre` 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 = TheWorldIndices::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 [`TheWorld`] 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<TheWorld>46     pub fn instantiate(
47         &self,
48         mut store: impl wasmtime::AsContextMut<Data = _T>,
49     ) -> wasmtime::Result<TheWorld> {
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> TheWorldPre<_T> {
56     /// Same as [`Self::instantiate`], except with `async`.
instantiate_async( &self, mut store: impl wasmtime::AsContextMut<Data = _T>, ) -> wasmtime::Result<TheWorld>57     pub async fn instantiate_async(
58         &self,
59         mut store: impl wasmtime::AsContextMut<Data = _T>,
60     ) -> wasmtime::Result<TheWorld> {
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 /// `the-world`.
68 ///
69 /// This is an implementation detail of [`TheWorldPre`] and can
70 /// be constructed if needed as well.
71 ///
72 /// For more information see [`TheWorld`] as well.
73 #[derive(Clone)]
74 pub struct TheWorldIndices {
75     interface0: exports::foo::foo::floats::GuestIndices,
76 }
77 /// Auto-generated bindings for an instance a component which
78 /// implements the world `the-world`.
79 ///
80 /// This structure can be created through a number of means
81 /// depending on your requirements and what you have on hand:
82 ///
83 /// * The most convenient way is to use
84 ///   [`TheWorld::instantiate`] which only needs a
85 ///   [`Store`], [`Component`], and [`Linker`].
86 ///
87 /// * Alternatively you can create a [`TheWorldPre`] ahead of
88 ///   time with a [`Component`] to front-load string lookups
89 ///   of exports once instead of per-instantiation. This
90 ///   method then uses [`TheWorldPre::instantiate`] to
91 ///   create a [`TheWorld`].
92 ///
93 /// * If you've instantiated the instance yourself already
94 ///   then you can use [`TheWorld::new`].
95 ///
96 /// These methods are all equivalent to one another and move
97 /// around the tradeoff of what work is performed when.
98 ///
99 /// [`Store`]: wasmtime::Store
100 /// [`Component`]: wasmtime::component::Component
101 /// [`Linker`]: wasmtime::component::Linker
102 pub struct TheWorld {
103     interface0: exports::foo::foo::floats::Guest,
104 }
105 const _: () = {
106     impl TheWorldIndices {
107         /// Creates a new copy of `TheWorldIndices` bindings which can then
108         /// be used to instantiate into a particular store.
109         ///
110         /// This method may fail if the component does not have the
111         /// required exports.
new<_T>( _instance_pre: &wasmtime::component::InstancePre<_T>, ) -> wasmtime::Result<Self>112         pub fn new<_T>(
113             _instance_pre: &wasmtime::component::InstancePre<_T>,
114         ) -> wasmtime::Result<Self> {
115             let _component = _instance_pre.component();
116             let _instance_type = _instance_pre.instance_type();
117             let interface0 = exports::foo::foo::floats::GuestIndices::new(
118                 _instance_pre,
119             )?;
120             Ok(TheWorldIndices { interface0 })
121         }
122         /// Uses the indices stored in `self` to load an instance
123         /// of [`TheWorld`] from the instance provided.
124         ///
125         /// Note that at this time this method will additionally
126         /// perform type-checks of all exports.
load( &self, mut store: impl wasmtime::AsContextMut, instance: &wasmtime::component::Instance, ) -> wasmtime::Result<TheWorld>127         pub fn load(
128             &self,
129             mut store: impl wasmtime::AsContextMut,
130             instance: &wasmtime::component::Instance,
131         ) -> wasmtime::Result<TheWorld> {
132             let _ = &mut store;
133             let _instance = instance;
134             let interface0 = self.interface0.load(&mut store, &_instance)?;
135             Ok(TheWorld { interface0 })
136         }
137     }
138     impl TheWorld {
139         /// Convenience wrapper around [`TheWorldPre::new`] and
140         /// [`TheWorldPre::instantiate`].
instantiate<_T>( store: impl wasmtime::AsContextMut<Data = _T>, component: &wasmtime::component::Component, linker: &wasmtime::component::Linker<_T>, ) -> wasmtime::Result<TheWorld>141         pub fn instantiate<_T>(
142             store: impl wasmtime::AsContextMut<Data = _T>,
143             component: &wasmtime::component::Component,
144             linker: &wasmtime::component::Linker<_T>,
145         ) -> wasmtime::Result<TheWorld> {
146             let pre = linker.instantiate_pre(component)?;
147             TheWorldPre::new(pre)?.instantiate(store)
148         }
149         /// Convenience wrapper around [`TheWorldIndices::new`] and
150         /// [`TheWorldIndices::load`].
new( mut store: impl wasmtime::AsContextMut, instance: &wasmtime::component::Instance, ) -> wasmtime::Result<TheWorld>151         pub fn new(
152             mut store: impl wasmtime::AsContextMut,
153             instance: &wasmtime::component::Instance,
154         ) -> wasmtime::Result<TheWorld> {
155             let indices = TheWorldIndices::new(&instance.instance_pre(&store))?;
156             indices.load(&mut store, instance)
157         }
158         /// Convenience wrapper around [`TheWorldPre::new`] and
159         /// [`TheWorldPre::instantiate_async`].
instantiate_async<_T>( store: impl wasmtime::AsContextMut<Data = _T>, component: &wasmtime::component::Component, linker: &wasmtime::component::Linker<_T>, ) -> wasmtime::Result<TheWorld> where _T: Send,160         pub async fn instantiate_async<_T>(
161             store: impl wasmtime::AsContextMut<Data = _T>,
162             component: &wasmtime::component::Component,
163             linker: &wasmtime::component::Linker<_T>,
164         ) -> wasmtime::Result<TheWorld>
165         where
166             _T: Send,
167         {
168             let pre = linker.instantiate_pre(component)?;
169             TheWorldPre::new(pre)?.instantiate_async(store).await
170         }
add_to_linker<T, D>( linker: &mut wasmtime::component::Linker<T>, host_getter: fn(&mut T) -> D::Data<'_>, ) -> wasmtime::Result<()> where D: foo::foo::floats::HostWithStore + Send, for<'a> D::Data<'a>: foo::foo::floats::Host + Send, T: 'static + Send,171         pub fn add_to_linker<T, D>(
172             linker: &mut wasmtime::component::Linker<T>,
173             host_getter: fn(&mut T) -> D::Data<'_>,
174         ) -> wasmtime::Result<()>
175         where
176             D: foo::foo::floats::HostWithStore + Send,
177             for<'a> D::Data<'a>: foo::foo::floats::Host + Send,
178             T: 'static + Send,
179         {
180             foo::foo::floats::add_to_linker::<T, D>(linker, host_getter)?;
181             Ok(())
182         }
foo_foo_floats(&self) -> &exports::foo::foo::floats::Guest183         pub fn foo_foo_floats(&self) -> &exports::foo::foo::floats::Guest {
184             &self.interface0
185         }
186     }
187 };
188 pub mod foo {
189     pub mod foo {
190         #[allow(clippy::all)]
191         pub mod floats {
192             #[allow(unused_imports)]
193             use wasmtime::component::__internal::Box;
194             pub trait HostWithStore: wasmtime::component::HasData + Send {}
195             impl<_T: ?Sized> HostWithStore for _T
196             where
197                 _T: wasmtime::component::HasData + Send,
198             {}
199             pub trait Host: Send {
f32_param( &mut self, x: f32, ) -> impl ::core::future::Future<Output = ()> + Send200                 fn f32_param(
201                     &mut self,
202                     x: f32,
203                 ) -> impl ::core::future::Future<Output = ()> + Send;
f64_param( &mut self, x: f64, ) -> impl ::core::future::Future<Output = ()> + Send204                 fn f64_param(
205                     &mut self,
206                     x: f64,
207                 ) -> impl ::core::future::Future<Output = ()> + Send;
f32_result( &mut self, ) -> impl ::core::future::Future<Output = f32> + Send208                 fn f32_result(
209                     &mut self,
210                 ) -> impl ::core::future::Future<Output = f32> + Send;
f64_result( &mut self, ) -> impl ::core::future::Future<Output = f64> + Send211                 fn f64_result(
212                     &mut self,
213                 ) -> impl ::core::future::Future<Output = f64> + Send;
214             }
215             impl<_T: Host + ?Sized + Send> Host for &mut _T {
f32_param( &mut self, x: f32, ) -> impl ::core::future::Future<Output = ()> + Send216                 fn f32_param(
217                     &mut self,
218                     x: f32,
219                 ) -> impl ::core::future::Future<Output = ()> + Send {
220                     async move { Host::f32_param(*self, x).await }
221                 }
f64_param( &mut self, x: f64, ) -> impl ::core::future::Future<Output = ()> + Send222                 fn f64_param(
223                     &mut self,
224                     x: f64,
225                 ) -> impl ::core::future::Future<Output = ()> + Send {
226                     async move { Host::f64_param(*self, x).await }
227                 }
f32_result( &mut self, ) -> impl ::core::future::Future<Output = f32> + Send228                 fn f32_result(
229                     &mut self,
230                 ) -> impl ::core::future::Future<Output = f32> + Send {
231                     async move { Host::f32_result(*self).await }
232                 }
f64_result( &mut self, ) -> impl ::core::future::Future<Output = f64> + Send233                 fn f64_result(
234                     &mut self,
235                 ) -> impl ::core::future::Future<Output = f64> + Send {
236                     async move { Host::f64_result(*self).await }
237                 }
238             }
add_to_linker<T, D>( linker: &mut wasmtime::component::Linker<T>, host_getter: fn(&mut T) -> D::Data<'_>, ) -> wasmtime::Result<()> where D: HostWithStore, for<'a> D::Data<'a>: Host, T: 'static + Send,239             pub fn add_to_linker<T, D>(
240                 linker: &mut wasmtime::component::Linker<T>,
241                 host_getter: fn(&mut T) -> D::Data<'_>,
242             ) -> wasmtime::Result<()>
243             where
244                 D: HostWithStore,
245                 for<'a> D::Data<'a>: Host,
246                 T: 'static + Send,
247             {
248                 let mut inst = linker.instance("foo:foo/floats")?;
249                 inst.func_wrap_async(
250                     "f32-param",
251                     move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (f32,)| {
252                         wasmtime::component::__internal::Box::new(async move {
253                             let host = &mut host_getter(caller.data_mut());
254                             let r = Host::f32_param(host, arg0).await;
255                             Ok(r)
256                         })
257                     },
258                 )?;
259                 inst.func_wrap_async(
260                     "f64-param",
261                     move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (f64,)| {
262                         wasmtime::component::__internal::Box::new(async move {
263                             let host = &mut host_getter(caller.data_mut());
264                             let r = Host::f64_param(host, arg0).await;
265                             Ok(r)
266                         })
267                     },
268                 )?;
269                 inst.func_wrap_async(
270                     "f32-result",
271                     move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
272                         wasmtime::component::__internal::Box::new(async move {
273                             let host = &mut host_getter(caller.data_mut());
274                             let r = Host::f32_result(host).await;
275                             Ok((r,))
276                         })
277                     },
278                 )?;
279                 inst.func_wrap_async(
280                     "f64-result",
281                     move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
282                         wasmtime::component::__internal::Box::new(async move {
283                             let host = &mut host_getter(caller.data_mut());
284                             let r = Host::f64_result(host).await;
285                             Ok((r,))
286                         })
287                     },
288                 )?;
289                 Ok(())
290             }
291         }
292     }
293 }
294 pub mod exports {
295     pub mod foo {
296         pub mod foo {
297             #[allow(clippy::all)]
298             pub mod floats {
299                 #[allow(unused_imports)]
300                 use wasmtime::component::__internal::Box;
301                 #[derive(Clone)]
302                 pub struct Guest {
303                     f32_param: wasmtime::component::Func,
304                     f64_param: wasmtime::component::Func,
305                     f32_result: wasmtime::component::Func,
306                     f64_result: wasmtime::component::Func,
307                 }
308                 #[derive(Clone)]
309                 pub struct GuestIndices {
310                     f32_param: wasmtime::component::ComponentExportIndex,
311                     f64_param: wasmtime::component::ComponentExportIndex,
312                     f32_result: wasmtime::component::ComponentExportIndex,
313                     f64_result: wasmtime::component::ComponentExportIndex,
314                 }
315                 impl GuestIndices {
316                     /// Constructor for [`GuestIndices`] which takes a
317                     /// [`Component`](wasmtime::component::Component) as input and can be executed
318                     /// before instantiation.
319                     ///
320                     /// This constructor can be used to front-load string lookups to find exports
321                     /// within a component.
new<_T>( _instance_pre: &wasmtime::component::InstancePre<_T>, ) -> wasmtime::Result<GuestIndices>322                     pub fn new<_T>(
323                         _instance_pre: &wasmtime::component::InstancePre<_T>,
324                     ) -> wasmtime::Result<GuestIndices> {
325                         let instance = _instance_pre
326                             .component()
327                             .get_export_index(None, "foo:foo/floats")
328                             .ok_or_else(|| {
329                                 wasmtime::format_err!(
330                                     "no exported instance named `foo:foo/floats`"
331                                 )
332                             })?;
333                         let mut lookup = move |name| {
334                             _instance_pre
335                                 .component()
336                                 .get_export_index(Some(&instance), name)
337                                 .ok_or_else(|| {
338                                     wasmtime::format_err!(
339                                         "instance export `foo:foo/floats` does \
340                         not have export `{name}`"
341                                     )
342                                 })
343                         };
344                         let _ = &mut lookup;
345                         let f32_param = lookup("f32-param")?;
346                         let f64_param = lookup("f64-param")?;
347                         let f32_result = lookup("f32-result")?;
348                         let f64_result = lookup("f64-result")?;
349                         Ok(GuestIndices {
350                             f32_param,
351                             f64_param,
352                             f32_result,
353                             f64_result,
354                         })
355                     }
load( &self, mut store: impl wasmtime::AsContextMut, instance: &wasmtime::component::Instance, ) -> wasmtime::Result<Guest>356                     pub fn load(
357                         &self,
358                         mut store: impl wasmtime::AsContextMut,
359                         instance: &wasmtime::component::Instance,
360                     ) -> wasmtime::Result<Guest> {
361                         let _instance = instance;
362                         let _instance_pre = _instance.instance_pre(&store);
363                         let _instance_type = _instance_pre.instance_type();
364                         let mut store = store.as_context_mut();
365                         let _ = &mut store;
366                         let f32_param = *_instance
367                             .get_typed_func::<(f32,), ()>(&mut store, &self.f32_param)?
368                             .func();
369                         let f64_param = *_instance
370                             .get_typed_func::<(f64,), ()>(&mut store, &self.f64_param)?
371                             .func();
372                         let f32_result = *_instance
373                             .get_typed_func::<(), (f32,)>(&mut store, &self.f32_result)?
374                             .func();
375                         let f64_result = *_instance
376                             .get_typed_func::<(), (f64,)>(&mut store, &self.f64_result)?
377                             .func();
378                         Ok(Guest {
379                             f32_param,
380                             f64_param,
381                             f32_result,
382                             f64_result,
383                         })
384                     }
385                 }
386                 impl Guest {
call_f32_param<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: f32, ) -> wasmtime::Result<()> where <S as wasmtime::AsContext>::Data: Send,387                     pub async fn call_f32_param<S: wasmtime::AsContextMut>(
388                         &self,
389                         mut store: S,
390                         arg0: f32,
391                     ) -> wasmtime::Result<()>
392                     where
393                         <S as wasmtime::AsContext>::Data: Send,
394                     {
395                         let callee = unsafe {
396                             wasmtime::component::TypedFunc::<
397                                 (f32,),
398                                 (),
399                             >::new_unchecked(self.f32_param)
400                         };
401                         let () = callee
402                             .call_async(store.as_context_mut(), (arg0,))
403                             .await?;
404                         Ok(())
405                     }
call_f64_param<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: f64, ) -> wasmtime::Result<()> where <S as wasmtime::AsContext>::Data: Send,406                     pub async fn call_f64_param<S: wasmtime::AsContextMut>(
407                         &self,
408                         mut store: S,
409                         arg0: f64,
410                     ) -> wasmtime::Result<()>
411                     where
412                         <S as wasmtime::AsContext>::Data: Send,
413                     {
414                         let callee = unsafe {
415                             wasmtime::component::TypedFunc::<
416                                 (f64,),
417                                 (),
418                             >::new_unchecked(self.f64_param)
419                         };
420                         let () = callee
421                             .call_async(store.as_context_mut(), (arg0,))
422                             .await?;
423                         Ok(())
424                     }
call_f32_result<S: wasmtime::AsContextMut>( &self, mut store: S, ) -> wasmtime::Result<f32> where <S as wasmtime::AsContext>::Data: Send,425                     pub async fn call_f32_result<S: wasmtime::AsContextMut>(
426                         &self,
427                         mut store: S,
428                     ) -> wasmtime::Result<f32>
429                     where
430                         <S as wasmtime::AsContext>::Data: Send,
431                     {
432                         let callee = unsafe {
433                             wasmtime::component::TypedFunc::<
434                                 (),
435                                 (f32,),
436                             >::new_unchecked(self.f32_result)
437                         };
438                         let (ret0,) = callee
439                             .call_async(store.as_context_mut(), ())
440                             .await?;
441                         Ok(ret0)
442                     }
call_f64_result<S: wasmtime::AsContextMut>( &self, mut store: S, ) -> wasmtime::Result<f64> where <S as wasmtime::AsContext>::Data: Send,443                     pub async fn call_f64_result<S: wasmtime::AsContextMut>(
444                         &self,
445                         mut store: S,
446                     ) -> wasmtime::Result<f64>
447                     where
448                         <S as wasmtime::AsContext>::Data: Send,
449                     {
450                         let callee = unsafe {
451                             wasmtime::component::TypedFunc::<
452                                 (),
453                                 (f64,),
454                             >::new_unchecked(self.f64_result)
455                         };
456                         let (ret0,) = callee
457                             .call_async(store.as_context_mut(), ())
458                             .await?;
459                         Ok(ret0)
460                     }
461                 }
462             }
463         }
464     }
465 }
466