Method export_interface

crates/csharp/src/world_generator.rs:259–305

(
        &mut self,
        resolve: &Resolve,
        key: &WorldKey,
        id: InterfaceId,
        _files: &mut Files,
    )

    }

    fn export_interface(
        &mut self,
        resolve: &Resolve,
        key: &WorldKey,
        id: InterfaceId,
        _files: &mut Files,
    ) -> anyhow::Result<()> {
        let name = interface_name(self, resolve, key, Direction::Export);
        self.interface_names.insert(id, name.clone());
        let mut r#gen = self.interface(resolve, &name, Direction::Export, false);

        let mut old_resources = mem::take(&mut r#gen.csharp_gen.all_resources);
        r#gen.types(id);
        let new_resources = mem::take(&mut r#gen.csharp_gen.all_resources);
        old_resources.extend(new_resources.clone());
        r#gen.csharp_gen.all_resources = old_resources;
        for (resource, funcs) in by_resource(
            resolve.interfaces[id]
                .functions
                .iter()
                .map(|(k, v)| (k.as_str(), v)),
            new_resources.keys().copied(),
        ) {
            if let Some(resource) = resource {
                r#gen.start_resource(resource, Some(key));
            }

            for func in funcs {
                r#gen.export(func, Some(key));
            }

            if resource.is_some() {
                r#gen.end_resource();
            }
        }

        // for anonymous types
        r#gen.define_interface_types(id);

        let import_module_name = &resolve.name_world_key(key);
        r#gen.add_futures_or_streams(&format!("[export]{import_module_name}"), true, true);

        r#gen.add_futures_or_streams(&format!("[export]{import_module_name}"), true, false);

        r#gen.add_interface_fragment(true);
        Ok(())
    }

    fn export_funcs(
        &mut self,