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> { 14 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. 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 } 33 pub fn engine(&self) -> &wasmtime::Engine { 34 self.instance_pre.engine() 35 } 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. 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`. 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::chars::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::chars::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. 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::chars::GuestIndices::new(_instance_pre)?; 118 Ok(TheWorldIndices { interface0 }) 119 } 120 /// Uses the indices stored in `self` to load an instance 121 /// of [`TheWorld`] from the instance provided. 122 /// 123 /// Note that at this time this method will additionally 124 /// perform type-checks of all exports. 125 pub fn load( 126 &self, 127 mut store: impl wasmtime::AsContextMut, 128 instance: &wasmtime::component::Instance, 129 ) -> wasmtime::Result<TheWorld> { 130 let _ = &mut store; 131 let _instance = instance; 132 let interface0 = self.interface0.load(&mut store, &_instance)?; 133 Ok(TheWorld { interface0 }) 134 } 135 } 136 impl TheWorld { 137 /// Convenience wrapper around [`TheWorldPre::new`] and 138 /// [`TheWorldPre::instantiate`]. 139 pub fn instantiate<_T>( 140 store: impl wasmtime::AsContextMut<Data = _T>, 141 component: &wasmtime::component::Component, 142 linker: &wasmtime::component::Linker<_T>, 143 ) -> wasmtime::Result<TheWorld> { 144 let pre = linker.instantiate_pre(component)?; 145 TheWorldPre::new(pre)?.instantiate(store) 146 } 147 /// Convenience wrapper around [`TheWorldIndices::new`] and 148 /// [`TheWorldIndices::load`]. 149 pub fn new( 150 mut store: impl wasmtime::AsContextMut, 151 instance: &wasmtime::component::Instance, 152 ) -> wasmtime::Result<TheWorld> { 153 let indices = TheWorldIndices::new(&instance.instance_pre(&store))?; 154 indices.load(&mut store, instance) 155 } 156 /// Convenience wrapper around [`TheWorldPre::new`] and 157 /// [`TheWorldPre::instantiate_async`]. 158 pub async fn instantiate_async<_T>( 159 store: impl wasmtime::AsContextMut<Data = _T>, 160 component: &wasmtime::component::Component, 161 linker: &wasmtime::component::Linker<_T>, 162 ) -> wasmtime::Result<TheWorld> 163 where 164 _T: Send, 165 { 166 let pre = linker.instantiate_pre(component)?; 167 TheWorldPre::new(pre)?.instantiate_async(store).await 168 } 169 pub fn add_to_linker<T, D>( 170 linker: &mut wasmtime::component::Linker<T>, 171 host_getter: fn(&mut T) -> D::Data<'_>, 172 ) -> wasmtime::Result<()> 173 where 174 D: foo::foo::chars::HostWithStore + Send, 175 for<'a> D::Data<'a>: foo::foo::chars::Host + Send, 176 T: 'static + Send, 177 { 178 foo::foo::chars::add_to_linker::<T, D>(linker, host_getter)?; 179 Ok(()) 180 } 181 pub fn foo_foo_chars(&self) -> &exports::foo::foo::chars::Guest { 182 &self.interface0 183 } 184 } 185 }; 186 pub mod foo { 187 pub mod foo { 188 #[allow(clippy::all)] 189 pub mod chars { 190 #[allow(unused_imports)] 191 use wasmtime::component::__internal::Box; 192 pub trait HostWithStore: wasmtime::component::HasData + Send { 193 /// A function that accepts a character 194 fn take_char<T: Send>( 195 accessor: &wasmtime::component::Accessor<T, Self>, 196 x: char, 197 ) -> impl ::core::future::Future<Output = ()> + Send; 198 /// A function that returns a character 199 fn return_char<T: Send>( 200 accessor: &wasmtime::component::Accessor<T, Self>, 201 ) -> impl ::core::future::Future<Output = char> + Send; 202 } 203 pub trait Host: Send {} 204 impl<_T: Host + ?Sized + Send> Host for &mut _T {} 205 pub fn add_to_linker<T, D>( 206 linker: &mut wasmtime::component::Linker<T>, 207 host_getter: fn(&mut T) -> D::Data<'_>, 208 ) -> wasmtime::Result<()> 209 where 210 D: HostWithStore, 211 for<'a> D::Data<'a>: Host, 212 T: 'static + Send, 213 { 214 let mut inst = linker.instance("foo:foo/chars")?; 215 inst.func_wrap_concurrent( 216 "take-char", 217 move |caller: &wasmtime::component::Accessor<T>, (arg0,): (char,)| { 218 wasmtime::component::__internal::Box::pin(async move { 219 let host = &caller.with_getter(host_getter); 220 let r = <D as HostWithStore>::take_char(host, arg0).await; 221 Ok(r) 222 }) 223 }, 224 )?; 225 inst.func_wrap_concurrent( 226 "return-char", 227 move |caller: &wasmtime::component::Accessor<T>, (): ()| { 228 wasmtime::component::__internal::Box::pin(async move { 229 let host = &caller.with_getter(host_getter); 230 let r = <D as HostWithStore>::return_char(host).await; 231 Ok((r,)) 232 }) 233 }, 234 )?; 235 Ok(()) 236 } 237 } 238 } 239 } 240 pub mod exports { 241 pub mod foo { 242 pub mod foo { 243 #[allow(clippy::all)] 244 pub mod chars { 245 #[allow(unused_imports)] 246 use wasmtime::component::__internal::Box; 247 #[derive(Clone)] 248 pub struct Guest { 249 take_char: wasmtime::component::Func, 250 return_char: wasmtime::component::Func, 251 } 252 #[derive(Clone)] 253 pub struct GuestIndices { 254 take_char: wasmtime::component::ComponentExportIndex, 255 return_char: wasmtime::component::ComponentExportIndex, 256 } 257 impl GuestIndices { 258 /// Constructor for [`GuestIndices`] which takes a 259 /// [`Component`](wasmtime::component::Component) as input and can be executed 260 /// before instantiation. 261 /// 262 /// This constructor can be used to front-load string lookups to find exports 263 /// within a component. 264 pub fn new<_T>( 265 _instance_pre: &wasmtime::component::InstancePre<_T>, 266 ) -> wasmtime::Result<GuestIndices> { 267 let instance = _instance_pre 268 .component() 269 .get_export_index(None, "foo:foo/chars") 270 .ok_or_else(|| { 271 wasmtime::format_err!( 272 "no exported instance named `foo:foo/chars`" 273 ) 274 })?; 275 let mut lookup = move |name| { 276 _instance_pre 277 .component() 278 .get_export_index(Some(&instance), name) 279 .ok_or_else(|| { 280 wasmtime::format_err!( 281 "instance export `foo:foo/chars` does \ 282 not have export `{name}`" 283 ) 284 }) 285 }; 286 let _ = &mut lookup; 287 let take_char = lookup("take-char")?; 288 let return_char = lookup("return-char")?; 289 Ok(GuestIndices { 290 take_char, 291 return_char, 292 }) 293 } 294 pub fn load( 295 &self, 296 mut store: impl wasmtime::AsContextMut, 297 instance: &wasmtime::component::Instance, 298 ) -> wasmtime::Result<Guest> { 299 let _instance = instance; 300 let _instance_pre = _instance.instance_pre(&store); 301 let _instance_type = _instance_pre.instance_type(); 302 let mut store = store.as_context_mut(); 303 let _ = &mut store; 304 let take_char = *_instance 305 .get_typed_func::<(char,), ()>(&mut store, &self.take_char)? 306 .func(); 307 let return_char = *_instance 308 .get_typed_func::< 309 (), 310 (char,), 311 >(&mut store, &self.return_char)? 312 .func(); 313 Ok(Guest { take_char, return_char }) 314 } 315 } 316 impl Guest { 317 /// A function that accepts a character 318 pub async fn call_take_char<_T, _D>( 319 &self, 320 accessor: &wasmtime::component::Accessor<_T, _D>, 321 arg0: char, 322 ) -> wasmtime::Result<()> 323 where 324 _T: Send, 325 _D: wasmtime::component::HasData, 326 { 327 let callee = unsafe { 328 wasmtime::component::TypedFunc::< 329 (char,), 330 (), 331 >::new_unchecked(self.take_char) 332 }; 333 let ((), _) = callee.call_concurrent(accessor, (arg0,)).await?; 334 Ok(()) 335 } 336 /// A function that returns a character 337 pub async fn call_return_char<_T, _D>( 338 &self, 339 accessor: &wasmtime::component::Accessor<_T, _D>, 340 ) -> wasmtime::Result<char> 341 where 342 _T: Send, 343 _D: wasmtime::component::HasData, 344 { 345 let callee = unsafe { 346 wasmtime::component::TypedFunc::< 347 (), 348 (char,), 349 >::new_unchecked(self.return_char) 350 }; 351 let ((ret0,), _) = callee.call_concurrent(accessor, ()).await?; 352 Ok(ret0) 353 } 354 } 355 } 356 } 357 } 358 } 359