search

fzyzcjy / flutter_rust_bridge

Flutter/Dart <-> Rust binding generator, feature-rich, but seamless and simple.
https://fzyzcjy.github.io/flutter_rust_bridge/
MIT License
3.75k stars 268 forks source link

String type mismatch when using `impl Fn(&String) -> DartFnFuture<String>` #2184

Closed juliankrieger closed 3 days ago

juliankrieger commented 6 days ago

Describe the bug

When using &String in an impl Fn, I get the following error.

Steps to reproduce

#[derive(Clone)]
struct FFIBLECommunicator {
    //pub ffi_send_pvr_trigger: &'static (dyn Fn(&brski_prm_artifacts::pvr::trigger::Trigger, &String) -> DartFnFuture<String> + Sync + Send),
    // create place to store the function
    ffi_send_pvr_trigger: Arc<Box<dyn Fn(String, String) -> DartFnFuture<String> + Sync + Send>>
}

impl FFIBLECommunicator {
    pub fn new(ffi_send_pvr_trigger: impl Fn(String, String) -> DartFnFuture<String> + Sync + Send + 'static) -> Self {
        Self {
            ffi_send_pvr_trigger: Arc::new(Box::new(ffi_send_pvr_trigger))
        }
    }
}

Logs

lib/src/rust/frb_generated.io.dart:251:11: Error: The argument type 'String/*1*/' can't be assigned to the parameter type 'String/*2*/'.
 - 'String/*1*/' is from 'dart:core'.
 - 'String/*2*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
          'frbgen_flutter_app_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerFFIBLECommunicator');
          ^
lib/src/rust/frb_generated.io.dart:267:11: Error: The argument type 'String/*1*/' can't be assigned to the parameter type 'String/*2*/'.
 - 'String/*1*/' is from 'dart:core'.
 - 'String/*2*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
          'frbgen_flutter_app_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerFFIBLECommunicator');
          ^
lib/src/rust/frb_generated.io.dart:283:11: Error: The argument type 'String/*1*/' can't be assigned to the parameter type 'String/*2*/'.
 - 'String/*1*/' is from 'dart:core'.
 - 'String/*2*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
          'frbgen_flutter_app_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerParsedConfig');
          ^
lib/src/rust/frb_generated.io.dart:299:11: Error: The argument type 'String/*1*/' can't be assigned to the parameter type 'String/*2*/'.
 - 'String/*1*/' is from 'dart:core'.
 - 'String/*2*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
          'frbgen_flutter_app_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerParsedConfig');
          ^
lib/src/rust/frb_generated.io.dart:315:11: Error: The argument type 'String/*1*/' can't be assigned to the parameter type 'String/*2*/'.
 - 'String/*1*/' is from 'dart:core'.
 - 'String/*2*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
          'frbgen_flutter_app_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString');
          ^
lib/src/rust/frb_generated.io.dart:331:11: Error: The argument type 'String/*1*/' can't be assigned to the parameter type 'String/*2*/'.
 - 'String/*1*/' is from 'dart:core'.
 - 'String/*2*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
          'frbgen_flutter_app_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString');
          ^
lib/src/rust/frb_generated.dart:58:14: Error: The return type of the method 'RustLib.codegenVersion' is 'String/*1*/', which does not match the return type, 'String/*2*/', of the overridden method, 'BaseEntrypoint.codegenVersion'.
 - 'String/*1*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
 - 'String/*2*/' is from 'dart:core'.
Change to a subtype of 'String/*2*/'.
  String get codegenVersion => '2.0.0';
             ^
../../../../../../.pub-cache/hosted/pub.dev/flutter_rust_bridge-2.0.0/lib/src/main_components/entrypoint.dart:118:14: Context: This is the overridden method ('codegenVersion').
  String get codegenVersion;
             ^
lib/main.dart:21:51: Error: The argument type 'String/*1*/' can't be assigned to the parameter type 'String/*2*/'.
 - 'String/*1*/' is from 'dart:core'.
 - 'String/*2*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
    ParsedConfig parsedConfig = getConfig(eeCert: eeCert, eeKey: eeKeyNoPass, registrarCert: registrarCert);
                                                  ^
lib/main.dart:21:66: Error: The argument type 'String/*1*/' can't be assigned to the parameter type 'String/*2*/'.
 - 'String/*1*/' is from 'dart:core'.
 - 'String/*2*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
    ParsedConfig parsedConfig = getConfig(eeCert: eeCert, eeKey: eeKeyNoPass, registrarCert: registrarCert);
                                                                 ^
lib/main.dart:21:94: Error: The argument type 'String/*1*/' can't be assigned to the parameter type 'String/*2*/'.
 - 'String/*1*/' is from 'dart:core'.
 - 'String/*2*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
    ParsedConfig parsedConfig = getConfig(eeCert: eeCert, eeKey: eeKeyNoPass, registrarCert: registrarCert);
                                                                                          ^
lib/main.dart:23:21: Error: A value of type 'String/*1*/' can't be assigned to a variable of type 'String/*2*/'.
 - 'String/*1*/' is from 'dart:core'.
 - 'String/*2*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
    String serial = "123456789";
                    ^
lib/main.dart:40:77: Error: The argument type 'String/*1*/' can't be assigned to the parameter type 'String/*2*/'.
 - 'String/*1*/' is from 'dart:core'.
 - 'String/*2*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
                  'Action: Call Rust `greet("Tom")`\nResult: `${greet(name: "Tom")}`'),
                                                                            ^
lib/src/rust/frb_generated.dart:58:32: Error: A value of type 'String/*1*/' can't be returned from a function with return type 'String/*2*/'.
 - 'String/*1*/' is from 'dart:core'.
 - 'String/*2*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
  String get codegenVersion => '2.0.0';
                               ^
lib/src/rust/frb_generated.dart:314:32: Error: The argument type 'String/*1*/' can't be assigned to the parameter type 'String/*2*/'.
 - 'String/*1*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
 - 'String/*2*/' is from 'dart:core'.
    return AnyhowException(raw as String);
                               ^
lib/src/rust/frb_generated.dart:421:28: Error: The argument type 'String/*1*/' can't be assigned to the parameter type 'String/*2*/'.
 - 'String/*1*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
 - 'String/*2*/' is from 'dart:core'.
    return AnyhowException(inner);
                           ^
lib/src/rust/frb_generated.dart:498:25: Error: A value of type 'String/*1*/' can't be returned from a function with return type 'String/*2*/'.
 - 'String/*1*/' is from 'dart:core'.
 - 'String/*2*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
    return utf8.decoder.convert(inner);
                        ^
lib/src/rust/frb_generated.dart:541:28: Error: The argument type 'String/*1*/' can't be assigned to the parameter type 'String/*2*/'.
 - 'String/*1*/' is from 'dart:core'.
 - 'String/*2*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
    sse_encode_String(self.message, serializer);
                           ^
lib/src/rust/frb_generated.dart:637:58: Error: The argument type 'String/*1*/' can't be assigned to the parameter type 'String/*2*/'.
 - 'String/*1*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
 - 'String/*2*/' is from 'dart:core'.
    sse_encode_list_prim_u_8_strict(utf8.encoder.convert(self), serializer);
                                                         ^
lib/src/rust/frb_generated.io.dart:238:34: Error: A value of type 'Pointer<T> Function<T extends NativeType>(String/*1*/)' can't be assigned to a variable of type 'Pointer<T> Function<T extends NativeType>(String/*2*/)'.
 - 'Pointer' is from 'dart:ffi'.
 - 'NativeType' is from 'dart:ffi'.
 - 'String/*1*/' is from 'dart:core'.
 - 'String/*2*/' is from 'package:flutter_app/src/rust/api/simple.dart' ('lib/src/rust/api/simple.dart').
      : _lookup = dynamicLibrary.lookup;
                                 ^
Target kernel_snapshot failed: Exception

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':app:compileFlutterBuildDebug'.
> Process 'command '/Users/wintermute/Dev/flutter/bin/flutter'' finished with non-zero exit value 1

* Try:
> Run with --stacktrace option to get the stack trace.
> Run with --info or --debug option to get more log output.
> Run with --scan to get full insights.

* Get more help at https://help.gradle.org

BUILD FAILED in 1s
Error: Gradle task assembleDebug failed with exit code 1

### Expected behavior

_No response_

### Generated binding code

```shell
frb_generated-io.rs

// This file is automatically generated, so please do not edit it.
// Generated by `flutter_rust_bridge`@ 2.0.0.

// Section: imports

use super::*;
use crate::api::simple::*;
use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
use flutter_rust_bridge::{Handler, IntoIntoDart};

// Section: boilerplate

flutter_rust_bridge::frb_generated_boilerplate_io!();

#[no_mangle]
pub extern "C" fn frbgen_flutter_app_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerFFIBLECommunicator(
    ptr: *const std::ffi::c_void,
) {
    MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<FFIBLECommunicator>>::increment_strong_count(ptr as _);
}

#[no_mangle]
pub extern "C" fn frbgen_flutter_app_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerFFIBLECommunicator(
    ptr: *const std::ffi::c_void,
) {
    MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<FFIBLECommunicator>>::decrement_strong_count(ptr as _);
}

#[no_mangle]
pub extern "C" fn frbgen_flutter_app_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerParsedConfig(
    ptr: *const std::ffi::c_void,
) {
    MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ParsedConfig>>::increment_strong_count(ptr as _);
}

#[no_mangle]
pub extern "C" fn frbgen_flutter_app_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerParsedConfig(
    ptr: *const std::ffi::c_void,
) {
    MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ParsedConfig>>::decrement_strong_count(ptr as _);
}

#[no_mangle]
pub extern "C" fn frbgen_flutter_app_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString(
    ptr: *const std::ffi::c_void,
) {
    MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<String>>::increment_strong_count(ptr as _);
}

#[no_mangle]
pub extern "C" fn frbgen_flutter_app_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString(
    ptr: *const std::ffi::c_void,
) {
    MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<String>>::decrement_strong_count(ptr as _);
}

frb-generated.rs

// This file is automatically generated, so please do not edit it.
// Generated by `flutter_rust_bridge`@ 2.0.0.

#![allow(
    non_camel_case_types,
    unused,
    non_snake_case,
    clippy::needless_return,
    clippy::redundant_closure_call,
    clippy::redundant_closure,
    clippy::useless_conversion,
    clippy::unit_arg,
    clippy::unused_unit,
    clippy::double_parens,
    clippy::let_and_return,
    clippy::too_many_arguments,
    clippy::match_single_binding,
    clippy::clone_on_copy,
    clippy::let_unit_value,
    clippy::deref_addrof,
    clippy::explicit_auto_deref,
    clippy::borrow_deref_ref,
    clippy::needless_borrow
)]

// Section: imports

use crate::api::simple::*;
use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
use flutter_rust_bridge::{Handler, IntoIntoDart};

// Section: boilerplate

flutter_rust_bridge::frb_generated_boilerplate!(
    default_stream_sink_codec = SseCodec,
    default_rust_opaque = RustOpaqueMoi,
    default_rust_auto_opaque = RustAutoOpaqueMoi,
);
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.0.0";
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 1067309539;

// Section: executor

flutter_rust_bridge::frb_generated_default_handler!();

// Section: wire_funcs

fn wire__crate__api__simple__FfibleCommunicator_new_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::SseCodec,_,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "FfibleCommunicator_new", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_ffi_send_pvr_trigger = decode_DartFn_Inputs_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString_Output_String_AnyhowException(<flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer));deserializer.end(); move |context|  {
                    transform_result_sse::<_, ()>((move ||  {
                         let output_ok = Result::<_,()>::Ok(crate::api::simple::FFIBLECommunicator::new(api_ffi_send_pvr_trigger))?;  Ok(output_ok)
                    })())
                } })
}
fn wire__crate__api__simple__get_config_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "get_config",
            port: None,
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
        },
        move || {
            let message = unsafe {
                flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
                    ptr_,
                    rust_vec_len_,
                    data_len_,
                )
            };
            let mut deserializer =
                flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_ee_cert = <String>::sse_decode(&mut deserializer);
            let api_ee_key = <String>::sse_decode(&mut deserializer);
            let api_registrar_cert = <String>::sse_decode(&mut deserializer);
            deserializer.end();
            transform_result_sse::<_, ()>((move || {
                let output_ok = Result::<_, ()>::Ok(crate::api::simple::get_config(
                    api_ee_cert,
                    api_ee_key,
                    api_registrar_cert,
                ))?;
                Ok(output_ok)
            })())
        },
    )
}
fn wire__crate__api__simple__get_pvr_trigger_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "get_pvr_trigger",
            port: None,
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
        },
        move || {
            let message = unsafe {
                flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
                    ptr_,
                    rust_vec_len_,
                    data_len_,
                )
            };
            let mut deserializer =
                flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_parsed_config = <RustOpaqueMoi<
                flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ParsedConfig>,
            >>::sse_decode(&mut deserializer);
            let api_serial_number = <String>::sse_decode(&mut deserializer);
            deserializer.end();
            transform_result_sse::<_, ()>((move || {
                let mut api_parsed_config_guard = None;
                let decode_indices_ =
                    flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
                        flutter_rust_bridge::for_generated::LockableOrderInfo::new(
                            &api_parsed_config,
                            0,
                            false,
                        ),
                    ]);
                for i in decode_indices_ {
                    match i {
                        0 => {
                            api_parsed_config_guard =
                                Some(api_parsed_config.lockable_decode_sync_ref())
                        }
                        _ => unreachable!(),
                    }
                }
                let api_parsed_config_guard = api_parsed_config_guard.unwrap();
                let output_ok = Result::<_, ()>::Ok(crate::api::simple::get_pvr_trigger(
                    &*api_parsed_config_guard,
                    api_serial_number,
                ))?;
                Ok(output_ok)
            })())
        },
    )
}
fn wire__crate__api__simple__greet_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "greet",
            port: None,
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
        },
        move || {
            let message = unsafe {
                flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
                    ptr_,
                    rust_vec_len_,
                    data_len_,
                )
            };
            let mut deserializer =
                flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_name = <String>::sse_decode(&mut deserializer);
            deserializer.end();
            transform_result_sse::<_, ()>((move || {
                let output_ok = Result::<_, ()>::Ok(crate::api::simple::greet(api_name))?;
                Ok(output_ok)
            })())
        },
    )
}
fn wire__crate__api__simple__init_app_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::SseCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "init_app",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let message = unsafe {
                flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
                    ptr_,
                    rust_vec_len_,
                    data_len_,
                )
            };
            let mut deserializer =
                flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            deserializer.end();
            move |context| {
                transform_result_sse::<_, ()>((move || {
                    let output_ok = Result::<_, ()>::Ok({
                        crate::api::simple::init_app();
                    })?;
                    Ok(output_ok)
                })())
            }
        },
    )
}

// Section: related_funcs

fn decode_DartFn_Inputs_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString_Output_String_AnyhowException(
    dart_opaque: flutter_rust_bridge::DartOpaque,
) -> impl Fn(
    RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<String>>,
    RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<String>>,
) -> flutter_rust_bridge::DartFnFuture<String> {
    use flutter_rust_bridge::IntoDart;

    async fn body(
        dart_opaque: flutter_rust_bridge::DartOpaque,
        arg0: RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<String>>,
        arg1: RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<String>>,
    ) -> String {
        let args = vec![
            arg0.into_into_dart().into_dart(),
            arg1.into_into_dart().into_dart(),
        ];
        let message = FLUTTER_RUST_BRIDGE_HANDLER
            .dart_fn_invoke(dart_opaque, args)
            .await;

        let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
        let action = deserializer.cursor.read_u8().unwrap();
        let ans = match action {
            0 => std::result::Result::Ok(<String>::sse_decode(&mut deserializer)),
            1 => std::result::Result::Err(
                <flutter_rust_bridge::for_generated::anyhow::Error>::sse_decode(&mut deserializer),
            ),
            _ => unreachable!(),
        };
        deserializer.end();
        let ans = ans.expect("Dart throws exception but Rust side assume it is not failable");
        ans
    }

    move |arg0: RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<String>>,
          arg1: RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<String>>| {
        flutter_rust_bridge::for_generated::convert_into_dart_fn_future(body(
            dart_opaque.clone(),
            arg0,
            arg1,
        ))
    }
}
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
    flutter_rust_bridge::for_generated::RustAutoOpaqueInner<FFIBLECommunicator>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
    flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ParsedConfig>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
    flutter_rust_bridge::for_generated::RustAutoOpaqueInner<String>
);

// Section: dart2rust

impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
        let mut inner = <String>::sse_decode(deserializer);
        return flutter_rust_bridge::for_generated::anyhow::anyhow!("{}", inner);
    }
}

impl SseDecode for FFIBLECommunicator {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
        let mut inner = <RustOpaqueMoi<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<FFIBLECommunicator>,
        >>::sse_decode(deserializer);
        return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
    }
}

impl SseDecode for ParsedConfig {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
        let mut inner = <RustOpaqueMoi<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ParsedConfig>,
        >>::sse_decode(deserializer);
        return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
    }
}

impl SseDecode for flutter_rust_bridge::DartOpaque {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
        let mut inner = <usize>::sse_decode(deserializer);
        return unsafe { flutter_rust_bridge::for_generated::sse_decode_dart_opaque(inner) };
    }
}

impl SseDecode
    for RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<FFIBLECommunicator>>
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
        let mut inner = <usize>::sse_decode(deserializer);
        return decode_rust_opaque_moi(inner);
    }
}

impl SseDecode
    for RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ParsedConfig>>
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
        let mut inner = <usize>::sse_decode(deserializer);
        return decode_rust_opaque_moi(inner);
    }
}

impl SseDecode for RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<String>> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
        let mut inner = <usize>::sse_decode(deserializer);
        return decode_rust_opaque_moi(inner);
    }
}

impl SseDecode for String {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
        let mut inner = <Vec<u8>>::sse_decode(deserializer);
        return String::from_utf8(inner).unwrap();
    }
}

impl SseDecode for Vec<u8> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
        let mut len_ = <i32>::sse_decode(deserializer);
        let mut ans_ = vec![];
        for idx_ in 0..len_ {
            ans_.push(<u8>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for u8 {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
        deserializer.cursor.read_u8().unwrap()
    }
}

impl SseDecode for () {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
}

impl SseDecode for usize {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
        deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
    }
}

impl SseDecode for i32 {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
        deserializer.cursor.read_i32::<NativeEndian>().unwrap()
    }
}

impl SseDecode for bool {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
        deserializer.cursor.read_u8().unwrap() != 0
    }
}

fn pde_ffi_dispatcher_primary_impl(
    func_id: i32,
    port: flutter_rust_bridge::for_generated::MessagePort,
    ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len: i32,
    data_len: i32,
) {
    // Codec=Pde (Serialization + dispatch), see doc to use other codecs
    match func_id {
        1 => {
            wire__crate__api__simple__FfibleCommunicator_new_impl(port, ptr, rust_vec_len, data_len)
        }
        5 => wire__crate__api__simple__init_app_impl(port, ptr, rust_vec_len, data_len),
        _ => unreachable!(),
    }
}

fn pde_ffi_dispatcher_sync_impl(
    func_id: i32,
    ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len: i32,
    data_len: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    // Codec=Pde (Serialization + dispatch), see doc to use other codecs
    match func_id {
        2 => wire__crate__api__simple__get_config_impl(ptr, rust_vec_len, data_len),
        3 => wire__crate__api__simple__get_pvr_trigger_impl(ptr, rust_vec_len, data_len),
        4 => wire__crate__api__simple__greet_impl(ptr, rust_vec_len, data_len),
        _ => unreachable!(),
    }
}

// Section: rust2dart

// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<FFIBLECommunicator> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self.0)
            .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<FFIBLECommunicator>
{
}

impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<FFIBLECommunicator>> for FFIBLECommunicator {
    fn into_into_dart(self) -> FrbWrapper<FFIBLECommunicator> {
        self.into()
    }
}

// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<ParsedConfig> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self.0)
            .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<ParsedConfig> {}

impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<ParsedConfig>> for ParsedConfig {
    fn into_into_dart(self) -> FrbWrapper<ParsedConfig> {
        self.into()
    }
}

impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <String>::sse_encode(format!("{:?}", self), serializer);
    }
}

impl SseEncode for FFIBLECommunicator {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<FFIBLECommunicator>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer);
    }
}

impl SseEncode for ParsedConfig {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ParsedConfig>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer);
    }
}

impl SseEncode for flutter_rust_bridge::DartOpaque {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <usize>::sse_encode(self.encode(), serializer);
    }
}

impl SseEncode
    for RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<FFIBLECommunicator>>
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        let (ptr, size) = self.sse_encode_raw();
        <usize>::sse_encode(ptr, serializer);
        <i32>::sse_encode(size, serializer);
    }
}

impl SseEncode
    for RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ParsedConfig>>
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        let (ptr, size) = self.sse_encode_raw();
        <usize>::sse_encode(ptr, serializer);
        <i32>::sse_encode(size, serializer);
    }
}

impl SseEncode for RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<String>> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        let (ptr, size) = self.sse_encode_raw();
        <usize>::sse_encode(ptr, serializer);
        <i32>::sse_encode(size, serializer);
    }
}

impl SseEncode for String {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <Vec<u8>>::sse_encode(self.into_bytes(), serializer);
    }
}

impl SseEncode for Vec<u8> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <i32>::sse_encode(self.len() as _, serializer);
        for item in self {
            <u8>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for u8 {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        serializer.cursor.write_u8(self).unwrap();
    }
}

impl SseEncode for () {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
}

impl SseEncode for usize {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        serializer
            .cursor
            .write_u64::<NativeEndian>(self as _)
            .unwrap();
    }
}

impl SseEncode for i32 {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
    }
}

impl SseEncode for bool {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        serializer.cursor.write_u8(self as _).unwrap();
    }
}

#[cfg(not(target_family = "wasm"))]
#[path = "frb_generated.io.rs"]
mod io;
#[cfg(not(target_family = "wasm"))]
pub use io::*;

/// cbindgen:ignore
#[cfg(target_family = "wasm")]
#[path = "frb_generated.web.rs"]
mod web;
#[cfg(target_family = "wasm")]
pub use web::*;

frb-generated.dart

// This file is automatically generated, so please do not edit it.
// Generated by `flutter_rust_bridge`@ 2.0.0.

// ignore_for_file: unused_import, unused_element, unnecessary_import, duplicate_ignore, invalid_use_of_internal_member, annotate_overrides, non_constant_identifier_names, curly_braces_in_flow_control_structures, prefer_const_literals_to_create_immutables, unused_field

import 'api/simple.dart';
import 'dart:async';
import 'dart:convert';
import 'frb_generated.dart';
import 'frb_generated.io.dart'
    if (dart.library.js_interop) 'frb_generated.web.dart';
import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart';

/// Main entrypoint of the Rust API
class RustLib extends BaseEntrypoint<RustLibApi, RustLibApiImpl, RustLibWire> {
  @internal
  static final instance = RustLib._();

  RustLib._();

  /// Initialize flutter_rust_bridge
  static Future<void> init({
    RustLibApi? api,
    BaseHandler? handler,
    ExternalLibrary? externalLibrary,
  }) async {
    await instance.initImpl(
      api: api,
      handler: handler,
      externalLibrary: externalLibrary,
    );
  }

  /// Dispose flutter_rust_bridge
  ///
  /// The call to this function is optional, since flutter_rust_bridge (and everything else)
  /// is automatically disposed when the app stops.
  static void dispose() => instance.disposeImpl();

  @override
  ApiImplConstructor<RustLibApiImpl, RustLibWire> get apiImplConstructor =>
      RustLibApiImpl.new;

  @override
  WireConstructor<RustLibWire> get wireConstructor =>
      RustLibWire.fromExternalLibrary;

  @override
  Future<void> executeRustInitializers() async {
    await api.crateApiSimpleInitApp();
  }

  @override
  ExternalLibraryLoaderConfig get defaultExternalLibraryLoaderConfig =>
      kDefaultExternalLibraryLoaderConfig;

  @override
  String get codegenVersion => '2.0.0';

  @override
  int get rustContentHash => 1067309539;

  static const kDefaultExternalLibraryLoaderConfig =
      ExternalLibraryLoaderConfig(
    stem: 'rust_lib_flutter_app',
    ioDirectory: '../crates/flutter_bridge/target/release/',
    webPrefix: 'pkg/',
  );
}

abstract class RustLibApi extends BaseApi {
  Future<FfibleCommunicator> crateApiSimpleFfibleCommunicatorNew(
      {required FutureOr<String> Function(String, String) ffiSendPvrTrigger});

  ParsedConfig crateApiSimpleGetConfig(
      {required String eeCert,
      required String eeKey,
      required String registrarCert});

  String crateApiSimpleGetPvrTrigger(
      {required ParsedConfig parsedConfig, required String serialNumber});

  String crateApiSimpleGreet({required String name});

  Future<void> crateApiSimpleInitApp();

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_FfibleCommunicator;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_FfibleCommunicator;

  CrossPlatformFinalizerArg
      get rust_arc_decrement_strong_count_FfibleCommunicatorPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_ParsedConfig;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_ParsedConfig;

  CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_ParsedConfigPtr;

  RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_String;

  RustArcDecrementStrongCountFnType get rust_arc_decrement_strong_count_String;

  CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_StringPtr;
}

class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
  RustLibApiImpl({
    required super.handler,
    required super.wire,
    required super.generalizedFrbRustBinding,
    required super.portManager,
  });

  @override
  Future<FfibleCommunicator> crateApiSimpleFfibleCommunicatorNew(
      {required FutureOr<String> Function(String, String) ffiSendPvrTrigger}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_DartFn_Inputs_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString_Output_String_AnyhowException(
            ffiSendPvrTrigger, serializer);
        pdeCallFfi(generalizedFrbRustBinding, serializer,
            funcId: 1, port: port_);
      },
      codec: SseCodec(
        decodeSuccessData:
            sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerFFIBLECommunicator,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiSimpleFfibleCommunicatorNewConstMeta,
      argValues: [ffiSendPvrTrigger],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSimpleFfibleCommunicatorNewConstMeta =>
      const TaskConstMeta(
        debugName: "FfibleCommunicator_new",
        argNames: ["ffiSendPvrTrigger"],
      );

  @override
  ParsedConfig crateApiSimpleGetConfig(
      {required String eeCert,
      required String eeKey,
      required String registrarCert}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_String(eeCert, serializer);
        sse_encode_String(eeKey, serializer);
        sse_encode_String(registrarCert, serializer);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 2)!;
      },
      codec: SseCodec(
        decodeSuccessData:
            sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerParsedConfig,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiSimpleGetConfigConstMeta,
      argValues: [eeCert, eeKey, registrarCert],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSimpleGetConfigConstMeta => const TaskConstMeta(
        debugName: "get_config",
        argNames: ["eeCert", "eeKey", "registrarCert"],
      );

  @override
  String crateApiSimpleGetPvrTrigger(
      {required ParsedConfig parsedConfig, required String serialNumber}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerParsedConfig(
            parsedConfig, serializer);
        sse_encode_String(serialNumber, serializer);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 3)!;
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_String,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiSimpleGetPvrTriggerConstMeta,
      argValues: [parsedConfig, serialNumber],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSimpleGetPvrTriggerConstMeta =>
      const TaskConstMeta(
        debugName: "get_pvr_trigger",
        argNames: ["parsedConfig", "serialNumber"],
      );

  @override
  String crateApiSimpleGreet({required String name}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_String(name, serializer);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 4)!;
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_String,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiSimpleGreetConstMeta,
      argValues: [name],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSimpleGreetConstMeta => const TaskConstMeta(
        debugName: "greet",
        argNames: ["name"],
      );

  @override
  Future<void> crateApiSimpleInitApp() {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        pdeCallFfi(generalizedFrbRustBinding, serializer,
            funcId: 5, port: port_);
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_unit,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiSimpleInitAppConstMeta,
      argValues: [],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSimpleInitAppConstMeta => const TaskConstMeta(
        debugName: "init_app",
        argNames: [],
      );

  Future<void> Function(int, dynamic, dynamic)
      encode_DartFn_Inputs_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString_Output_String_AnyhowException(
          FutureOr<String> Function(String, String) raw) {
    return (callId, rawArg0, rawArg1) async {
      final arg0 =
          dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString(
              rawArg0);
      final arg1 =
          dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString(
              rawArg1);

      Box<String>? rawOutput;
      Box<AnyhowException>? rawError;
      try {
        rawOutput = Box(await raw(arg0, arg1));
      } catch (e, s) {
        rawError = Box(AnyhowException("$e\n\n$s"));
      }

      final serializer = SseSerializer(generalizedFrbRustBinding);
      assert((rawOutput != null) ^ (rawError != null));
      if (rawOutput != null) {
        serializer.buffer.putUint8(0);
        sse_encode_String(rawOutput.value, serializer);
      } else {
        serializer.buffer.putUint8(1);
        sse_encode_AnyhowException(rawError!.value, serializer);
      }
      final output = serializer.intoRaw();

      generalizedFrbRustBinding.dartFnDeliverOutput(
          callId: callId,
          ptr: output.ptr,
          rustVecLen: output.rustVecLen,
          dataLen: output.dataLen);
    };
  }

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_FfibleCommunicator => wire
          .rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerFFIBLECommunicator;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_FfibleCommunicator => wire
          .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerFFIBLECommunicator;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_ParsedConfig => wire
          .rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerParsedConfig;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_ParsedConfig => wire
          .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerParsedConfig;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_String => wire
          .rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_String => wire
          .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString;

  @protected
  AnyhowException dco_decode_AnyhowException(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return AnyhowException(raw as String);
  }

  @protected
  FfibleCommunicator
      dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerFFIBLECommunicator(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return FfibleCommunicatorImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  ParsedConfig
      dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerParsedConfig(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return ParsedConfigImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  ParsedConfig
      dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerParsedConfig(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return ParsedConfigImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  String
      dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return StringImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  FutureOr<String> Function(String, String)
      dco_decode_DartFn_Inputs_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString_Output_String_AnyhowException(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    throw UnimplementedError('');
  }

  @protected
  Object dco_decode_DartOpaque(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return decodeDartOpaque(raw, generalizedFrbRustBinding);
  }

  @protected
  FfibleCommunicator
      dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerFFIBLECommunicator(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return FfibleCommunicatorImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  ParsedConfig
      dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerParsedConfig(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return ParsedConfigImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  String
      dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return StringImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  String dco_decode_String(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as String;
  }

  @protected
  Uint8List dco_decode_list_prim_u_8_strict(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as Uint8List;
  }

  @protected
  int dco_decode_u_8(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as int;
  }

  @protected
  void dco_decode_unit(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return;
  }

  @protected
  BigInt dco_decode_usize(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dcoDecodeU64(raw);
  }

  @protected
  AnyhowException sse_decode_AnyhowException(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var inner = sse_decode_String(deserializer);
    return AnyhowException(inner);
  }

  @protected
  FfibleCommunicator
      sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerFFIBLECommunicator(
          SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return FfibleCommunicatorImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  ParsedConfig
      sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerParsedConfig(
          SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return ParsedConfigImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  ParsedConfig
      sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerParsedConfig(
          SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return ParsedConfigImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  String
      sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString(
          SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return StringImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  Object sse_decode_DartOpaque(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var inner = sse_decode_usize(deserializer);
    return decodeDartOpaque(inner, generalizedFrbRustBinding);
  }

  @protected
  FfibleCommunicator
      sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerFFIBLECommunicator(
          SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return FfibleCommunicatorImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  ParsedConfig
      sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerParsedConfig(
          SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return ParsedConfigImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  String
      sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString(
          SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return StringImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  String sse_decode_String(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var inner = sse_decode_list_prim_u_8_strict(deserializer);
    return utf8.decoder.convert(inner);
  }

  @protected
  Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var len_ = sse_decode_i_32(deserializer);
    return deserializer.buffer.getUint8List(len_);
  }

  @protected
  int sse_decode_u_8(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return deserializer.buffer.getUint8();
  }

  @protected
  void sse_decode_unit(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
  }

  @protected
  BigInt sse_decode_usize(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return deserializer.buffer.getBigUint64();
  }

  @protected
  int sse_decode_i_32(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return deserializer.buffer.getInt32();
  }

  @protected
  bool sse_decode_bool(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return deserializer.buffer.getUint8() != 0;
  }

  @protected
  void sse_encode_AnyhowException(
      AnyhowException self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_String(self.message, serializer);
  }

  @protected
  void
      sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerFFIBLECommunicator(
          FfibleCommunicator self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as FfibleCommunicatorImpl).frbInternalSseEncode(move: true),
        serializer);
  }

  @protected
  void
      sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerParsedConfig(
          ParsedConfig self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as ParsedConfigImpl).frbInternalSseEncode(move: true),
        serializer);
  }

  @protected
  void
      sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerParsedConfig(
          ParsedConfig self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as ParsedConfigImpl).frbInternalSseEncode(move: false),
        serializer);
  }

  @protected
  void
      sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString(
          String self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as StringImpl).frbInternalSseEncode(move: false), serializer);
  }

  @protected
  void
      sse_encode_DartFn_Inputs_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString_Output_String_AnyhowException(
          FutureOr<String> Function(String, String) self,
          SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_DartOpaque(
        encode_DartFn_Inputs_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString_Output_String_AnyhowException(
            self),
        serializer);
  }

  @protected
  void sse_encode_DartOpaque(Object self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        BigInt.from(PlatformPointerUtil.ptrToInt(encodeDartOpaque(
                self, portManager.dartHandlerPort, generalizedFrbRustBinding)))
            .toUnsigned(64),
        serializer);
  }

  @protected
  void
      sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerFFIBLECommunicator(
          FfibleCommunicator self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as FfibleCommunicatorImpl).frbInternalSseEncode(move: null),
        serializer);
  }

  @protected
  void
      sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerParsedConfig(
          ParsedConfig self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as ParsedConfigImpl).frbInternalSseEncode(move: null),
        serializer);
  }

  @protected
  void
      sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerString(
          String self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as StringImpl).frbInternalSseEncode(move: null), serializer);
  }

  @protected
  void sse_encode_String(String self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_list_prim_u_8_strict(utf8.encoder.convert(self), serializer);
  }

  @protected
  void sse_encode_list_prim_u_8_strict(
      Uint8List self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_i_32(self.length, serializer);
    serializer.buffer.putUint8List(self);
  }

  @protected
  void sse_encode_u_8(int self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putUint8(self);
  }

  @protected
  void sse_encode_unit(void self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
  }

  @protected
  void sse_encode_usize(BigInt self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putBigUint64(self);
  }

  @protected
  void sse_encode_i_32(int self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putInt32(self);
  }

  @protected
  void sse_encode_bool(bool self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putUint8(self ? 1 : 0);
  }
}

@sealed
class FfibleCommunicatorImpl extends RustOpaque implements FfibleCommunicator {
  // Not to be used by end users
  FfibleCommunicatorImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  FfibleCommunicatorImpl.frbInternalSseDecode(
      BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        RustLib.instance.api.rust_arc_increment_strong_count_FfibleCommunicator,
    rustArcDecrementStrongCount:
        RustLib.instance.api.rust_arc_decrement_strong_count_FfibleCommunicator,
    rustArcDecrementStrongCountPtr: RustLib
        .instance.api.rust_arc_decrement_strong_count_FfibleCommunicatorPtr,
  );
}

@sealed
class ParsedConfigImpl extends RustOpaque implements ParsedConfig {
  // Not to be used by end users
  ParsedConfigImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  ParsedConfigImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        RustLib.instance.api.rust_arc_increment_strong_count_ParsedConfig,
    rustArcDecrementStrongCount:
        RustLib.instance.api.rust_arc_decrement_strong_count_ParsedConfig,
    rustArcDecrementStrongCountPtr:
        RustLib.instance.api.rust_arc_decrement_strong_count_ParsedConfigPtr,
  );
}

@sealed
class StringImpl extends RustOpaque implements String {
  // Not to be used by end users
  StringImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  StringImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        RustLib.instance.api.rust_arc_increment_strong_count_String,
    rustArcDecrementStrongCount:
        RustLib.instance.api.rust_arc_decrement_strong_count_String,
    rustArcDecrementStrongCountPtr:
        RustLib.instance.api.rust_arc_decrement_strong_count_StringPtr,
  );
}



### OS

_No response_

### Version of `flutter_rust_bridge_codegen`

_No response_

### Flutter info

_No response_

### Version of `clang++`

_No response_

### Additional context

_No response_
welcome[bot] commented 6 days ago

Hi! Thanks for opening your first issue here! :smile:

fzyzcjy commented 5 days ago

Try to use String, since &String (or &str) is only a grammar sugar and does not really prevent copying - Dart iirc does not have zero-copy for that.

fzyzcjy commented 3 days ago

Close since this seems to be solved, but feel free to reopen if having any quesitons!