// the data struct I want to push into ResourceTable, it has a  reference typed field `map`
pub struct MapKeyIter<'a> {
    map: &'a MapHandle,
    prev: Option<Vec<u8>>,
    next: Vec<u8>,
}

// bindgen!() generates Trait definition

            pub trait HostMapKeyIter {
                fn next(
                    &mut self,
                    self_: wasmtime::component::Resource<MapKeyIter>,
                ) -> wasmtime::Result<Result<Option<Value>, ()>>;
                fn drop(
                    &mut self,
                    rep: wasmtime::component::Resource<MapKeyIter>,
                ) -> wasmtime::Result<()>;
            }


// My impl code of `HostMapKeyIter` trait

impl<'a, State> ebpf::HostMapKeyIter for BpfCtx<'a, State> {
    fn next(
        &mut self,
        self_: wasmtime::component::Resource<libbpf_rs::MapKeyIter>,
    ) -> Result<Result<Option<Vec<u8>>, ()>, wasmtime::Error> {
        let map_key_iter: &'_ mut libbpf_rs::MapKeyIter = self.table.get_mut(&self_)?;
        Ok(Ok(map_key_iter.next()))
    }

    fn drop(
        &mut self,
        rep: wasmtime::component::Resource<libbpf_rs::MapKeyIter>,
    ) -> wasmtime::Result<()> {
        self.table.delete(rep)?;
        Ok(())
    }
}

    fn next(
        &mut self,
        self_: wasmtime::component::Resource<libbpf_rs::MapKeyIter<'a>>,
    ) -> Result<Result<Option<Vec<u8>>, ()>, wasmtime::Error> {

            pub trait HostMapKeyIter<'a> {
                fn next(
                    &mut self,
                    self_: wasmtime::component::Resource<MapKeyIter<'a>>,
                ) -> wasmtime::Result<Result<Option<Value>, ()>>;
                fn drop(
                    &mut self,
                    rep: wasmtime::component::Resource<MapKeyIter<'a>>,
                ) -> wasmtime::Result<()>;
            }

            uwriteln!(self.src, "pub trait Host{camel} {{");

    fn generate_function_trait_sig(&mut self, func: &Function) {
        let wt = self.gen.wasmtime_path();
        self.rustdoc(&func.docs);

        if self.gen.opts.async_.is_import_async(&func.name) {
            self.push_str("async ");
        }
        self.push_str("fn ");
        self.push_str(&rust_function_name(func));
        self.push_str("(&mut self, ");
        for (name, param) in func.params.iter() {
            let name = to_rust_ident(name);
            self.push_str(&name);
            self.push_str(": ");
            self.print_ty(param, **TypeMode::Owned**);
            self.push_str(",");
        }