opensource/localsend
1
0
Fork 0
mirror of https://github.com/localsend/localsend.git synced 2026-08-07 07:14:52 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity
Files
61b73b36419357352a395341430aebff831be828
localsend/packages/localsend_isolates/rust/src/frb_generated.rs
T
Tien Do Nam 61b73b3641
CI / format (push) Has been cancelled
Details
CI / test (push) Has been cancelled
Details
CI / packaging (push) Has been cancelled
Details
feat: add option to disable checksum verification
2026-08-03 17:31:29 +02:00

7888 lines
329 KiB
Rust
Raw Blame History

// This file is automatically generated, so please do not edit it.
// @generated by `flutter_rust_bridge`@ 2.12.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::uninlined_format_args,
clippy::needless_borrow
)]
// Section: imports
use crate::api::cancel::*;
use crate::api::discovery::*;
use crate::api::http::*;
use crate::api::server::*;
use crate::api::stream::*;
use crate::api::webrtc::*;
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.12.0";
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -1120530143;
// Section: executor
flutter_rust_bridge::frb_generated_default_handler!();
// Section: wire_funcs
fn wire__crate__api__stream__Dart2RustStreamSink_add_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "Dart2RustStreamSink_add",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Dart2RustStreamSink>,
>>::sse_decode(&mut deserializer);
let api_data = <Vec<u8>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, String>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, true,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref_mut().await)
}
_ => unreachable!(),
}
}
let mut api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::stream::Dart2RustStreamSink::add(
&mut *api_that_guard,
api_data,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__stream__Dart2RustStreamSink_close_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: "Dart2RustStreamSink_close",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Dart2RustStreamSink>,
>>::sse_decode(&mut deserializer);
deserializer.end();
transform_result_sse::<_, ()>((move || {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, true,
),
]);
for i in decode_indices_ {
match i {
0 => api_that_guard = Some(api_that.lockable_decode_sync_ref_mut()),
_ => unreachable!(),
}
}
let mut api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok({
crate::api::stream::Dart2RustStreamSink::close(&mut *api_that_guard);
})?;
Ok(output_ok)
})())
},
)
}
fn wire__crate__api__webrtc__LsSignalingConnection_accept_offer_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "LsSignalingConnection_accept_offer",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LsSignalingConnection>,
>>::sse_decode(&mut deserializer);
let api_stun_servers = <Vec<String>>::sse_decode(&mut deserializer);
let api_offer = <crate::api::webrtc::WsServerSdpMessage>::sse_decode(&mut deserializer);
let api_private_key = <String>::sse_decode(&mut deserializer);
let api_expecting_public_key =
<Option<crate::api::webrtc::ExpectingPublicKey>>::sse_decode(&mut deserializer);
let api_pin = <Option<crate::api::webrtc::PinConfig>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::webrtc::LsSignalingConnection::accept_offer(
&*api_that_guard,
api_stun_servers,
api_offer,
&api_private_key,
api_expecting_public_key,
api_pin,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__LsSignalingConnection_send_offer_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "LsSignalingConnection_send_offer",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LsSignalingConnection>,
>>::sse_decode(&mut deserializer);
let api_stun_servers = <Vec<String>>::sse_decode(&mut deserializer);
let api_target = <uuid::Uuid>::sse_decode(&mut deserializer);
let api_private_key = <String>::sse_decode(&mut deserializer);
let api_expecting_public_key =
<Option<crate::api::webrtc::ExpectingPublicKey>>::sse_decode(&mut deserializer);
let api_pin = <Option<crate::api::webrtc::PinConfig>>::sse_decode(&mut deserializer);
let api_files = <Vec<crate::api::model::FileDto>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::webrtc::LsSignalingConnection::send_offer(
&*api_that_guard,
api_stun_servers,
api_target,
&api_private_key,
api_expecting_public_key,
api_pin,
api_files,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__LsSignalingConnection_update_info_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "LsSignalingConnection_update_info",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LsSignalingConnection>,
>>::sse_decode(&mut deserializer);
let api_info = <crate::api::webrtc::ClientInfoWithoutId>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::webrtc::LsSignalingConnection::update_info(
&*api_that_guard,
api_info,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__cancel__RsCancellationToken_cancel_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: "RsCancellationToken_cancel",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsCancellationToken>,
>>::sse_decode(&mut deserializer);
deserializer.end();
transform_result_sse::<_, ()>((move || {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
),
]);
for i in decode_indices_ {
match i {
0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok({
crate::api::cancel::RsCancellationToken::cancel(&*api_that_guard);
})?;
Ok(output_ok)
})())
},
)
}
fn wire__crate__api__discovery__RsDiscovery_add_device_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsDiscovery_add_device",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsDiscovery>,
>>::sse_decode(&mut deserializer);
let api_device =
<crate::api::discovery::RsDiscoveredDevice>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, ()>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok({
crate::api::discovery::RsDiscovery::add_device(
&*api_that_guard,
api_device,
)
.await;
})?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__discovery__RsDiscovery_announce_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsDiscovery_announce",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsDiscovery>,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, ()>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok({
crate::api::discovery::RsDiscovery::announce(&*api_that_guard).await;
})?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__discovery__RsDiscovery_discover_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsDiscovery_discover",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsDiscovery>,
>>::sse_decode(&mut deserializer);
let api_host = <String>::sse_decode(&mut deserializer);
let api_port = <u16>::sse_decode(&mut deserializer);
let api_protocol = <crate::api::model::ProtocolType>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, ()>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok(
crate::api::discovery::RsDiscovery::discover(
&*api_that_guard,
api_host,
api_port,
api_protocol,
)
.await,
)?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__discovery__RsDiscovery_listen_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsDiscovery_listen",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsDiscovery>,
>>::sse_decode(&mut deserializer);
let api_sink = <StreamSink<
crate::api::discovery::RsStoredDevice,
flutter_rust_bridge::for_generated::SseCodec,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, ()>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok({
crate::api::discovery::RsDiscovery::listen(&*api_that_guard, api_sink)
.await;
})?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__discovery__RsDiscovery_multicast_error_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: "RsDiscovery_multicast_error",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsDiscovery>,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| {
transform_result_sse::<_, ()>((move || {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
),
]);
for i in decode_indices_ {
match i {
0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok(
crate::api::discovery::RsDiscovery::multicast_error(&*api_that_guard),
)?;
Ok(output_ok)
})())
}
},
)
}
fn wire__crate__api__discovery__RsDiscovery_scan_subnet_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsDiscovery_scan_subnet",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsDiscovery>,
>>::sse_decode(&mut deserializer);
let api_interface_ip = <String>::sse_decode(&mut deserializer);
let api_port = <u16>::sse_decode(&mut deserializer);
let api_protocol = <crate::api::model::ProtocolType>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::discovery::RsDiscovery::scan_subnet(
&*api_that_guard,
api_interface_ip,
api_port,
api_protocol,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__discovery__RsDiscovery_set_answer_announcements_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: "RsDiscovery_set_answer_announcements",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsDiscovery>,
>>::sse_decode(&mut deserializer);
let api_answer = <bool>::sse_decode(&mut deserializer);
deserializer.end();
move |context| {
transform_result_sse::<_, ()>((move || {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
),
]);
for i in decode_indices_ {
match i {
0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok({
crate::api::discovery::RsDiscovery::set_answer_announcements(
&*api_that_guard,
api_answer,
);
})?;
Ok(output_ok)
})())
}
},
)
}
fn wire__crate__api__discovery__RsDiscovery_stop_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsDiscovery_stop",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsDiscovery>,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, ()>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok({
crate::api::discovery::RsDiscovery::stop(&*api_that_guard).await;
})?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__http__RsHttpClient_cancel_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsHttpClient_cancel",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpClient>,
>>::sse_decode(&mut deserializer);
let api_protocol = <crate::api::model::ProtocolType>::sse_decode(&mut deserializer);
let api_ip = <String>::sse_decode(&mut deserializer);
let api_port = <u16>::sse_decode(&mut deserializer);
let api_session_id = <String>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, crate::api::http::RsHttpClientError>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::http::RsHttpClient::cancel(
&*api_that_guard,
api_protocol,
&api_ip,
api_port,
&api_session_id,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__http__RsHttpClient_prepare_upload_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsHttpClient_prepare_upload",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpClient>,
>>::sse_decode(&mut deserializer);
let api_protocol = <crate::api::model::ProtocolType>::sse_decode(&mut deserializer);
let api_ip = <String>::sse_decode(&mut deserializer);
let api_port = <u16>::sse_decode(&mut deserializer);
let api_payload =
<crate::api::model::PrepareUploadRequestDto>::sse_decode(&mut deserializer);
let api_public_key = <Option<String>>::sse_decode(&mut deserializer);
let api_pin = <Option<String>>::sse_decode(&mut deserializer);
let api_cancel_token = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsCancellationToken>,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, crate::api::http::RsHttpClientError>(
(move || async move {
let mut api_that_guard = None;
let mut api_cancel_token_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![
flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
),
flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_cancel_token,
1,
false,
),
],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
1 => {
api_cancel_token_guard =
Some(api_cancel_token.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let api_cancel_token_guard = api_cancel_token_guard.unwrap();
let output_ok = crate::api::http::RsHttpClient::prepare_upload(
&*api_that_guard,
api_protocol,
&api_ip,
api_port,
api_payload,
api_public_key,
api_pin,
&*api_cancel_token_guard,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__http__RsHttpClient_register_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsHttpClient_register",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpClient>,
>>::sse_decode(&mut deserializer);
let api_protocol = <crate::api::model::ProtocolType>::sse_decode(&mut deserializer);
let api_ip = <String>::sse_decode(&mut deserializer);
let api_port = <u16>::sse_decode(&mut deserializer);
let api_payload = <crate::api::model::RegisterDto>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, crate::api::http::RsHttpClientError>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::http::RsHttpClient::register(
&*api_that_guard,
api_protocol,
&api_ip,
api_port,
api_payload,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__http__RsHttpClient_upload_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsHttpClient_upload",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpClient>,
>>::sse_decode(&mut deserializer);
let api_sink =
<StreamSink<f64, flutter_rust_bridge::for_generated::SseCodec>>::sse_decode(
&mut deserializer,
);
let api_protocol = <crate::api::model::ProtocolType>::sse_decode(&mut deserializer);
let api_ip = <String>::sse_decode(&mut deserializer);
let api_port = <u16>::sse_decode(&mut deserializer);
let api_public_key = <Option<String>>::sse_decode(&mut deserializer);
let api_session_id = <String>::sse_decode(&mut deserializer);
let api_file_id = <String>::sse_decode(&mut deserializer);
let api_token = <String>::sse_decode(&mut deserializer);
let api_binary = <Option<Dart2RustStreamReceiver>>::sse_decode(&mut deserializer);
let api_path = <Option<String>>::sse_decode(&mut deserializer);
let api_file_descriptor = <Option<i32>>::sse_decode(&mut deserializer);
let api_content_length = <u64>::sse_decode(&mut deserializer);
let api_cancel_token = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsCancellationToken>,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, crate::api::http::RsHttpClientError>(
(move || async move {
let mut api_that_guard = None;
let mut api_cancel_token_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![
flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
),
flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_cancel_token,
1,
false,
),
],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
1 => {
api_cancel_token_guard =
Some(api_cancel_token.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let api_cancel_token_guard = api_cancel_token_guard.unwrap();
let output_ok = crate::api::http::RsHttpClient::upload(
&*api_that_guard,
api_sink,
api_protocol,
&api_ip,
api_port,
api_public_key,
&api_session_id,
&api_file_id,
&api_token,
api_binary,
api_path,
api_file_descriptor,
api_content_length,
&*api_cancel_token_guard,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__server__RsHttpServer_cancel_session_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsHttpServer_cancel_session",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpServer>,
>>::sse_decode(&mut deserializer);
let api_session_id = <String>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, ()>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok({
crate::api::server::RsHttpServer::cancel_session(
&*api_that_guard,
api_session_id,
)
.await;
})?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__server__RsHttpServer_fail_file_download_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsHttpServer_fail_file_download",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpServer>,
>>::sse_decode(&mut deserializer);
let api_session_id = <String>::sse_decode(&mut deserializer);
let api_file_id = <String>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, ()>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok({
crate::api::server::RsHttpServer::fail_file_download(
&*api_that_guard,
api_session_id,
api_file_id,
)
.await;
})?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__server__RsHttpServer_fail_file_upload_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsHttpServer_fail_file_upload",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpServer>,
>>::sse_decode(&mut deserializer);
let api_session_id = <String>::sse_decode(&mut deserializer);
let api_file_id = <String>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, ()>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok({
crate::api::server::RsHttpServer::fail_file_upload(
&*api_that_guard,
api_session_id,
api_file_id,
)
.await;
})?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__server__RsHttpServer_listen_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsHttpServer_listen",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpServer>,
>>::sse_decode(&mut deserializer);
let api_sink = <StreamSink<
crate::api::server::RsServerEvent,
flutter_rust_bridge::for_generated::SseCodec,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, ()>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok({
crate::api::server::RsHttpServer::listen(&*api_that_guard, api_sink)
.await;
})?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__server__RsHttpServer_respond_file_download_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsHttpServer_respond_file_download",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpServer>,
>>::sse_decode(&mut deserializer);
let api_session_id = <String>::sse_decode(&mut deserializer);
let api_file_id = <String>::sse_decode(&mut deserializer);
let api_path = <Option<String>>::sse_decode(&mut deserializer);
let api_file_descriptor = <Option<i32>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::server::RsHttpServer::respond_file_download(
&*api_that_guard,
api_session_id,
api_file_id,
api_path,
api_file_descriptor,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__server__RsHttpServer_respond_file_upload_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsHttpServer_respond_file_upload",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpServer>,
>>::sse_decode(&mut deserializer);
let api_sink =
<StreamSink<f64, flutter_rust_bridge::for_generated::SseCodec>>::sse_decode(
&mut deserializer,
);
let api_session_id = <String>::sse_decode(&mut deserializer);
let api_file_id = <String>::sse_decode(&mut deserializer);
let api_path = <Option<String>>::sse_decode(&mut deserializer);
let api_file_descriptor = <Option<i32>>::sse_decode(&mut deserializer);
let api_file_size = <u64>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::server::RsHttpServer::respond_file_upload(
&*api_that_guard,
api_sink,
api_session_id,
api_file_id,
api_path,
api_file_descriptor,
api_file_size,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__server__RsHttpServer_respond_prepare_download_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsHttpServer_respond_prepare_download",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpServer>,
>>::sse_decode(&mut deserializer);
let api_session_id = <String>::sse_decode(&mut deserializer);
let api_accept = <bool>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::server::RsHttpServer::respond_prepare_download(
&*api_that_guard,
api_session_id,
api_accept,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__server__RsHttpServer_respond_prepare_upload_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsHttpServer_respond_prepare_upload",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpServer>,
>>::sse_decode(&mut deserializer);
let api_accepted_file_ids = <Option<Vec<String>>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::server::RsHttpServer::respond_prepare_upload(
&*api_that_guard,
api_accepted_file_ids,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__server__RsHttpServer_stop_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsHttpServer_stop",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpServer>,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, ()>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok({
crate::api::server::RsHttpServer::stop(&*api_that_guard).await;
})?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__RtcFileReceiver_get_file_id_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: "RtcFileReceiver_get_file_id",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCFileReceiver>,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| {
transform_result_sse::<_, ()>((move || {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
),
]);
for i in decode_indices_ {
match i {
0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok(
crate::api::webrtc::RTCFileReceiver::get_file_id(&*api_that_guard),
)?;
Ok(output_ok)
})())
}
},
)
}
fn wire__crate__api__webrtc__RtcFileReceiver_receive_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RtcFileReceiver_receive",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCFileReceiver>,
>>::sse_decode(&mut deserializer);
let api_sink =
<StreamSink<Vec<u8>, flutter_rust_bridge::for_generated::SseCodec>>::sse_decode(
&mut deserializer,
);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::webrtc::RTCFileReceiver::receive(
&*api_that_guard,
api_sink,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__RtcFileSender_send_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RtcFileSender_send",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCFileSender>,
>>::sse_decode(&mut deserializer);
let api_data = <Vec<u8>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok =
crate::api::webrtc::RTCFileSender::send(&*api_that_guard, api_data)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__RtcReceiveController_decline_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RtcReceiveController_decline",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCReceiveController>,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok =
crate::api::webrtc::RTCReceiveController::decline(&*api_that_guard)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__RtcReceiveController_listen_error_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RtcReceiveController_listen_error",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCReceiveController>,
>>::sse_decode(&mut deserializer);
let api_sink = <StreamSink<
crate::api::webrtc::RTCFileError,
flutter_rust_bridge::for_generated::SseCodec,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, ()>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok({
crate::api::webrtc::RTCReceiveController::listen_error(
&*api_that_guard,
api_sink,
)
.await;
})?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__RtcReceiveController_listen_files_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RtcReceiveController_listen_files",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCReceiveController>,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::webrtc::RTCReceiveController::listen_files(
&*api_that_guard,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__RtcReceiveController_listen_receiving_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RtcReceiveController_listen_receiving",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCReceiveController>,
>>::sse_decode(&mut deserializer);
let api_sink = <StreamSink<
RTCFileReceiver,
flutter_rust_bridge::for_generated::SseCodec,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, ()>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok({
crate::api::webrtc::RTCReceiveController::listen_receiving(
&*api_that_guard,
api_sink,
)
.await;
})?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__RtcReceiveController_listen_status_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RtcReceiveController_listen_status",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCReceiveController>,
>>::sse_decode(&mut deserializer);
let api_sink = <StreamSink<
crate::api::webrtc::RTCStatus,
flutter_rust_bridge::for_generated::SseCodec,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, ()>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok({
crate::api::webrtc::RTCReceiveController::listen_status(
&*api_that_guard,
api_sink,
)
.await;
})?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__RtcReceiveController_send_file_status_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RtcReceiveController_send_file_status",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCReceiveController>,
>>::sse_decode(&mut deserializer);
let api_status =
<crate::api::webrtc::RTCSendFileResponse>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::webrtc::RTCReceiveController::send_file_status(
&*api_that_guard,
api_status,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__RtcReceiveController_send_pin_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RtcReceiveController_send_pin",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCReceiveController>,
>>::sse_decode(&mut deserializer);
let api_pin = <String>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::webrtc::RTCReceiveController::send_pin(
&*api_that_guard,
api_pin,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__RtcReceiveController_send_selection_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RtcReceiveController_send_selection",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCReceiveController>,
>>::sse_decode(&mut deserializer);
let api_selection = <std::collections::HashSet<String>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::webrtc::RTCReceiveController::send_selection(
&*api_that_guard,
api_selection,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__RtcSendController_listen_error_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RtcSendController_listen_error",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCSendController>,
>>::sse_decode(&mut deserializer);
let api_sink = <StreamSink<
crate::api::webrtc::RTCFileError,
flutter_rust_bridge::for_generated::SseCodec,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, ()>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, true,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref_mut().await)
}
_ => unreachable!(),
}
}
let mut api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok({
crate::api::webrtc::RTCSendController::listen_error(
&mut *api_that_guard,
api_sink,
)
.await;
})?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__RtcSendController_listen_selected_files_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RtcSendController_listen_selected_files",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCSendController>,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok =
crate::api::webrtc::RTCSendController::listen_selected_files(
&*api_that_guard,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__RtcSendController_listen_status_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RtcSendController_listen_status",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCSendController>,
>>::sse_decode(&mut deserializer);
let api_sink = <StreamSink<
crate::api::webrtc::RTCStatus,
flutter_rust_bridge::for_generated::SseCodec,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, ()>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, true,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref_mut().await)
}
_ => unreachable!(),
}
}
let mut api_that_guard = api_that_guard.unwrap();
let output_ok = Result::<_, ()>::Ok({
crate::api::webrtc::RTCSendController::listen_status(
&mut *api_that_guard,
api_sink,
)
.await;
})?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__RtcSendController_send_file_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RtcSendController_send_file",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCSendController>,
>>::sse_decode(&mut deserializer);
let api_file_id = <String>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::webrtc::RTCSendController::send_file(
&*api_that_guard,
api_file_id,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__RtcSendController_send_pin_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RtcSendController_send_pin",
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_that = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCSendController>,
>>::sse_decode(&mut deserializer);
let api_pin = <String>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_that_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_that, 0, false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_that_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::api::webrtc::RTCSendController::send_pin(
&*api_that_guard,
api_pin,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__webrtc__connect_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_async::<flutter_rust_bridge::for_generated::SseCodec,_,_,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "connect", 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_sink = <StreamSink<crate::api::webrtc::WsServerMessage,flutter_rust_bridge::for_generated::SseCodec>>::sse_decode(&mut deserializer);
let api_uri = <String>::sse_decode(&mut deserializer);
let api_info = <crate::api::webrtc::ProposingClientInfo>::sse_decode(&mut deserializer);
let api_private_key = <String>::sse_decode(&mut deserializer);
let api_on_connection = decode_DartFn_Inputs_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerLsSignalingConnection_Output_unit_AnyhowException(<flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer));deserializer.end(); move |context| async move {
transform_result_sse::<_, ()>((move || async move {
let output_ok = Result::<_,()>::Ok({ crate::api::webrtc::connect(api_sink, api_uri, api_info, api_private_key, api_on_connection).await; })?; Ok(output_ok)
})().await)
} })
}
fn wire__crate__api__cancel__create_cancellation_token_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: "create_cancellation_token",
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);
deserializer.end();
transform_result_sse::<_, ()>((move || {
let output_ok =
Result::<_, ()>::Ok(crate::api::cancel::create_cancellation_token())?;
Ok(output_ok)
})())
},
)
}
fn wire__crate__api__http__create_client_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: "create_client",
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_private_key = <String>::sse_decode(&mut deserializer);
let api_cert = <String>::sse_decode(&mut deserializer);
let api_version =
<crate::api::http::LsHttpClientVersion>::sse_decode(&mut deserializer);
let api_expected_fingerprint = <Option<String>>::sse_decode(&mut deserializer);
let api_timeout_ms = <Option<u32>>::sse_decode(&mut deserializer);
deserializer.end();
transform_result_sse::<_, crate::api::http::RsHttpClientError>((move || {
let output_ok = crate::api::http::create_client(
api_private_key,
api_cert,
api_version,
api_expected_fingerprint,
api_timeout_ms,
)?;
Ok(output_ok)
})())
},
)
}
fn wire__crate__api__stream__create_stream_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: "create_stream",
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::stream::create_stream())?;
Ok(output_ok)
})())
}
},
)
}
fn wire__crate__api__logging__enable_debug_logging_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: "enable_debug_logging",
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::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || {
let output_ok = crate::api::logging::enable_debug_logging()?;
Ok(output_ok)
})(),
)
}
},
)
}
fn wire__crate__api__crypto__generate_key_pair_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: "generate_key_pair",
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::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || {
let output_ok = crate::api::crypto::generate_key_pair()?;
Ok(output_ok)
})(),
)
}
},
)
}
fn wire__crate__api__crypto__generate_security_context_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: "generate_security_context",
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::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || {
let output_ok = crate::api::crypto::generate_security_context()?;
Ok(output_ok)
})(),
)
}
},
)
}
fn wire__crate__api__crypto__hash_file_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "hash_file",
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_sink = <StreamSink<
crate::api::crypto::RsHashFileEvent,
flutter_rust_bridge::for_generated::SseCodec,
>>::sse_decode(&mut deserializer);
let api_path = <Option<String>>::sse_decode(&mut deserializer);
let api_file_descriptor = <Option<i32>>::sse_decode(&mut deserializer);
let api_bytes = <Option<Vec<u8>>>::sse_decode(&mut deserializer);
let api_cancel_token = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsCancellationToken>,
>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let mut api_cancel_token_guard = None;
let decode_indices_ =
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
&api_cancel_token,
0,
false,
)],
);
for i in decode_indices_ {
match i {
0 => {
api_cancel_token_guard =
Some(api_cancel_token.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_cancel_token_guard = api_cancel_token_guard.unwrap();
let output_ok = crate::api::crypto::hash_file(
api_sink,
api_path,
api_file_descriptor,
api_bytes,
&*api_cancel_token_guard,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__filename__is_valid_file_name_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: "is_valid_file_name",
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::filename::is_valid_file_name(api_name))?;
Ok(output_ok)
})())
},
)
}
fn wire__crate__api__filename__sanitize_file_name_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: "sanitize_file_name",
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::filename::sanitize_file_name(api_name))?;
Ok(output_ok)
})())
},
)
}
fn wire__crate__api__discovery__start_discovery_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "start_discovery",
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_group = <String>::sse_decode(&mut deserializer);
let api_port = <u16>::sse_decode(&mut deserializer);
let api_network_whitelist = <Option<Vec<String>>>::sse_decode(&mut deserializer);
let api_network_blacklist = <Option<Vec<String>>>::sse_decode(&mut deserializer);
let api_alias = <String>::sse_decode(&mut deserializer);
let api_version = <String>::sse_decode(&mut deserializer);
let api_device_model = <Option<String>>::sse_decode(&mut deserializer);
let api_device_type =
<Option<crate::api::model::DeviceType>>::sse_decode(&mut deserializer);
let api_fingerprint = <String>::sse_decode(&mut deserializer);
let api_protocol = <crate::api::model::ProtocolType>::sse_decode(&mut deserializer);
let api_download = <bool>::sse_decode(&mut deserializer);
let api_cert_pem = <String>::sse_decode(&mut deserializer);
let api_private_key_pem = <String>::sse_decode(&mut deserializer);
let api_timeout_ms = <u64>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let output_ok = crate::api::discovery::start_discovery(
api_group,
api_port,
api_network_whitelist,
api_network_blacklist,
api_alias,
api_version,
api_device_model,
api_device_type,
api_fingerprint,
api_protocol,
api_download,
api_cert_pem,
api_private_key_pem,
api_timeout_ms,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__server__start_server_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_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "start_server",
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_port = <u16>::sse_decode(&mut deserializer);
let api_tls = <Option<crate::api::server::TlsConfig>>::sse_decode(&mut deserializer);
let api_alias = <String>::sse_decode(&mut deserializer);
let api_version = <String>::sse_decode(&mut deserializer);
let api_device_model = <Option<String>>::sse_decode(&mut deserializer);
let api_device_type =
<Option<crate::api::model::DeviceType>>::sse_decode(&mut deserializer);
let api_fingerprint = <String>::sse_decode(&mut deserializer);
let api_pin = <Option<String>>::sse_decode(&mut deserializer);
let api_verify_checksums = <bool>::sse_decode(&mut deserializer);
let api_web = <Option<crate::api::server::WebParams>>::sse_decode(&mut deserializer);
let api_show_token = <Option<String>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let output_ok = crate::api::server::start_server(
api_port,
api_tls,
api_alias,
api_version,
api_device_model,
api_device_type,
api_fingerprint,
api_pin,
api_verify_checksums,
api_web,
api_show_token,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__api__crypto__verify_cert_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: "verify_cert",
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_cert = <String>::sse_decode(&mut deserializer);
let api_public_key = <String>::sse_decode(&mut deserializer);
deserializer.end();
move |context| {
transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || {
let output_ok = crate::api::crypto::verify_cert(api_cert, api_public_key)?;
Ok(output_ok)
})(),
)
}
},
)
}
// Section: static_checks
#[allow(clippy::unnecessary_literal_unwrap)]
const _: fn() = || {
{
let ClientInfo = None::<crate::api::webrtc::ClientInfo>.unwrap();
let _: uuid::Uuid = ClientInfo.id;
let _: String = ClientInfo.alias;
let _: String = ClientInfo.version;
let _: Option<String> = ClientInfo.device_model;
let _: Option<crate::api::model::DeviceType> = ClientInfo.device_type;
let _: String = ClientInfo.token;
}
{
let ClientInfoWithoutId = None::<crate::api::webrtc::ClientInfoWithoutId>.unwrap();
let _: String = ClientInfoWithoutId.alias;
let _: String = ClientInfoWithoutId.version;
let _: Option<String> = ClientInfoWithoutId.device_model;
let _: Option<crate::api::model::DeviceType> = ClientInfoWithoutId.device_type;
let _: String = ClientInfoWithoutId.token;
}
{
let FileDto = None::<crate::api::model::FileDto>.unwrap();
let _: String = FileDto.id;
let _: String = FileDto.file_name;
let _: u64 = FileDto.size;
let _: String = FileDto.file_type;
let _: Option<String> = FileDto.sha256;
let _: Option<String> = FileDto.preview;
let _: Option<crate::api::model::FileMetadata> = FileDto.metadata;
}
{
let FileMetadata = None::<crate::api::model::FileMetadata>.unwrap();
let _: Option<String> = FileMetadata.modified;
let _: Option<String> = FileMetadata.accessed;
}
{
let PinConfig = None::<crate::api::webrtc::PinConfig>.unwrap();
let _: String = PinConfig.pin;
let _: u8 = PinConfig.max_tries;
}
{
let PrepareUploadRequestDto = None::<crate::api::model::PrepareUploadRequestDto>.unwrap();
let _: crate::api::model::RegisterDto = PrepareUploadRequestDto.info;
let _: std::collections::HashMap<String, crate::api::model::FileDto> =
PrepareUploadRequestDto.files;
}
{
let PrepareUploadResponseDto = None::<crate::api::model::PrepareUploadResponseDto>.unwrap();
let _: String = PrepareUploadResponseDto.session_id;
let _: std::collections::HashMap<String, String> = PrepareUploadResponseDto.files;
}
{
let PrepareUploadResult = None::<crate::api::http::PrepareUploadResult>.unwrap();
let _: u16 = PrepareUploadResult.status_code;
let _: Option<crate::api::model::PrepareUploadResponseDto> = PrepareUploadResult.response;
}
{
let RegisterDto = None::<crate::api::model::RegisterDto>.unwrap();
let _: String = RegisterDto.alias;
let _: String = RegisterDto.version;
let _: Option<String> = RegisterDto.device_model;
let _: Option<crate::api::model::DeviceType> = RegisterDto.device_type;
let _: String = RegisterDto.token;
let _: u16 = RegisterDto.port;
let _: crate::api::model::ProtocolType = RegisterDto.protocol;
let _: bool = RegisterDto.has_web_interface;
}
{
let RegisterDtoV2 = None::<crate::api::server::RegisterDtoV2>.unwrap();
let _: String = RegisterDtoV2.alias;
let _: String = RegisterDtoV2.version;
let _: Option<String> = RegisterDtoV2.device_model;
let _: Option<crate::api::model::DeviceType> = RegisterDtoV2.device_type;
let _: String = RegisterDtoV2.fingerprint;
let _: u16 = RegisterDtoV2.port;
let _: crate::api::model::ProtocolType = RegisterDtoV2.protocol;
let _: bool = RegisterDtoV2.download;
}
{
let RegisterResponseDto = None::<crate::api::model::RegisterResponseDto>.unwrap();
let _: String = RegisterResponseDto.alias;
let _: String = RegisterResponseDto.version;
let _: Option<String> = RegisterResponseDto.device_model;
let _: Option<crate::api::model::DeviceType> = RegisterResponseDto.device_type;
let _: String = RegisterResponseDto.token;
let _: bool = RegisterResponseDto.has_web_interface;
}
{
let RTCFileError = None::<crate::api::webrtc::RTCFileError>.unwrap();
let _: String = RTCFileError.file_id;
let _: String = RTCFileError.error;
}
{
let RTCSendFileResponse = None::<crate::api::webrtc::RTCSendFileResponse>.unwrap();
let _: String = RTCSendFileResponse.id;
let _: bool = RTCSendFileResponse.success;
let _: Option<String> = RTCSendFileResponse.error;
}
match None::<crate::api::webrtc::RTCStatus>.unwrap() {
crate::api::webrtc::RTCStatus::SdpExchanged => {}
crate::api::webrtc::RTCStatus::Connected => {}
crate::api::webrtc::RTCStatus::PinRequired => {}
crate::api::webrtc::RTCStatus::TooManyAttempts => {}
crate::api::webrtc::RTCStatus::Declined => {}
crate::api::webrtc::RTCStatus::Sending => {}
crate::api::webrtc::RTCStatus::Finished => {}
crate::api::webrtc::RTCStatus::Error(field0) => {
let _: String = field0;
}
}
{
let TlsConfig = None::<crate::api::server::TlsConfig>.unwrap();
let _: String = TlsConfig.cert;
let _: String = TlsConfig.private_key;
}
{
let WebI18n = None::<crate::api::server::WebI18n>.unwrap();
let _: String = WebI18n.waiting;
let _: String = WebI18n.enter_pin;
let _: String = WebI18n.invalid_pin;
let _: String = WebI18n.too_many_attempts;
let _: String = WebI18n.rejected;
let _: String = WebI18n.upload_rejected;
let _: String = WebI18n.busy;
let _: String = WebI18n.files;
let _: String = WebI18n.file_name;
let _: String = WebI18n.size;
}
match None::<crate::api::webrtc::WsServerMessage>.unwrap() {
crate::api::webrtc::WsServerMessage::Hello { client, peers } => {
let _: crate::api::webrtc::ClientInfo = client;
let _: Vec<crate::api::webrtc::ClientInfo> = peers;
}
crate::api::webrtc::WsServerMessage::Join { peer } => {
let _: crate::api::webrtc::ClientInfo = peer;
}
crate::api::webrtc::WsServerMessage::Update { peer } => {
let _: crate::api::webrtc::ClientInfo = peer;
}
crate::api::webrtc::WsServerMessage::Left { peer_id } => {
let _: uuid::Uuid = peer_id;
}
crate::api::webrtc::WsServerMessage::Offer(field0) => {
let _: crate::api::webrtc::WsServerSdpMessage = field0;
}
crate::api::webrtc::WsServerMessage::Answer(field0) => {
let _: crate::api::webrtc::WsServerSdpMessage = field0;
}
crate::api::webrtc::WsServerMessage::Error { code } => {
let _: u16 = code;
}
}
{
let WsServerSdpMessage = None::<crate::api::webrtc::WsServerSdpMessage>.unwrap();
let _: crate::api::webrtc::ClientInfo = WsServerSdpMessage.peer;
let _: String = WsServerSdpMessage.session_id;
let _: String = WsServerSdpMessage.sdp;
}
};
// Section: related_funcs
fn decode_DartFn_Inputs_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerLsSignalingConnection_Output_unit_AnyhowException(
dart_opaque: flutter_rust_bridge::DartOpaque,
) -> impl Fn(LsSignalingConnection) -> flutter_rust_bridge::DartFnFuture<()> {
use flutter_rust_bridge::IntoDart;
async fn body(dart_opaque: flutter_rust_bridge::DartOpaque, arg0: LsSignalingConnection) -> () {
let args = vec![arg0.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(<()>::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: LsSignalingConnection| {
flutter_rust_bridge::for_generated::convert_into_dart_fn_future(body(
dart_opaque.clone(),
arg0,
))
}
}
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Dart2RustStreamReceiver>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Dart2RustStreamSink>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LsSignalingConnection>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCFileReceiver>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCFileSender>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCReceiveController>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCSendController>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsCancellationToken>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsDiscovery>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpClient>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpServer>
);
// 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 Dart2RustStreamReceiver {
// 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<Dart2RustStreamReceiver>,
>>::sse_decode(deserializer);
return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
}
}
impl SseDecode for Dart2RustStreamSink {
// 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<Dart2RustStreamSink>,
>>::sse_decode(deserializer);
return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
}
}
impl SseDecode for LsSignalingConnection {
// 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<LsSignalingConnection>,
>>::sse_decode(deserializer);
return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
}
}
impl SseDecode for RTCFileReceiver {
// 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<RTCFileReceiver>,
>>::sse_decode(deserializer);
return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
}
}
impl SseDecode for RTCFileSender {
// 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<RTCFileSender>,
>>::sse_decode(deserializer);
return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
}
}
impl SseDecode for RTCReceiveController {
// 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<RTCReceiveController>,
>>::sse_decode(deserializer);
return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
}
}
impl SseDecode for RTCSendController {
// 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<RTCSendController>,
>>::sse_decode(deserializer);
return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
}
}
impl SseDecode for RsCancellationToken {
// 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<RsCancellationToken>,
>>::sse_decode(deserializer);
return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
}
}
impl SseDecode for RsDiscovery {
// 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<RsDiscovery>,
>>::sse_decode(deserializer);
return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
}
}
impl SseDecode for RsHttpClient {
// 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<RsHttpClient>,
>>::sse_decode(deserializer);
return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
}
}
impl SseDecode for RsHttpServer {
// 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<RsHttpServer>,
>>::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 std::collections::HashMap<String, 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<(String, String)>>::sse_decode(deserializer);
return inner.into_iter().collect();
}
}
impl SseDecode for std::collections::HashMap<String, crate::api::model::FileDto> {
// 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<(String, crate::api::model::FileDto)>>::sse_decode(deserializer);
return inner.into_iter().collect();
}
}
impl SseDecode
for RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Dart2RustStreamReceiver>,
>
{
// 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<Dart2RustStreamSink>>
{
// 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<LsSignalingConnection>,
>
{
// 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<RTCFileReceiver>>
{
// 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<RTCFileSender>>
{
// 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<RTCReceiveController>>
{
// 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<RTCSendController>>
{
// 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<RsCancellationToken>>
{
// 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<RsDiscovery>>
{
// 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<RsHttpClient>>
{
// 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<RsHttpServer>>
{
// 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 std::collections::HashSet<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<String>>::sse_decode(deserializer);
return inner.into_iter().collect();
}
}
impl SseDecode for StreamSink<RTCFileReceiver, flutter_rust_bridge::for_generated::SseCodec> {
// 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 StreamSink::deserialize(inner);
}
}
impl SseDecode for StreamSink<f64, flutter_rust_bridge::for_generated::SseCodec> {
// 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 StreamSink::deserialize(inner);
}
}
impl SseDecode for StreamSink<Vec<u8>, flutter_rust_bridge::for_generated::SseCodec> {
// 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 StreamSink::deserialize(inner);
}
}
impl SseDecode
for StreamSink<
crate::api::crypto::RsHashFileEvent,
flutter_rust_bridge::for_generated::SseCodec,
>
{
// 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 StreamSink::deserialize(inner);
}
}
impl SseDecode
for StreamSink<crate::api::server::RsServerEvent, flutter_rust_bridge::for_generated::SseCodec>
{
// 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 StreamSink::deserialize(inner);
}
}
impl SseDecode
for StreamSink<
crate::api::discovery::RsStoredDevice,
flutter_rust_bridge::for_generated::SseCodec,
>
{
// 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 StreamSink::deserialize(inner);
}
}
impl SseDecode
for StreamSink<crate::api::webrtc::RTCFileError, flutter_rust_bridge::for_generated::SseCodec>
{
// 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 StreamSink::deserialize(inner);
}
}
impl SseDecode
for StreamSink<crate::api::webrtc::RTCStatus, flutter_rust_bridge::for_generated::SseCodec>
{
// 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 StreamSink::deserialize(inner);
}
}
impl SseDecode
for StreamSink<
crate::api::webrtc::WsServerMessage,
flutter_rust_bridge::for_generated::SseCodec,
>
{
// 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 StreamSink::deserialize(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 uuid::Uuid {
// 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 uuid::Uuid::from_slice(&inner).expect("fail to decode uuid");
}
}
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
}
}
impl SseDecode for crate::api::webrtc::ClientInfo {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_id = <uuid::Uuid>::sse_decode(deserializer);
let mut var_alias = <String>::sse_decode(deserializer);
let mut var_version = <String>::sse_decode(deserializer);
let mut var_deviceModel = <Option<String>>::sse_decode(deserializer);
let mut var_deviceType = <Option<crate::api::model::DeviceType>>::sse_decode(deserializer);
let mut var_token = <String>::sse_decode(deserializer);
return crate::api::webrtc::ClientInfo {
id: var_id,
alias: var_alias,
version: var_version,
device_model: var_deviceModel,
device_type: var_deviceType,
token: var_token,
};
}
}
impl SseDecode for crate::api::webrtc::ClientInfoWithoutId {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_alias = <String>::sse_decode(deserializer);
let mut var_version = <String>::sse_decode(deserializer);
let mut var_deviceModel = <Option<String>>::sse_decode(deserializer);
let mut var_deviceType = <Option<crate::api::model::DeviceType>>::sse_decode(deserializer);
let mut var_token = <String>::sse_decode(deserializer);
return crate::api::webrtc::ClientInfoWithoutId {
alias: var_alias,
version: var_version,
device_model: var_deviceModel,
device_type: var_deviceType,
token: var_token,
};
}
}
impl SseDecode for crate::api::model::DeviceType {
// 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 = <i32>::sse_decode(deserializer);
return match inner {
0 => crate::api::model::DeviceType::Mobile,
1 => crate::api::model::DeviceType::Desktop,
2 => crate::api::model::DeviceType::Web,
3 => crate::api::model::DeviceType::Headless,
4 => crate::api::model::DeviceType::Server,
_ => unreachable!("Invalid variant for DeviceType: {}", inner),
};
}
}
impl SseDecode for crate::api::webrtc::ExpectingPublicKey {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_publicKey = <String>::sse_decode(deserializer);
let mut var_kind = <String>::sse_decode(deserializer);
return crate::api::webrtc::ExpectingPublicKey {
public_key: var_publicKey,
kind: var_kind,
};
}
}
impl SseDecode for f64 {
// 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_f64::<NativeEndian>().unwrap()
}
}
impl SseDecode for crate::api::model::FileDto {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_id = <String>::sse_decode(deserializer);
let mut var_fileName = <String>::sse_decode(deserializer);
let mut var_size = <u64>::sse_decode(deserializer);
let mut var_fileType = <String>::sse_decode(deserializer);
let mut var_sha256 = <Option<String>>::sse_decode(deserializer);
let mut var_preview = <Option<String>>::sse_decode(deserializer);
let mut var_metadata = <Option<crate::api::model::FileMetadata>>::sse_decode(deserializer);
return crate::api::model::FileDto {
id: var_id,
file_name: var_fileName,
size: var_size,
file_type: var_fileType,
sha256: var_sha256,
preview: var_preview,
metadata: var_metadata,
};
}
}
impl SseDecode for crate::api::model::FileMetadata {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_modified = <Option<String>>::sse_decode(deserializer);
let mut var_accessed = <Option<String>>::sse_decode(deserializer);
return crate::api::model::FileMetadata {
modified: var_modified,
accessed: var_accessed,
};
}
}
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 isize {
// 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_i64::<NativeEndian>().unwrap() as _
}
}
impl SseDecode for crate::api::crypto::KeyPair {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_privateKey = <String>::sse_decode(deserializer);
let mut var_publicKey = <String>::sse_decode(deserializer);
return crate::api::crypto::KeyPair {
private_key: var_privateKey,
public_key: var_publicKey,
};
}
}
impl SseDecode for Vec<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 len_ = <i32>::sse_decode(deserializer);
let mut ans_ = Vec::with_capacity(len_ as usize);
for idx_ in 0..len_ {
ans_.push(<String>::sse_decode(deserializer));
}
return ans_;
}
}
impl SseDecode for Vec<crate::api::webrtc::ClientInfo> {
// 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::with_capacity(len_ as usize);
for idx_ in 0..len_ {
ans_.push(<crate::api::webrtc::ClientInfo>::sse_decode(deserializer));
}
return ans_;
}
}
impl SseDecode for Vec<crate::api::model::FileDto> {
// 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::with_capacity(len_ as usize);
for idx_ in 0..len_ {
ans_.push(<crate::api::model::FileDto>::sse_decode(deserializer));
}
return ans_;
}
}
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::with_capacity(len_ as usize);
for idx_ in 0..len_ {
ans_.push(<u8>::sse_decode(deserializer));
}
return ans_;
}
}
impl SseDecode for Vec<(String, crate::api::model::FileDto)> {
// 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::with_capacity(len_ as usize);
for idx_ in 0..len_ {
ans_.push(<(String, crate::api::model::FileDto)>::sse_decode(
deserializer,
));
}
return ans_;
}
}
impl SseDecode for Vec<(String, 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 len_ = <i32>::sse_decode(deserializer);
let mut ans_ = Vec::with_capacity(len_ as usize);
for idx_ in 0..len_ {
ans_.push(<(String, String)>::sse_decode(deserializer));
}
return ans_;
}
}
impl SseDecode for Vec<crate::api::discovery::RsDeviceChannel> {
// 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::with_capacity(len_ as usize);
for idx_ in 0..len_ {
ans_.push(<crate::api::discovery::RsDeviceChannel>::sse_decode(
deserializer,
));
}
return ans_;
}
}
impl SseDecode for crate::api::http::LsHttpClientVersion {
// 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 = <i32>::sse_decode(deserializer);
return match inner {
0 => crate::api::http::LsHttpClientVersion::V2,
1 => crate::api::http::LsHttpClientVersion::V3,
_ => unreachable!("Invalid variant for LsHttpClientVersion: {}", inner),
};
}
}
impl SseDecode for Option<String> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<String>::sse_decode(deserializer));
} else {
return None;
}
}
}
impl SseDecode for Option<Dart2RustStreamReceiver> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<Dart2RustStreamReceiver>::sse_decode(deserializer));
} else {
return None;
}
}
}
impl SseDecode for Option<crate::api::model::DeviceType> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<crate::api::model::DeviceType>::sse_decode(deserializer));
} else {
return None;
}
}
}
impl SseDecode for Option<crate::api::webrtc::ExpectingPublicKey> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<crate::api::webrtc::ExpectingPublicKey>::sse_decode(
deserializer,
));
} else {
return None;
}
}
}
impl SseDecode for Option<crate::api::model::FileMetadata> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<crate::api::model::FileMetadata>::sse_decode(deserializer));
} else {
return None;
}
}
}
impl SseDecode for Option<i32> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<i32>::sse_decode(deserializer));
} else {
return None;
}
}
}
impl SseDecode for Option<crate::api::webrtc::PinConfig> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<crate::api::webrtc::PinConfig>::sse_decode(deserializer));
} else {
return None;
}
}
}
impl SseDecode for Option<crate::api::model::PrepareUploadResponseDto> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<crate::api::model::PrepareUploadResponseDto>::sse_decode(
deserializer,
));
} else {
return None;
}
}
}
impl SseDecode for Option<crate::api::discovery::RsStoredDevice> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<crate::api::discovery::RsStoredDevice>::sse_decode(
deserializer,
));
} else {
return None;
}
}
}
impl SseDecode for Option<crate::api::server::TlsConfig> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<crate::api::server::TlsConfig>::sse_decode(deserializer));
} else {
return None;
}
}
}
impl SseDecode for Option<u32> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<u32>::sse_decode(deserializer));
} else {
return None;
}
}
}
impl SseDecode for Option<crate::api::server::WebParams> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<crate::api::server::WebParams>::sse_decode(deserializer));
} else {
return None;
}
}
}
impl SseDecode for Option<crate::api::server::WebSendParams> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<crate::api::server::WebSendParams>::sse_decode(
deserializer,
));
} else {
return None;
}
}
}
impl SseDecode for Option<Vec<String>> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<Vec<String>>::sse_decode(deserializer));
} else {
return None;
}
}
}
impl SseDecode for Option<Vec<u8>> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<Vec<u8>>::sse_decode(deserializer));
} else {
return None;
}
}
}
impl SseDecode for crate::api::webrtc::PinConfig {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_pin = <String>::sse_decode(deserializer);
let mut var_maxTries = <u8>::sse_decode(deserializer);
return crate::api::webrtc::PinConfig {
pin: var_pin,
max_tries: var_maxTries,
};
}
}
impl SseDecode for crate::api::model::PrepareUploadRequestDto {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_info = <crate::api::model::RegisterDto>::sse_decode(deserializer);
let mut var_files =
<std::collections::HashMap<String, crate::api::model::FileDto>>::sse_decode(
deserializer,
);
return crate::api::model::PrepareUploadRequestDto {
info: var_info,
files: var_files,
};
}
}
impl SseDecode for crate::api::model::PrepareUploadResponseDto {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_sessionId = <String>::sse_decode(deserializer);
let mut var_files = <std::collections::HashMap<String, String>>::sse_decode(deserializer);
return crate::api::model::PrepareUploadResponseDto {
session_id: var_sessionId,
files: var_files,
};
}
}
impl SseDecode for crate::api::http::PrepareUploadResult {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_statusCode = <u16>::sse_decode(deserializer);
let mut var_response =
<Option<crate::api::model::PrepareUploadResponseDto>>::sse_decode(deserializer);
return crate::api::http::PrepareUploadResult {
status_code: var_statusCode,
response: var_response,
};
}
}
impl SseDecode for crate::api::webrtc::ProposingClientInfo {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_alias = <String>::sse_decode(deserializer);
let mut var_version = <String>::sse_decode(deserializer);
let mut var_deviceModel = <Option<String>>::sse_decode(deserializer);
let mut var_deviceType = <Option<crate::api::model::DeviceType>>::sse_decode(deserializer);
return crate::api::webrtc::ProposingClientInfo {
alias: var_alias,
version: var_version,
device_model: var_deviceModel,
device_type: var_deviceType,
};
}
}
impl SseDecode for crate::api::model::ProtocolType {
// 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 = <i32>::sse_decode(deserializer);
return match inner {
0 => crate::api::model::ProtocolType::Http,
1 => crate::api::model::ProtocolType::Https,
_ => unreachable!("Invalid variant for ProtocolType: {}", inner),
};
}
}
impl SseDecode for (Dart2RustStreamSink, Dart2RustStreamReceiver) {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_field0 = <Dart2RustStreamSink>::sse_decode(deserializer);
let mut var_field1 = <Dart2RustStreamReceiver>::sse_decode(deserializer);
return (var_field0, var_field1);
}
}
impl SseDecode for (String, crate::api::model::FileDto) {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_field0 = <String>::sse_decode(deserializer);
let mut var_field1 = <crate::api::model::FileDto>::sse_decode(deserializer);
return (var_field0, var_field1);
}
}
impl SseDecode for (String, 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 var_field0 = <String>::sse_decode(deserializer);
let mut var_field1 = <String>::sse_decode(deserializer);
return (var_field0, var_field1);
}
}
impl SseDecode for crate::api::model::RegisterDto {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_alias = <String>::sse_decode(deserializer);
let mut var_version = <String>::sse_decode(deserializer);
let mut var_deviceModel = <Option<String>>::sse_decode(deserializer);
let mut var_deviceType = <Option<crate::api::model::DeviceType>>::sse_decode(deserializer);
let mut var_token = <String>::sse_decode(deserializer);
let mut var_port = <u16>::sse_decode(deserializer);
let mut var_protocol = <crate::api::model::ProtocolType>::sse_decode(deserializer);
let mut var_hasWebInterface = <bool>::sse_decode(deserializer);
return crate::api::model::RegisterDto {
alias: var_alias,
version: var_version,
device_model: var_deviceModel,
device_type: var_deviceType,
token: var_token,
port: var_port,
protocol: var_protocol,
has_web_interface: var_hasWebInterface,
};
}
}
impl SseDecode for crate::api::server::RegisterDtoV2 {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_alias = <String>::sse_decode(deserializer);
let mut var_version = <String>::sse_decode(deserializer);
let mut var_deviceModel = <Option<String>>::sse_decode(deserializer);
let mut var_deviceType = <Option<crate::api::model::DeviceType>>::sse_decode(deserializer);
let mut var_fingerprint = <String>::sse_decode(deserializer);
let mut var_port = <u16>::sse_decode(deserializer);
let mut var_protocol = <crate::api::model::ProtocolType>::sse_decode(deserializer);
let mut var_download = <bool>::sse_decode(deserializer);
return crate::api::server::RegisterDtoV2 {
alias: var_alias,
version: var_version,
device_model: var_deviceModel,
device_type: var_deviceType,
fingerprint: var_fingerprint,
port: var_port,
protocol: var_protocol,
download: var_download,
};
}
}
impl SseDecode for crate::api::model::RegisterResponseDto {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_alias = <String>::sse_decode(deserializer);
let mut var_version = <String>::sse_decode(deserializer);
let mut var_deviceModel = <Option<String>>::sse_decode(deserializer);
let mut var_deviceType = <Option<crate::api::model::DeviceType>>::sse_decode(deserializer);
let mut var_token = <String>::sse_decode(deserializer);
let mut var_hasWebInterface = <bool>::sse_decode(deserializer);
return crate::api::model::RegisterResponseDto {
alias: var_alias,
version: var_version,
device_model: var_deviceModel,
device_type: var_deviceType,
token: var_token,
has_web_interface: var_hasWebInterface,
};
}
}
impl SseDecode for crate::api::http::ResultWithPublicKeyRegisterResponseDto {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_publicKey = <Option<String>>::sse_decode(deserializer);
let mut var_body = <crate::api::model::RegisterResponseDto>::sse_decode(deserializer);
return crate::api::http::ResultWithPublicKeyRegisterResponseDto {
public_key: var_publicKey,
body: var_body,
};
}
}
impl SseDecode for crate::api::discovery::RsDeviceChannel {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_host = <String>::sse_decode(deserializer);
let mut var_port = <u16>::sse_decode(deserializer);
let mut var_protocol = <crate::api::model::ProtocolType>::sse_decode(deserializer);
return crate::api::discovery::RsDeviceChannel {
host: var_host,
port: var_port,
protocol: var_protocol,
};
}
}
impl SseDecode for crate::api::discovery::RsDiscoveredDevice {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_alias = <String>::sse_decode(deserializer);
let mut var_version = <String>::sse_decode(deserializer);
let mut var_deviceModel = <Option<String>>::sse_decode(deserializer);
let mut var_deviceType = <Option<crate::api::model::DeviceType>>::sse_decode(deserializer);
let mut var_fingerprint = <String>::sse_decode(deserializer);
let mut var_host = <String>::sse_decode(deserializer);
let mut var_port = <u16>::sse_decode(deserializer);
let mut var_protocol = <crate::api::model::ProtocolType>::sse_decode(deserializer);
let mut var_download = <bool>::sse_decode(deserializer);
return crate::api::discovery::RsDiscoveredDevice {
alias: var_alias,
version: var_version,
device_model: var_deviceModel,
device_type: var_deviceType,
fingerprint: var_fingerprint,
host: var_host,
port: var_port,
protocol: var_protocol,
download: var_download,
};
}
}
impl SseDecode for crate::api::crypto::RsHashFileEvent {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut tag_ = <i32>::sse_decode(deserializer);
match tag_ {
0 => {
let mut var_bytes = <u64>::sse_decode(deserializer);
return crate::api::crypto::RsHashFileEvent::Progress { bytes: var_bytes };
}
1 => {
let mut var_hash = <String>::sse_decode(deserializer);
return crate::api::crypto::RsHashFileEvent::Done { hash: var_hash };
}
_ => {
unimplemented!("");
}
}
}
}
impl SseDecode for crate::api::http::RsHttpClientError {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut tag_ = <i32>::sse_decode(deserializer);
match tag_ {
0 => {
let mut var_status = <u16>::sse_decode(deserializer);
let mut var_message = <Option<String>>::sse_decode(deserializer);
return crate::api::http::RsHttpClientError::StatusCode {
status: var_status,
message: var_message,
};
}
1 => {
let mut var_field0 = <String>::sse_decode(deserializer);
return crate::api::http::RsHttpClientError::Reqwest(var_field0);
}
2 => {
let mut var_field0 = <String>::sse_decode(deserializer);
return crate::api::http::RsHttpClientError::Json(var_field0);
}
3 => {
let mut var_field0 = <String>::sse_decode(deserializer);
return crate::api::http::RsHttpClientError::Io(var_field0);
}
4 => {
let mut var_field0 = <String>::sse_decode(deserializer);
return crate::api::http::RsHttpClientError::Other(var_field0);
}
_ => {
unimplemented!("");
}
}
}
}
impl SseDecode for crate::api::server::RsServerEvent {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut tag_ = <i32>::sse_decode(deserializer);
match tag_ {
0 => {
let mut var_ip = <String>::sse_decode(deserializer);
let mut var_info = <crate::api::server::RegisterDtoV2>::sse_decode(deserializer);
return crate::api::server::RsServerEvent::Register {
ip: var_ip,
info: var_info,
};
}
1 => {
let mut var_sessionId = <String>::sse_decode(deserializer);
let mut var_ip = <String>::sse_decode(deserializer);
let mut var_info = <crate::api::server::RegisterDtoV2>::sse_decode(deserializer);
let mut var_certFingerprint = <Option<String>>::sse_decode(deserializer);
let mut var_files =
<std::collections::HashMap<String, crate::api::model::FileDto>>::sse_decode(
deserializer,
);
return crate::api::server::RsServerEvent::PrepareUpload {
session_id: var_sessionId,
ip: var_ip,
info: var_info,
cert_fingerprint: var_certFingerprint,
files: var_files,
};
}
2 => {
let mut var_sessionId = <String>::sse_decode(deserializer);
let mut var_fileId = <String>::sse_decode(deserializer);
let mut var_file = <crate::api::model::FileDto>::sse_decode(deserializer);
return crate::api::server::RsServerEvent::FileUpload {
session_id: var_sessionId,
file_id: var_fileId,
file: var_file,
};
}
3 => {
let mut var_sessionId = <String>::sse_decode(deserializer);
let mut var_reason =
<crate::api::server::SessionEndReasonV2>::sse_decode(deserializer);
return crate::api::server::RsServerEvent::SessionEnd {
session_id: var_sessionId,
reason: var_reason,
};
}
4 => {
let mut var_sessionId = <String>::sse_decode(deserializer);
return crate::api::server::RsServerEvent::PrepareUploadAborted {
session_id: var_sessionId,
};
}
5 => {
let mut var_ip = <String>::sse_decode(deserializer);
let mut var_sessionId = <String>::sse_decode(deserializer);
return crate::api::server::RsServerEvent::CancelReceived {
ip: var_ip,
session_id: var_sessionId,
};
}
6 => {
let mut var_ip = <String>::sse_decode(deserializer);
let mut var_sessionId = <String>::sse_decode(deserializer);
let mut var_userAgent = <Option<String>>::sse_decode(deserializer);
return crate::api::server::RsServerEvent::WebPrepareDownload {
ip: var_ip,
session_id: var_sessionId,
user_agent: var_userAgent,
};
}
7 => {
let mut var_sessionId = <String>::sse_decode(deserializer);
let mut var_fileId = <String>::sse_decode(deserializer);
let mut var_file = <crate::api::model::FileDto>::sse_decode(deserializer);
return crate::api::server::RsServerEvent::WebFileDownload {
session_id: var_sessionId,
file_id: var_fileId,
file: var_file,
};
}
8 => {
let mut var_args = <Vec<String>>::sse_decode(deserializer);
return crate::api::server::RsServerEvent::Show { args: var_args };
}
_ => {
unimplemented!("");
}
}
}
}
impl SseDecode for crate::api::discovery::RsStoredDevice {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_alias = <String>::sse_decode(deserializer);
let mut var_version = <String>::sse_decode(deserializer);
let mut var_deviceModel = <Option<String>>::sse_decode(deserializer);
let mut var_deviceType = <Option<crate::api::model::DeviceType>>::sse_decode(deserializer);
let mut var_fingerprint = <String>::sse_decode(deserializer);
let mut var_download = <bool>::sse_decode(deserializer);
let mut var_channels =
<Vec<crate::api::discovery::RsDeviceChannel>>::sse_decode(deserializer);
return crate::api::discovery::RsStoredDevice {
alias: var_alias,
version: var_version,
device_model: var_deviceModel,
device_type: var_deviceType,
fingerprint: var_fingerprint,
download: var_download,
channels: var_channels,
};
}
}
impl SseDecode for crate::api::webrtc::RTCFileError {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_fileId = <String>::sse_decode(deserializer);
let mut var_error = <String>::sse_decode(deserializer);
return crate::api::webrtc::RTCFileError {
file_id: var_fileId,
error: var_error,
};
}
}
impl SseDecode for crate::api::webrtc::RTCSendFileResponse {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_id = <String>::sse_decode(deserializer);
let mut var_success = <bool>::sse_decode(deserializer);
let mut var_error = <Option<String>>::sse_decode(deserializer);
return crate::api::webrtc::RTCSendFileResponse {
id: var_id,
success: var_success,
error: var_error,
};
}
}
impl SseDecode for crate::api::webrtc::RTCStatus {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut tag_ = <i32>::sse_decode(deserializer);
match tag_ {
0 => {
return crate::api::webrtc::RTCStatus::SdpExchanged;
}
1 => {
return crate::api::webrtc::RTCStatus::Connected;
}
2 => {
return crate::api::webrtc::RTCStatus::PinRequired;
}
3 => {
return crate::api::webrtc::RTCStatus::TooManyAttempts;
}
4 => {
return crate::api::webrtc::RTCStatus::Declined;
}
5 => {
return crate::api::webrtc::RTCStatus::Sending;
}
6 => {
return crate::api::webrtc::RTCStatus::Finished;
}
7 => {
let mut var_field0 = <String>::sse_decode(deserializer);
return crate::api::webrtc::RTCStatus::Error(var_field0);
}
_ => {
unimplemented!("");
}
}
}
}
impl SseDecode for crate::api::crypto::SecurityContext {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_privateKey = <String>::sse_decode(deserializer);
let mut var_publicKey = <String>::sse_decode(deserializer);
let mut var_certificate = <String>::sse_decode(deserializer);
let mut var_certificateHash = <String>::sse_decode(deserializer);
return crate::api::crypto::SecurityContext {
private_key: var_privateKey,
public_key: var_publicKey,
certificate: var_certificate,
certificate_hash: var_certificateHash,
};
}
}
impl SseDecode for crate::api::server::SessionEndReasonV2 {
// 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 = <i32>::sse_decode(deserializer);
return match inner {
0 => crate::api::server::SessionEndReasonV2::Finished,
1 => crate::api::server::SessionEndReasonV2::Cancelled,
_ => unreachable!("Invalid variant for SessionEndReasonV2: {}", inner),
};
}
}
impl SseDecode for crate::api::server::TlsConfig {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_cert = <String>::sse_decode(deserializer);
let mut var_privateKey = <String>::sse_decode(deserializer);
return crate::api::server::TlsConfig {
cert: var_cert,
private_key: var_privateKey,
};
}
}
impl SseDecode for u16 {
// 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_u16::<NativeEndian>().unwrap()
}
}
impl SseDecode for u32 {
// 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_u32::<NativeEndian>().unwrap()
}
}
impl SseDecode for u64 {
// 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()
}
}
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 crate::api::server::WebI18n {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_waiting = <String>::sse_decode(deserializer);
let mut var_enterPin = <String>::sse_decode(deserializer);
let mut var_invalidPin = <String>::sse_decode(deserializer);
let mut var_tooManyAttempts = <String>::sse_decode(deserializer);
let mut var_rejected = <String>::sse_decode(deserializer);
let mut var_uploadRejected = <String>::sse_decode(deserializer);
let mut var_busy = <String>::sse_decode(deserializer);
let mut var_files = <String>::sse_decode(deserializer);
let mut var_fileName = <String>::sse_decode(deserializer);
let mut var_size = <String>::sse_decode(deserializer);
return crate::api::server::WebI18n {
waiting: var_waiting,
enter_pin: var_enterPin,
invalid_pin: var_invalidPin,
too_many_attempts: var_tooManyAttempts,
rejected: var_rejected,
upload_rejected: var_uploadRejected,
busy: var_busy,
files: var_files,
file_name: var_fileName,
size: var_size,
};
}
}
impl SseDecode for crate::api::server::WebParams {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_send = <Option<crate::api::server::WebSendParams>>::sse_decode(deserializer);
let mut var_upload = <bool>::sse_decode(deserializer);
let mut var_i18N = <crate::api::server::WebI18n>::sse_decode(deserializer);
return crate::api::server::WebParams {
send: var_send,
upload: var_upload,
i18n: var_i18N,
};
}
}
impl SseDecode for crate::api::server::WebSendParams {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_files =
<std::collections::HashMap<String, crate::api::model::FileDto>>::sse_decode(
deserializer,
);
let mut var_pin = <Option<String>>::sse_decode(deserializer);
return crate::api::server::WebSendParams {
files: var_files,
pin: var_pin,
};
}
}
impl SseDecode for crate::api::webrtc::WsServerMessage {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut tag_ = <i32>::sse_decode(deserializer);
match tag_ {
0 => {
let mut var_client = <crate::api::webrtc::ClientInfo>::sse_decode(deserializer);
let mut var_peers = <Vec<crate::api::webrtc::ClientInfo>>::sse_decode(deserializer);
return crate::api::webrtc::WsServerMessage::Hello {
client: var_client,
peers: var_peers,
};
}
1 => {
let mut var_peer = <crate::api::webrtc::ClientInfo>::sse_decode(deserializer);
return crate::api::webrtc::WsServerMessage::Join { peer: var_peer };
}
2 => {
let mut var_peer = <crate::api::webrtc::ClientInfo>::sse_decode(deserializer);
return crate::api::webrtc::WsServerMessage::Update { peer: var_peer };
}
3 => {
let mut var_peerId = <uuid::Uuid>::sse_decode(deserializer);
return crate::api::webrtc::WsServerMessage::Left {
peer_id: var_peerId,
};
}
4 => {
let mut var_field0 =
<crate::api::webrtc::WsServerSdpMessage>::sse_decode(deserializer);
return crate::api::webrtc::WsServerMessage::Offer(var_field0);
}
5 => {
let mut var_field0 =
<crate::api::webrtc::WsServerSdpMessage>::sse_decode(deserializer);
return crate::api::webrtc::WsServerMessage::Answer(var_field0);
}
6 => {
let mut var_code = <u16>::sse_decode(deserializer);
return crate::api::webrtc::WsServerMessage::Error { code: var_code };
}
_ => {
unimplemented!("");
}
}
}
}
impl SseDecode for crate::api::webrtc::WsServerSdpMessage {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_peer = <crate::api::webrtc::ClientInfo>::sse_decode(deserializer);
let mut var_sessionId = <String>::sse_decode(deserializer);
let mut var_sdp = <String>::sse_decode(deserializer);
return crate::api::webrtc::WsServerSdpMessage {
peer: var_peer,
session_id: var_sessionId,
sdp: var_sdp,
};
}
}
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__stream__Dart2RustStreamSink_add_impl(
port,
ptr,
rust_vec_len,
data_len,
),
3 => wire__crate__api__webrtc__LsSignalingConnection_accept_offer_impl(
port,
ptr,
rust_vec_len,
data_len,
),
4 => wire__crate__api__webrtc__LsSignalingConnection_send_offer_impl(
port,
ptr,
rust_vec_len,
data_len,
),
5 => wire__crate__api__webrtc__LsSignalingConnection_update_info_impl(
port,
ptr,
rust_vec_len,
data_len,
),
7 => wire__crate__api__discovery__RsDiscovery_add_device_impl(
port,
ptr,
rust_vec_len,
data_len,
),
8 => wire__crate__api__discovery__RsDiscovery_announce_impl(
port,
ptr,
rust_vec_len,
data_len,
),
9 => wire__crate__api__discovery__RsDiscovery_discover_impl(
port,
ptr,
rust_vec_len,
data_len,
),
10 => {
wire__crate__api__discovery__RsDiscovery_listen_impl(port, ptr, rust_vec_len, data_len)
}
11 => wire__crate__api__discovery__RsDiscovery_multicast_error_impl(
port,
ptr,
rust_vec_len,
data_len,
),
12 => wire__crate__api__discovery__RsDiscovery_scan_subnet_impl(
port,
ptr,
rust_vec_len,
data_len,
),
13 => wire__crate__api__discovery__RsDiscovery_set_answer_announcements_impl(
port,
ptr,
rust_vec_len,
data_len,
),
14 => wire__crate__api__discovery__RsDiscovery_stop_impl(port, ptr, rust_vec_len, data_len),
15 => wire__crate__api__http__RsHttpClient_cancel_impl(port, ptr, rust_vec_len, data_len),
16 => wire__crate__api__http__RsHttpClient_prepare_upload_impl(
port,
ptr,
rust_vec_len,
data_len,
),
17 => wire__crate__api__http__RsHttpClient_register_impl(port, ptr, rust_vec_len, data_len),
18 => wire__crate__api__http__RsHttpClient_upload_impl(port, ptr, rust_vec_len, data_len),
19 => wire__crate__api__server__RsHttpServer_cancel_session_impl(
port,
ptr,
rust_vec_len,
data_len,
),
20 => wire__crate__api__server__RsHttpServer_fail_file_download_impl(
port,
ptr,
rust_vec_len,
data_len,
),
21 => wire__crate__api__server__RsHttpServer_fail_file_upload_impl(
port,
ptr,
rust_vec_len,
data_len,
),
22 => wire__crate__api__server__RsHttpServer_listen_impl(port, ptr, rust_vec_len, data_len),
23 => wire__crate__api__server__RsHttpServer_respond_file_download_impl(
port,
ptr,
rust_vec_len,
data_len,
),
24 => wire__crate__api__server__RsHttpServer_respond_file_upload_impl(
port,
ptr,
rust_vec_len,
data_len,
),
25 => wire__crate__api__server__RsHttpServer_respond_prepare_download_impl(
port,
ptr,
rust_vec_len,
data_len,
),
26 => wire__crate__api__server__RsHttpServer_respond_prepare_upload_impl(
port,
ptr,
rust_vec_len,
data_len,
),
27 => wire__crate__api__server__RsHttpServer_stop_impl(port, ptr, rust_vec_len, data_len),
28 => wire__crate__api__webrtc__RtcFileReceiver_get_file_id_impl(
port,
ptr,
rust_vec_len,
data_len,
),
29 => wire__crate__api__webrtc__RtcFileReceiver_receive_impl(
port,
ptr,
rust_vec_len,
data_len,
),
30 => wire__crate__api__webrtc__RtcFileSender_send_impl(port, ptr, rust_vec_len, data_len),
31 => wire__crate__api__webrtc__RtcReceiveController_decline_impl(
port,
ptr,
rust_vec_len,
data_len,
),
32 => wire__crate__api__webrtc__RtcReceiveController_listen_error_impl(
port,
ptr,
rust_vec_len,
data_len,
),
33 => wire__crate__api__webrtc__RtcReceiveController_listen_files_impl(
port,
ptr,
rust_vec_len,
data_len,
),
34 => wire__crate__api__webrtc__RtcReceiveController_listen_receiving_impl(
port,
ptr,
rust_vec_len,
data_len,
),
35 => wire__crate__api__webrtc__RtcReceiveController_listen_status_impl(
port,
ptr,
rust_vec_len,
data_len,
),
36 => wire__crate__api__webrtc__RtcReceiveController_send_file_status_impl(
port,
ptr,
rust_vec_len,
data_len,
),
37 => wire__crate__api__webrtc__RtcReceiveController_send_pin_impl(
port,
ptr,
rust_vec_len,
data_len,
),
38 => wire__crate__api__webrtc__RtcReceiveController_send_selection_impl(
port,
ptr,
rust_vec_len,
data_len,
),
39 => wire__crate__api__webrtc__RtcSendController_listen_error_impl(
port,
ptr,
rust_vec_len,
data_len,
),
40 => wire__crate__api__webrtc__RtcSendController_listen_selected_files_impl(
port,
ptr,
rust_vec_len,
data_len,
),
41 => wire__crate__api__webrtc__RtcSendController_listen_status_impl(
port,
ptr,
rust_vec_len,
data_len,
),
42 => wire__crate__api__webrtc__RtcSendController_send_file_impl(
port,
ptr,
rust_vec_len,
data_len,
),
43 => wire__crate__api__webrtc__RtcSendController_send_pin_impl(
port,
ptr,
rust_vec_len,
data_len,
),
44 => wire__crate__api__webrtc__connect_impl(port, ptr, rust_vec_len, data_len),
47 => wire__crate__api__stream__create_stream_impl(port, ptr, rust_vec_len, data_len),
48 => {
wire__crate__api__logging__enable_debug_logging_impl(port, ptr, rust_vec_len, data_len)
}
49 => wire__crate__api__crypto__generate_key_pair_impl(port, ptr, rust_vec_len, data_len),
50 => wire__crate__api__crypto__generate_security_context_impl(
port,
ptr,
rust_vec_len,
data_len,
),
51 => wire__crate__api__crypto__hash_file_impl(port, ptr, rust_vec_len, data_len),
54 => wire__crate__api__discovery__start_discovery_impl(port, ptr, rust_vec_len, data_len),
55 => wire__crate__api__server__start_server_impl(port, ptr, rust_vec_len, data_len),
56 => wire__crate__api__crypto__verify_cert_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__stream__Dart2RustStreamSink_close_impl(ptr, rust_vec_len, data_len),
6 => wire__crate__api__cancel__RsCancellationToken_cancel_impl(ptr, rust_vec_len, data_len),
45 => wire__crate__api__cancel__create_cancellation_token_impl(ptr, rust_vec_len, data_len),
46 => wire__crate__api__http__create_client_impl(ptr, rust_vec_len, data_len),
52 => wire__crate__api__filename__is_valid_file_name_impl(ptr, rust_vec_len, data_len),
53 => wire__crate__api__filename__sanitize_file_name_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<Dart2RustStreamReceiver> {
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<Dart2RustStreamReceiver>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<Dart2RustStreamReceiver>>
for Dart2RustStreamReceiver
{
fn into_into_dart(self) -> FrbWrapper<Dart2RustStreamReceiver> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<Dart2RustStreamSink> {
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<Dart2RustStreamSink>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<Dart2RustStreamSink>> for Dart2RustStreamSink {
fn into_into_dart(self) -> FrbWrapper<Dart2RustStreamSink> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<LsSignalingConnection> {
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<LsSignalingConnection>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<LsSignalingConnection>>
for LsSignalingConnection
{
fn into_into_dart(self) -> FrbWrapper<LsSignalingConnection> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<RTCFileReceiver> {
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<RTCFileReceiver> {}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<RTCFileReceiver>> for RTCFileReceiver {
fn into_into_dart(self) -> FrbWrapper<RTCFileReceiver> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<RTCFileSender> {
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<RTCFileSender> {}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<RTCFileSender>> for RTCFileSender {
fn into_into_dart(self) -> FrbWrapper<RTCFileSender> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<RTCReceiveController> {
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<RTCReceiveController>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<RTCReceiveController>> for RTCReceiveController {
fn into_into_dart(self) -> FrbWrapper<RTCReceiveController> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<RTCSendController> {
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<RTCSendController> {}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<RTCSendController>> for RTCSendController {
fn into_into_dart(self) -> FrbWrapper<RTCSendController> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<RsCancellationToken> {
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<RsCancellationToken>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<RsCancellationToken>> for RsCancellationToken {
fn into_into_dart(self) -> FrbWrapper<RsCancellationToken> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<RsDiscovery> {
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<RsDiscovery> {}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<RsDiscovery>> for RsDiscovery {
fn into_into_dart(self) -> FrbWrapper<RsDiscovery> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<RsHttpClient> {
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<RsHttpClient> {}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<RsHttpClient>> for RsHttpClient {
fn into_into_dart(self) -> FrbWrapper<RsHttpClient> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<RsHttpServer> {
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<RsHttpServer> {}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<RsHttpServer>> for RsHttpServer {
fn into_into_dart(self) -> FrbWrapper<RsHttpServer> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::webrtc::ClientInfo> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.0.id.into_into_dart().into_dart(),
self.0.alias.into_into_dart().into_dart(),
self.0.version.into_into_dart().into_dart(),
self.0.device_model.into_into_dart().into_dart(),
self.0.device_type.into_into_dart().into_dart(),
self.0.token.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::webrtc::ClientInfo>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::webrtc::ClientInfo>>
for crate::api::webrtc::ClientInfo
{
fn into_into_dart(self) -> FrbWrapper<crate::api::webrtc::ClientInfo> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::webrtc::ClientInfoWithoutId> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.0.alias.into_into_dart().into_dart(),
self.0.version.into_into_dart().into_dart(),
self.0.device_model.into_into_dart().into_dart(),
self.0.device_type.into_into_dart().into_dart(),
self.0.token.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::webrtc::ClientInfoWithoutId>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::webrtc::ClientInfoWithoutId>>
for crate::api::webrtc::ClientInfoWithoutId
{
fn into_into_dart(self) -> FrbWrapper<crate::api::webrtc::ClientInfoWithoutId> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::model::DeviceType> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
match self.0 {
crate::api::model::DeviceType::Mobile => 0.into_dart(),
crate::api::model::DeviceType::Desktop => 1.into_dart(),
crate::api::model::DeviceType::Web => 2.into_dart(),
crate::api::model::DeviceType::Headless => 3.into_dart(),
crate::api::model::DeviceType::Server => 4.into_dart(),
_ => unreachable!(),
}
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::model::DeviceType>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::model::DeviceType>>
for crate::api::model::DeviceType
{
fn into_into_dart(self) -> FrbWrapper<crate::api::model::DeviceType> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::api::webrtc::ExpectingPublicKey {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.public_key.into_into_dart().into_dart(),
self.kind.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for crate::api::webrtc::ExpectingPublicKey
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::api::webrtc::ExpectingPublicKey>
for crate::api::webrtc::ExpectingPublicKey
{
fn into_into_dart(self) -> crate::api::webrtc::ExpectingPublicKey {
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::model::FileDto> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.0.id.into_into_dart().into_dart(),
self.0.file_name.into_into_dart().into_dart(),
self.0.size.into_into_dart().into_dart(),
self.0.file_type.into_into_dart().into_dart(),
self.0.sha256.into_into_dart().into_dart(),
self.0.preview.into_into_dart().into_dart(),
self.0.metadata.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::model::FileDto>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::model::FileDto>>
for crate::api::model::FileDto
{
fn into_into_dart(self) -> FrbWrapper<crate::api::model::FileDto> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::model::FileMetadata> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.0.modified.into_into_dart().into_dart(),
self.0.accessed.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::model::FileMetadata>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::model::FileMetadata>>
for crate::api::model::FileMetadata
{
fn into_into_dart(self) -> FrbWrapper<crate::api::model::FileMetadata> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::api::crypto::KeyPair {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.private_key.into_into_dart().into_dart(),
self.public_key.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::crypto::KeyPair {}
impl flutter_rust_bridge::IntoIntoDart<crate::api::crypto::KeyPair>
for crate::api::crypto::KeyPair
{
fn into_into_dart(self) -> crate::api::crypto::KeyPair {
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::http::LsHttpClientVersion> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
match self.0 {
crate::api::http::LsHttpClientVersion::V2 => 0.into_dart(),
crate::api::http::LsHttpClientVersion::V3 => 1.into_dart(),
_ => unreachable!(),
}
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::http::LsHttpClientVersion>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::http::LsHttpClientVersion>>
for crate::api::http::LsHttpClientVersion
{
fn into_into_dart(self) -> FrbWrapper<crate::api::http::LsHttpClientVersion> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::webrtc::PinConfig> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.0.pin.into_into_dart().into_dart(),
self.0.max_tries.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::webrtc::PinConfig>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::webrtc::PinConfig>>
for crate::api::webrtc::PinConfig
{
fn into_into_dart(self) -> FrbWrapper<crate::api::webrtc::PinConfig> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::model::PrepareUploadRequestDto> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.0.info.into_into_dart().into_dart(),
self.0.files.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::model::PrepareUploadRequestDto>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::model::PrepareUploadRequestDto>>
for crate::api::model::PrepareUploadRequestDto
{
fn into_into_dart(self) -> FrbWrapper<crate::api::model::PrepareUploadRequestDto> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::model::PrepareUploadResponseDto> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.0.session_id.into_into_dart().into_dart(),
self.0.files.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::model::PrepareUploadResponseDto>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::model::PrepareUploadResponseDto>>
for crate::api::model::PrepareUploadResponseDto
{
fn into_into_dart(self) -> FrbWrapper<crate::api::model::PrepareUploadResponseDto> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::http::PrepareUploadResult> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.0.status_code.into_into_dart().into_dart(),
self.0.response.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::http::PrepareUploadResult>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::http::PrepareUploadResult>>
for crate::api::http::PrepareUploadResult
{
fn into_into_dart(self) -> FrbWrapper<crate::api::http::PrepareUploadResult> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::api::webrtc::ProposingClientInfo {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.alias.into_into_dart().into_dart(),
self.version.into_into_dart().into_dart(),
self.device_model.into_into_dart().into_dart(),
self.device_type.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for crate::api::webrtc::ProposingClientInfo
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::api::webrtc::ProposingClientInfo>
for crate::api::webrtc::ProposingClientInfo
{
fn into_into_dart(self) -> crate::api::webrtc::ProposingClientInfo {
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::model::ProtocolType> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
match self.0 {
crate::api::model::ProtocolType::Http => 0.into_dart(),
crate::api::model::ProtocolType::Https => 1.into_dart(),
_ => unreachable!(),
}
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::model::ProtocolType>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::model::ProtocolType>>
for crate::api::model::ProtocolType
{
fn into_into_dart(self) -> FrbWrapper<crate::api::model::ProtocolType> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::model::RegisterDto> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.0.alias.into_into_dart().into_dart(),
self.0.version.into_into_dart().into_dart(),
self.0.device_model.into_into_dart().into_dart(),
self.0.device_type.into_into_dart().into_dart(),
self.0.token.into_into_dart().into_dart(),
self.0.port.into_into_dart().into_dart(),
self.0.protocol.into_into_dart().into_dart(),
self.0.has_web_interface.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::model::RegisterDto>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::model::RegisterDto>>
for crate::api::model::RegisterDto
{
fn into_into_dart(self) -> FrbWrapper<crate::api::model::RegisterDto> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::server::RegisterDtoV2> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.0.alias.into_into_dart().into_dart(),
self.0.version.into_into_dart().into_dart(),
self.0.device_model.into_into_dart().into_dart(),
self.0.device_type.into_into_dart().into_dart(),
self.0.fingerprint.into_into_dart().into_dart(),
self.0.port.into_into_dart().into_dart(),
self.0.protocol.into_into_dart().into_dart(),
self.0.download.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::server::RegisterDtoV2>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::server::RegisterDtoV2>>
for crate::api::server::RegisterDtoV2
{
fn into_into_dart(self) -> FrbWrapper<crate::api::server::RegisterDtoV2> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::model::RegisterResponseDto> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.0.alias.into_into_dart().into_dart(),
self.0.version.into_into_dart().into_dart(),
self.0.device_model.into_into_dart().into_dart(),
self.0.device_type.into_into_dart().into_dart(),
self.0.token.into_into_dart().into_dart(),
self.0.has_web_interface.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::model::RegisterResponseDto>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::model::RegisterResponseDto>>
for crate::api::model::RegisterResponseDto
{
fn into_into_dart(self) -> FrbWrapper<crate::api::model::RegisterResponseDto> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::api::http::ResultWithPublicKeyRegisterResponseDto {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.public_key.into_into_dart().into_dart(),
self.body.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for crate::api::http::ResultWithPublicKeyRegisterResponseDto
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::api::http::ResultWithPublicKeyRegisterResponseDto>
for crate::api::http::ResultWithPublicKeyRegisterResponseDto
{
fn into_into_dart(self) -> crate::api::http::ResultWithPublicKeyRegisterResponseDto {
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::api::discovery::RsDeviceChannel {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.host.into_into_dart().into_dart(),
self.port.into_into_dart().into_dart(),
self.protocol.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for crate::api::discovery::RsDeviceChannel
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::api::discovery::RsDeviceChannel>
for crate::api::discovery::RsDeviceChannel
{
fn into_into_dart(self) -> crate::api::discovery::RsDeviceChannel {
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::api::discovery::RsDiscoveredDevice {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.alias.into_into_dart().into_dart(),
self.version.into_into_dart().into_dart(),
self.device_model.into_into_dart().into_dart(),
self.device_type.into_into_dart().into_dart(),
self.fingerprint.into_into_dart().into_dart(),
self.host.into_into_dart().into_dart(),
self.port.into_into_dart().into_dart(),
self.protocol.into_into_dart().into_dart(),
self.download.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for crate::api::discovery::RsDiscoveredDevice
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::api::discovery::RsDiscoveredDevice>
for crate::api::discovery::RsDiscoveredDevice
{
fn into_into_dart(self) -> crate::api::discovery::RsDiscoveredDevice {
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::api::crypto::RsHashFileEvent {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
match self {
crate::api::crypto::RsHashFileEvent::Progress { bytes } => {
[0.into_dart(), bytes.into_into_dart().into_dart()].into_dart()
}
crate::api::crypto::RsHashFileEvent::Done { hash } => {
[1.into_dart(), hash.into_into_dart().into_dart()].into_dart()
}
_ => {
unimplemented!("");
}
}
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for crate::api::crypto::RsHashFileEvent
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::api::crypto::RsHashFileEvent>
for crate::api::crypto::RsHashFileEvent
{
fn into_into_dart(self) -> crate::api::crypto::RsHashFileEvent {
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::api::http::RsHttpClientError {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
match self {
crate::api::http::RsHttpClientError::StatusCode { status, message } => [
0.into_dart(),
status.into_into_dart().into_dart(),
message.into_into_dart().into_dart(),
]
.into_dart(),
crate::api::http::RsHttpClientError::Reqwest(field0) => {
[1.into_dart(), field0.into_into_dart().into_dart()].into_dart()
}
crate::api::http::RsHttpClientError::Json(field0) => {
[2.into_dart(), field0.into_into_dart().into_dart()].into_dart()
}
crate::api::http::RsHttpClientError::Io(field0) => {
[3.into_dart(), field0.into_into_dart().into_dart()].into_dart()
}
crate::api::http::RsHttpClientError::Other(field0) => {
[4.into_dart(), field0.into_into_dart().into_dart()].into_dart()
}
_ => {
unimplemented!("");
}
}
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for crate::api::http::RsHttpClientError
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::api::http::RsHttpClientError>
for crate::api::http::RsHttpClientError
{
fn into_into_dart(self) -> crate::api::http::RsHttpClientError {
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::api::server::RsServerEvent {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
match self {
crate::api::server::RsServerEvent::Register { ip, info } => [
0.into_dart(),
ip.into_into_dart().into_dart(),
info.into_into_dart().into_dart(),
]
.into_dart(),
crate::api::server::RsServerEvent::PrepareUpload {
session_id,
ip,
info,
cert_fingerprint,
files,
} => [
1.into_dart(),
session_id.into_into_dart().into_dart(),
ip.into_into_dart().into_dart(),
info.into_into_dart().into_dart(),
cert_fingerprint.into_into_dart().into_dart(),
files.into_into_dart().into_dart(),
]
.into_dart(),
crate::api::server::RsServerEvent::FileUpload {
session_id,
file_id,
file,
} => [
2.into_dart(),
session_id.into_into_dart().into_dart(),
file_id.into_into_dart().into_dart(),
file.into_into_dart().into_dart(),
]
.into_dart(),
crate::api::server::RsServerEvent::SessionEnd { session_id, reason } => [
3.into_dart(),
session_id.into_into_dart().into_dart(),
reason.into_into_dart().into_dart(),
]
.into_dart(),
crate::api::server::RsServerEvent::PrepareUploadAborted { session_id } => {
[4.into_dart(), session_id.into_into_dart().into_dart()].into_dart()
}
crate::api::server::RsServerEvent::CancelReceived { ip, session_id } => [
5.into_dart(),
ip.into_into_dart().into_dart(),
session_id.into_into_dart().into_dart(),
]
.into_dart(),
crate::api::server::RsServerEvent::WebPrepareDownload {
ip,
session_id,
user_agent,
} => [
6.into_dart(),
ip.into_into_dart().into_dart(),
session_id.into_into_dart().into_dart(),
user_agent.into_into_dart().into_dart(),
]
.into_dart(),
crate::api::server::RsServerEvent::WebFileDownload {
session_id,
file_id,
file,
} => [
7.into_dart(),
session_id.into_into_dart().into_dart(),
file_id.into_into_dart().into_dart(),
file.into_into_dart().into_dart(),
]
.into_dart(),
crate::api::server::RsServerEvent::Show { args } => {
[8.into_dart(), args.into_into_dart().into_dart()].into_dart()
}
_ => {
unimplemented!("");
}
}
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for crate::api::server::RsServerEvent
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::api::server::RsServerEvent>
for crate::api::server::RsServerEvent
{
fn into_into_dart(self) -> crate::api::server::RsServerEvent {
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::api::discovery::RsStoredDevice {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.alias.into_into_dart().into_dart(),
self.version.into_into_dart().into_dart(),
self.device_model.into_into_dart().into_dart(),
self.device_type.into_into_dart().into_dart(),
self.fingerprint.into_into_dart().into_dart(),
self.download.into_into_dart().into_dart(),
self.channels.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for crate::api::discovery::RsStoredDevice
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::api::discovery::RsStoredDevice>
for crate::api::discovery::RsStoredDevice
{
fn into_into_dart(self) -> crate::api::discovery::RsStoredDevice {
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::webrtc::RTCFileError> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.0.file_id.into_into_dart().into_dart(),
self.0.error.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::webrtc::RTCFileError>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::webrtc::RTCFileError>>
for crate::api::webrtc::RTCFileError
{
fn into_into_dart(self) -> FrbWrapper<crate::api::webrtc::RTCFileError> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::webrtc::RTCSendFileResponse> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.0.id.into_into_dart().into_dart(),
self.0.success.into_into_dart().into_dart(),
self.0.error.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::webrtc::RTCSendFileResponse>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::webrtc::RTCSendFileResponse>>
for crate::api::webrtc::RTCSendFileResponse
{
fn into_into_dart(self) -> FrbWrapper<crate::api::webrtc::RTCSendFileResponse> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::webrtc::RTCStatus> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
match self.0 {
crate::api::webrtc::RTCStatus::SdpExchanged => [0.into_dart()].into_dart(),
crate::api::webrtc::RTCStatus::Connected => [1.into_dart()].into_dart(),
crate::api::webrtc::RTCStatus::PinRequired => [2.into_dart()].into_dart(),
crate::api::webrtc::RTCStatus::TooManyAttempts => [3.into_dart()].into_dart(),
crate::api::webrtc::RTCStatus::Declined => [4.into_dart()].into_dart(),
crate::api::webrtc::RTCStatus::Sending => [5.into_dart()].into_dart(),
crate::api::webrtc::RTCStatus::Finished => [6.into_dart()].into_dart(),
crate::api::webrtc::RTCStatus::Error(field0) => {
[7.into_dart(), field0.into_into_dart().into_dart()].into_dart()
}
_ => {
unimplemented!("");
}
}
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::webrtc::RTCStatus>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::webrtc::RTCStatus>>
for crate::api::webrtc::RTCStatus
{
fn into_into_dart(self) -> FrbWrapper<crate::api::webrtc::RTCStatus> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::api::crypto::SecurityContext {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.private_key.into_into_dart().into_dart(),
self.public_key.into_into_dart().into_dart(),
self.certificate.into_into_dart().into_dart(),
self.certificate_hash.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for crate::api::crypto::SecurityContext
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::api::crypto::SecurityContext>
for crate::api::crypto::SecurityContext
{
fn into_into_dart(self) -> crate::api::crypto::SecurityContext {
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::server::SessionEndReasonV2> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
match self.0 {
crate::api::server::SessionEndReasonV2::Finished => 0.into_dart(),
crate::api::server::SessionEndReasonV2::Cancelled => 1.into_dart(),
_ => unreachable!(),
}
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::server::SessionEndReasonV2>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::server::SessionEndReasonV2>>
for crate::api::server::SessionEndReasonV2
{
fn into_into_dart(self) -> FrbWrapper<crate::api::server::SessionEndReasonV2> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::server::TlsConfig> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.0.cert.into_into_dart().into_dart(),
self.0.private_key.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::server::TlsConfig>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::server::TlsConfig>>
for crate::api::server::TlsConfig
{
fn into_into_dart(self) -> FrbWrapper<crate::api::server::TlsConfig> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::server::WebI18n> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.0.waiting.into_into_dart().into_dart(),
self.0.enter_pin.into_into_dart().into_dart(),
self.0.invalid_pin.into_into_dart().into_dart(),
self.0.too_many_attempts.into_into_dart().into_dart(),
self.0.rejected.into_into_dart().into_dart(),
self.0.upload_rejected.into_into_dart().into_dart(),
self.0.busy.into_into_dart().into_dart(),
self.0.files.into_into_dart().into_dart(),
self.0.file_name.into_into_dart().into_dart(),
self.0.size.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::server::WebI18n>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::server::WebI18n>>
for crate::api::server::WebI18n
{
fn into_into_dart(self) -> FrbWrapper<crate::api::server::WebI18n> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::api::server::WebParams {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.send.into_into_dart().into_dart(),
self.upload.into_into_dart().into_dart(),
self.i18n.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::server::WebParams {}
impl flutter_rust_bridge::IntoIntoDart<crate::api::server::WebParams>
for crate::api::server::WebParams
{
fn into_into_dart(self) -> crate::api::server::WebParams {
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::api::server::WebSendParams {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.files.into_into_dart().into_dart(),
self.pin.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for crate::api::server::WebSendParams
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::api::server::WebSendParams>
for crate::api::server::WebSendParams
{
fn into_into_dart(self) -> crate::api::server::WebSendParams {
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::webrtc::WsServerMessage> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
match self.0 {
crate::api::webrtc::WsServerMessage::Hello { client, peers } => [
0.into_dart(),
client.into_into_dart().into_dart(),
peers.into_into_dart().into_dart(),
]
.into_dart(),
crate::api::webrtc::WsServerMessage::Join { peer } => {
[1.into_dart(), peer.into_into_dart().into_dart()].into_dart()
}
crate::api::webrtc::WsServerMessage::Update { peer } => {
[2.into_dart(), peer.into_into_dart().into_dart()].into_dart()
}
crate::api::webrtc::WsServerMessage::Left { peer_id } => {
[3.into_dart(), peer_id.into_into_dart().into_dart()].into_dart()
}
crate::api::webrtc::WsServerMessage::Offer(field0) => {
[4.into_dart(), field0.into_into_dart().into_dart()].into_dart()
}
crate::api::webrtc::WsServerMessage::Answer(field0) => {
[5.into_dart(), field0.into_into_dart().into_dart()].into_dart()
}
crate::api::webrtc::WsServerMessage::Error { code } => {
[6.into_dart(), code.into_into_dart().into_dart()].into_dart()
}
_ => {
unimplemented!("");
}
}
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::webrtc::WsServerMessage>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::webrtc::WsServerMessage>>
for crate::api::webrtc::WsServerMessage
{
fn into_into_dart(self) -> FrbWrapper<crate::api::webrtc::WsServerMessage> {
self.into()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::api::webrtc::WsServerSdpMessage> {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.0.peer.into_into_dart().into_dart(),
self.0.session_id.into_into_dart().into_dart(),
self.0.sdp.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for FrbWrapper<crate::api::webrtc::WsServerSdpMessage>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::api::webrtc::WsServerSdpMessage>>
for crate::api::webrtc::WsServerSdpMessage
{
fn into_into_dart(self) -> FrbWrapper<crate::api::webrtc::WsServerSdpMessage> {
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 Dart2RustStreamReceiver {
// 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<Dart2RustStreamReceiver>,
>>::sse_encode(
flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self),
serializer,
);
}
}
impl SseEncode for Dart2RustStreamSink {
// 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<Dart2RustStreamSink>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer);
}
}
impl SseEncode for LsSignalingConnection {
// 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<LsSignalingConnection>,
>>::sse_encode(
flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self),
serializer,
);
}
}
impl SseEncode for RTCFileReceiver {
// 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<RTCFileReceiver>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer);
}
}
impl SseEncode for RTCFileSender {
// 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<RTCFileSender>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer);
}
}
impl SseEncode for RTCReceiveController {
// 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<RTCReceiveController>,
>>::sse_encode(
flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self),
serializer,
);
}
}
impl SseEncode for RTCSendController {
// 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<RTCSendController>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer);
}
}
impl SseEncode for RsCancellationToken {
// 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<RsCancellationToken>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer);
}
}
impl SseEncode for RsDiscovery {
// 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<RsDiscovery>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer);
}
}
impl SseEncode for RsHttpClient {
// 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<RsHttpClient>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer);
}
}
impl SseEncode for RsHttpServer {
// 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<RsHttpServer>>>::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 std::collections::HashMap<String, String> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<Vec<(String, String)>>::sse_encode(self.into_iter().collect(), serializer);
}
}
impl SseEncode for std::collections::HashMap<String, crate::api::model::FileDto> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<Vec<(String, crate::api::model::FileDto)>>::sse_encode(
self.into_iter().collect(),
serializer,
);
}
}
impl SseEncode
for RustOpaqueMoi<
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Dart2RustStreamReceiver>,
>
{
// 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<Dart2RustStreamSink>>
{
// 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<LsSignalingConnection>,
>
{
// 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<RTCFileReceiver>>
{
// 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<RTCFileSender>>
{
// 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<RTCReceiveController>>
{
// 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<RTCSendController>>
{
// 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<RsCancellationToken>>
{
// 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<RsDiscovery>>
{
// 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<RsHttpClient>>
{
// 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<RsHttpServer>>
{
// 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 std::collections::HashSet<String> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<Vec<String>>::sse_encode(self.into_iter().collect(), serializer);
}
}
impl SseEncode for StreamSink<RTCFileReceiver, flutter_rust_bridge::for_generated::SseCodec> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
unimplemented!("")
}
}
impl SseEncode for StreamSink<f64, flutter_rust_bridge::for_generated::SseCodec> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
unimplemented!("")
}
}
impl SseEncode for StreamSink<Vec<u8>, flutter_rust_bridge::for_generated::SseCodec> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
unimplemented!("")
}
}
impl SseEncode
for StreamSink<
crate::api::crypto::RsHashFileEvent,
flutter_rust_bridge::for_generated::SseCodec,
>
{
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
unimplemented!("")
}
}
impl SseEncode
for StreamSink<crate::api::server::RsServerEvent, flutter_rust_bridge::for_generated::SseCodec>
{
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
unimplemented!("")
}
}
impl SseEncode
for StreamSink<
crate::api::discovery::RsStoredDevice,
flutter_rust_bridge::for_generated::SseCodec,
>
{
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
unimplemented!("")
}
}
impl SseEncode
for StreamSink<crate::api::webrtc::RTCFileError, flutter_rust_bridge::for_generated::SseCodec>
{
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
unimplemented!("")
}
}
impl SseEncode
for StreamSink<crate::api::webrtc::RTCStatus, flutter_rust_bridge::for_generated::SseCodec>
{
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
unimplemented!("")
}
}
impl SseEncode
for StreamSink<
crate::api::webrtc::WsServerMessage,
flutter_rust_bridge::for_generated::SseCodec,
>
{
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
unimplemented!("")
}
}
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 uuid::Uuid {
// 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.as_bytes().to_vec(), serializer);
}
}
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();
}
}
impl SseEncode for crate::api::webrtc::ClientInfo {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<uuid::Uuid>::sse_encode(self.id, serializer);
<String>::sse_encode(self.alias, serializer);
<String>::sse_encode(self.version, serializer);
<Option<String>>::sse_encode(self.device_model, serializer);
<Option<crate::api::model::DeviceType>>::sse_encode(self.device_type, serializer);
<String>::sse_encode(self.token, serializer);
}
}
impl SseEncode for crate::api::webrtc::ClientInfoWithoutId {
// 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(self.alias, serializer);
<String>::sse_encode(self.version, serializer);
<Option<String>>::sse_encode(self.device_model, serializer);
<Option<crate::api::model::DeviceType>>::sse_encode(self.device_type, serializer);
<String>::sse_encode(self.token, serializer);
}
}
impl SseEncode for crate::api::model::DeviceType {
// 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(
match self {
crate::api::model::DeviceType::Mobile => 0,
crate::api::model::DeviceType::Desktop => 1,
crate::api::model::DeviceType::Web => 2,
crate::api::model::DeviceType::Headless => 3,
crate::api::model::DeviceType::Server => 4,
_ => {
unimplemented!("");
}
},
serializer,
);
}
}
impl SseEncode for crate::api::webrtc::ExpectingPublicKey {
// 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(self.public_key, serializer);
<String>::sse_encode(self.kind, serializer);
}
}
impl SseEncode for f64 {
// 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_f64::<NativeEndian>(self).unwrap();
}
}
impl SseEncode for crate::api::model::FileDto {
// 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(self.id, serializer);
<String>::sse_encode(self.file_name, serializer);
<u64>::sse_encode(self.size, serializer);
<String>::sse_encode(self.file_type, serializer);
<Option<String>>::sse_encode(self.sha256, serializer);
<Option<String>>::sse_encode(self.preview, serializer);
<Option<crate::api::model::FileMetadata>>::sse_encode(self.metadata, serializer);
}
}
impl SseEncode for crate::api::model::FileMetadata {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<Option<String>>::sse_encode(self.modified, serializer);
<Option<String>>::sse_encode(self.accessed, serializer);
}
}
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 isize {
// 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_i64::<NativeEndian>(self as _)
.unwrap();
}
}
impl SseEncode for crate::api::crypto::KeyPair {
// 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(self.private_key, serializer);
<String>::sse_encode(self.public_key, serializer);
}
}
impl SseEncode for Vec<String> {
// 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 {
<String>::sse_encode(item, serializer);
}
}
}
impl SseEncode for Vec<crate::api::webrtc::ClientInfo> {
// 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 {
<crate::api::webrtc::ClientInfo>::sse_encode(item, serializer);
}
}
}
impl SseEncode for Vec<crate::api::model::FileDto> {
// 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 {
<crate::api::model::FileDto>::sse_encode(item, 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 Vec<(String, crate::api::model::FileDto)> {
// 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 {
<(String, crate::api::model::FileDto)>::sse_encode(item, serializer);
}
}
}
impl SseEncode for Vec<(String, String)> {
// 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 {
<(String, String)>::sse_encode(item, serializer);
}
}
}
impl SseEncode for Vec<crate::api::discovery::RsDeviceChannel> {
// 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 {
<crate::api::discovery::RsDeviceChannel>::sse_encode(item, serializer);
}
}
}
impl SseEncode for crate::api::http::LsHttpClientVersion {
// 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(
match self {
crate::api::http::LsHttpClientVersion::V2 => 0,
crate::api::http::LsHttpClientVersion::V3 => 1,
_ => {
unimplemented!("");
}
},
serializer,
);
}
}
impl SseEncode for Option<String> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<String>::sse_encode(value, serializer);
}
}
}
impl SseEncode for Option<Dart2RustStreamReceiver> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<Dart2RustStreamReceiver>::sse_encode(value, serializer);
}
}
}
impl SseEncode for Option<crate::api::model::DeviceType> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<crate::api::model::DeviceType>::sse_encode(value, serializer);
}
}
}
impl SseEncode for Option<crate::api::webrtc::ExpectingPublicKey> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<crate::api::webrtc::ExpectingPublicKey>::sse_encode(value, serializer);
}
}
}
impl SseEncode for Option<crate::api::model::FileMetadata> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<crate::api::model::FileMetadata>::sse_encode(value, serializer);
}
}
}
impl SseEncode for Option<i32> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<i32>::sse_encode(value, serializer);
}
}
}
impl SseEncode for Option<crate::api::webrtc::PinConfig> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<crate::api::webrtc::PinConfig>::sse_encode(value, serializer);
}
}
}
impl SseEncode for Option<crate::api::model::PrepareUploadResponseDto> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<crate::api::model::PrepareUploadResponseDto>::sse_encode(value, serializer);
}
}
}
impl SseEncode for Option<crate::api::discovery::RsStoredDevice> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<crate::api::discovery::RsStoredDevice>::sse_encode(value, serializer);
}
}
}
impl SseEncode for Option<crate::api::server::TlsConfig> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<crate::api::server::TlsConfig>::sse_encode(value, serializer);
}
}
}
impl SseEncode for Option<u32> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<u32>::sse_encode(value, serializer);
}
}
}
impl SseEncode for Option<crate::api::server::WebParams> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<crate::api::server::WebParams>::sse_encode(value, serializer);
}
}
}
impl SseEncode for Option<crate::api::server::WebSendParams> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<crate::api::server::WebSendParams>::sse_encode(value, serializer);
}
}
}
impl SseEncode for Option<Vec<String>> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<Vec<String>>::sse_encode(value, serializer);
}
}
}
impl SseEncode for Option<Vec<u8>> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<Vec<u8>>::sse_encode(value, serializer);
}
}
}
impl SseEncode for crate::api::webrtc::PinConfig {
// 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(self.pin, serializer);
<u8>::sse_encode(self.max_tries, serializer);
}
}
impl SseEncode for crate::api::model::PrepareUploadRequestDto {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<crate::api::model::RegisterDto>::sse_encode(self.info, serializer);
<std::collections::HashMap<String, crate::api::model::FileDto>>::sse_encode(
self.files, serializer,
);
}
}
impl SseEncode for crate::api::model::PrepareUploadResponseDto {
// 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(self.session_id, serializer);
<std::collections::HashMap<String, String>>::sse_encode(self.files, serializer);
}
}
impl SseEncode for crate::api::http::PrepareUploadResult {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<u16>::sse_encode(self.status_code, serializer);
<Option<crate::api::model::PrepareUploadResponseDto>>::sse_encode(
self.response,
serializer,
);
}
}
impl SseEncode for crate::api::webrtc::ProposingClientInfo {
// 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(self.alias, serializer);
<String>::sse_encode(self.version, serializer);
<Option<String>>::sse_encode(self.device_model, serializer);
<Option<crate::api::model::DeviceType>>::sse_encode(self.device_type, serializer);
}
}
impl SseEncode for crate::api::model::ProtocolType {
// 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(
match self {
crate::api::model::ProtocolType::Http => 0,
crate::api::model::ProtocolType::Https => 1,
_ => {
unimplemented!("");
}
},
serializer,
);
}
}
impl SseEncode for (Dart2RustStreamSink, Dart2RustStreamReceiver) {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<Dart2RustStreamSink>::sse_encode(self.0, serializer);
<Dart2RustStreamReceiver>::sse_encode(self.1, serializer);
}
}
impl SseEncode for (String, crate::api::model::FileDto) {
// 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(self.0, serializer);
<crate::api::model::FileDto>::sse_encode(self.1, serializer);
}
}
impl SseEncode for (String, String) {
// 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(self.0, serializer);
<String>::sse_encode(self.1, serializer);
}
}
impl SseEncode for crate::api::model::RegisterDto {
// 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(self.alias, serializer);
<String>::sse_encode(self.version, serializer);
<Option<String>>::sse_encode(self.device_model, serializer);
<Option<crate::api::model::DeviceType>>::sse_encode(self.device_type, serializer);
<String>::sse_encode(self.token, serializer);
<u16>::sse_encode(self.port, serializer);
<crate::api::model::ProtocolType>::sse_encode(self.protocol, serializer);
<bool>::sse_encode(self.has_web_interface, serializer);
}
}
impl SseEncode for crate::api::server::RegisterDtoV2 {
// 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(self.alias, serializer);
<String>::sse_encode(self.version, serializer);
<Option<String>>::sse_encode(self.device_model, serializer);
<Option<crate::api::model::DeviceType>>::sse_encode(self.device_type, serializer);
<String>::sse_encode(self.fingerprint, serializer);
<u16>::sse_encode(self.port, serializer);
<crate::api::model::ProtocolType>::sse_encode(self.protocol, serializer);
<bool>::sse_encode(self.download, serializer);
}
}
impl SseEncode for crate::api::model::RegisterResponseDto {
// 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(self.alias, serializer);
<String>::sse_encode(self.version, serializer);
<Option<String>>::sse_encode(self.device_model, serializer);
<Option<crate::api::model::DeviceType>>::sse_encode(self.device_type, serializer);
<String>::sse_encode(self.token, serializer);
<bool>::sse_encode(self.has_web_interface, serializer);
}
}
impl SseEncode for crate::api::http::ResultWithPublicKeyRegisterResponseDto {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<Option<String>>::sse_encode(self.public_key, serializer);
<crate::api::model::RegisterResponseDto>::sse_encode(self.body, serializer);
}
}
impl SseEncode for crate::api::discovery::RsDeviceChannel {
// 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(self.host, serializer);
<u16>::sse_encode(self.port, serializer);
<crate::api::model::ProtocolType>::sse_encode(self.protocol, serializer);
}
}
impl SseEncode for crate::api::discovery::RsDiscoveredDevice {
// 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(self.alias, serializer);
<String>::sse_encode(self.version, serializer);
<Option<String>>::sse_encode(self.device_model, serializer);
<Option<crate::api::model::DeviceType>>::sse_encode(self.device_type, serializer);
<String>::sse_encode(self.fingerprint, serializer);
<String>::sse_encode(self.host, serializer);
<u16>::sse_encode(self.port, serializer);
<crate::api::model::ProtocolType>::sse_encode(self.protocol, serializer);
<bool>::sse_encode(self.download, serializer);
}
}
impl SseEncode for crate::api::crypto::RsHashFileEvent {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
match self {
crate::api::crypto::RsHashFileEvent::Progress { bytes } => {
<i32>::sse_encode(0, serializer);
<u64>::sse_encode(bytes, serializer);
}
crate::api::crypto::RsHashFileEvent::Done { hash } => {
<i32>::sse_encode(1, serializer);
<String>::sse_encode(hash, serializer);
}
_ => {
unimplemented!("");
}
}
}
}
impl SseEncode for crate::api::http::RsHttpClientError {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
match self {
crate::api::http::RsHttpClientError::StatusCode { status, message } => {
<i32>::sse_encode(0, serializer);
<u16>::sse_encode(status, serializer);
<Option<String>>::sse_encode(message, serializer);
}
crate::api::http::RsHttpClientError::Reqwest(field0) => {
<i32>::sse_encode(1, serializer);
<String>::sse_encode(field0, serializer);
}
crate::api::http::RsHttpClientError::Json(field0) => {
<i32>::sse_encode(2, serializer);
<String>::sse_encode(field0, serializer);
}
crate::api::http::RsHttpClientError::Io(field0) => {
<i32>::sse_encode(3, serializer);
<String>::sse_encode(field0, serializer);
}
crate::api::http::RsHttpClientError::Other(field0) => {
<i32>::sse_encode(4, serializer);
<String>::sse_encode(field0, serializer);
}
_ => {
unimplemented!("");
}
}
}
}
impl SseEncode for crate::api::server::RsServerEvent {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
match self {
crate::api::server::RsServerEvent::Register { ip, info } => {
<i32>::sse_encode(0, serializer);
<String>::sse_encode(ip, serializer);
<crate::api::server::RegisterDtoV2>::sse_encode(info, serializer);
}
crate::api::server::RsServerEvent::PrepareUpload {
session_id,
ip,
info,
cert_fingerprint,
files,
} => {
<i32>::sse_encode(1, serializer);
<String>::sse_encode(session_id, serializer);
<String>::sse_encode(ip, serializer);
<crate::api::server::RegisterDtoV2>::sse_encode(info, serializer);
<Option<String>>::sse_encode(cert_fingerprint, serializer);
<std::collections::HashMap<String, crate::api::model::FileDto>>::sse_encode(
files, serializer,
);
}
crate::api::server::RsServerEvent::FileUpload {
session_id,
file_id,
file,
} => {
<i32>::sse_encode(2, serializer);
<String>::sse_encode(session_id, serializer);
<String>::sse_encode(file_id, serializer);
<crate::api::model::FileDto>::sse_encode(file, serializer);
}
crate::api::server::RsServerEvent::SessionEnd { session_id, reason } => {
<i32>::sse_encode(3, serializer);
<String>::sse_encode(session_id, serializer);
<crate::api::server::SessionEndReasonV2>::sse_encode(reason, serializer);
}
crate::api::server::RsServerEvent::PrepareUploadAborted { session_id } => {
<i32>::sse_encode(4, serializer);
<String>::sse_encode(session_id, serializer);
}
crate::api::server::RsServerEvent::CancelReceived { ip, session_id } => {
<i32>::sse_encode(5, serializer);
<String>::sse_encode(ip, serializer);
<String>::sse_encode(session_id, serializer);
}
crate::api::server::RsServerEvent::WebPrepareDownload {
ip,
session_id,
user_agent,
} => {
<i32>::sse_encode(6, serializer);
<String>::sse_encode(ip, serializer);
<String>::sse_encode(session_id, serializer);
<Option<String>>::sse_encode(user_agent, serializer);
}
crate::api::server::RsServerEvent::WebFileDownload {
session_id,
file_id,
file,
} => {
<i32>::sse_encode(7, serializer);
<String>::sse_encode(session_id, serializer);
<String>::sse_encode(file_id, serializer);
<crate::api::model::FileDto>::sse_encode(file, serializer);
}
crate::api::server::RsServerEvent::Show { args } => {
<i32>::sse_encode(8, serializer);
<Vec<String>>::sse_encode(args, serializer);
}
_ => {
unimplemented!("");
}
}
}
}
impl SseEncode for crate::api::discovery::RsStoredDevice {
// 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(self.alias, serializer);
<String>::sse_encode(self.version, serializer);
<Option<String>>::sse_encode(self.device_model, serializer);
<Option<crate::api::model::DeviceType>>::sse_encode(self.device_type, serializer);
<String>::sse_encode(self.fingerprint, serializer);
<bool>::sse_encode(self.download, serializer);
<Vec<crate::api::discovery::RsDeviceChannel>>::sse_encode(self.channels, serializer);
}
}
impl SseEncode for crate::api::webrtc::RTCFileError {
// 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(self.file_id, serializer);
<String>::sse_encode(self.error, serializer);
}
}
impl SseEncode for crate::api::webrtc::RTCSendFileResponse {
// 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(self.id, serializer);
<bool>::sse_encode(self.success, serializer);
<Option<String>>::sse_encode(self.error, serializer);
}
}
impl SseEncode for crate::api::webrtc::RTCStatus {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
match self {
crate::api::webrtc::RTCStatus::SdpExchanged => {
<i32>::sse_encode(0, serializer);
}
crate::api::webrtc::RTCStatus::Connected => {
<i32>::sse_encode(1, serializer);
}
crate::api::webrtc::RTCStatus::PinRequired => {
<i32>::sse_encode(2, serializer);
}
crate::api::webrtc::RTCStatus::TooManyAttempts => {
<i32>::sse_encode(3, serializer);
}
crate::api::webrtc::RTCStatus::Declined => {
<i32>::sse_encode(4, serializer);
}
crate::api::webrtc::RTCStatus::Sending => {
<i32>::sse_encode(5, serializer);
}
crate::api::webrtc::RTCStatus::Finished => {
<i32>::sse_encode(6, serializer);
}
crate::api::webrtc::RTCStatus::Error(field0) => {
<i32>::sse_encode(7, serializer);
<String>::sse_encode(field0, serializer);
}
_ => {
unimplemented!("");
}
}
}
}
impl SseEncode for crate::api::crypto::SecurityContext {
// 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(self.private_key, serializer);
<String>::sse_encode(self.public_key, serializer);
<String>::sse_encode(self.certificate, serializer);
<String>::sse_encode(self.certificate_hash, serializer);
}
}
impl SseEncode for crate::api::server::SessionEndReasonV2 {
// 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(
match self {
crate::api::server::SessionEndReasonV2::Finished => 0,
crate::api::server::SessionEndReasonV2::Cancelled => 1,
_ => {
unimplemented!("");
}
},
serializer,
);
}
}
impl SseEncode for crate::api::server::TlsConfig {
// 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(self.cert, serializer);
<String>::sse_encode(self.private_key, serializer);
}
}
impl SseEncode for u16 {
// 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_u16::<NativeEndian>(self).unwrap();
}
}
impl SseEncode for u32 {
// 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_u32::<NativeEndian>(self).unwrap();
}
}
impl SseEncode for u64 {
// 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).unwrap();
}
}
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 crate::api::server::WebI18n {
// 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(self.waiting, serializer);
<String>::sse_encode(self.enter_pin, serializer);
<String>::sse_encode(self.invalid_pin, serializer);
<String>::sse_encode(self.too_many_attempts, serializer);
<String>::sse_encode(self.rejected, serializer);
<String>::sse_encode(self.upload_rejected, serializer);
<String>::sse_encode(self.busy, serializer);
<String>::sse_encode(self.files, serializer);
<String>::sse_encode(self.file_name, serializer);
<String>::sse_encode(self.size, serializer);
}
}
impl SseEncode for crate::api::server::WebParams {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<Option<crate::api::server::WebSendParams>>::sse_encode(self.send, serializer);
<bool>::sse_encode(self.upload, serializer);
<crate::api::server::WebI18n>::sse_encode(self.i18n, serializer);
}
}
impl SseEncode for crate::api::server::WebSendParams {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<std::collections::HashMap<String, crate::api::model::FileDto>>::sse_encode(
self.files, serializer,
);
<Option<String>>::sse_encode(self.pin, serializer);
}
}
impl SseEncode for crate::api::webrtc::WsServerMessage {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
match self {
crate::api::webrtc::WsServerMessage::Hello { client, peers } => {
<i32>::sse_encode(0, serializer);
<crate::api::webrtc::ClientInfo>::sse_encode(client, serializer);
<Vec<crate::api::webrtc::ClientInfo>>::sse_encode(peers, serializer);
}
crate::api::webrtc::WsServerMessage::Join { peer } => {
<i32>::sse_encode(1, serializer);
<crate::api::webrtc::ClientInfo>::sse_encode(peer, serializer);
}
crate::api::webrtc::WsServerMessage::Update { peer } => {
<i32>::sse_encode(2, serializer);
<crate::api::webrtc::ClientInfo>::sse_encode(peer, serializer);
}
crate::api::webrtc::WsServerMessage::Left { peer_id } => {
<i32>::sse_encode(3, serializer);
<uuid::Uuid>::sse_encode(peer_id, serializer);
}
crate::api::webrtc::WsServerMessage::Offer(field0) => {
<i32>::sse_encode(4, serializer);
<crate::api::webrtc::WsServerSdpMessage>::sse_encode(field0, serializer);
}
crate::api::webrtc::WsServerMessage::Answer(field0) => {
<i32>::sse_encode(5, serializer);
<crate::api::webrtc::WsServerSdpMessage>::sse_encode(field0, serializer);
}
crate::api::webrtc::WsServerMessage::Error { code } => {
<i32>::sse_encode(6, serializer);
<u16>::sse_encode(code, serializer);
}
_ => {
unimplemented!("");
}
}
}
}
impl SseEncode for crate::api::webrtc::WsServerSdpMessage {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<crate::api::webrtc::ClientInfo>::sse_encode(self.peer, serializer);
<String>::sse_encode(self.session_id, serializer);
<String>::sse_encode(self.sdp, serializer);
}
}
#[cfg(not(target_family = "wasm"))]
mod io {
// This file is automatically generated, so please do not edit it.
// @generated by `flutter_rust_bridge`@ 2.12.0.
// Section: imports
use super::*;
use crate::api::cancel::*;
use crate::api::discovery::*;
use crate::api::http::*;
use crate::api::server::*;
use crate::api::stream::*;
use crate::api::webrtc::*;
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!();
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDart2RustStreamReceiver(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner< Dart2RustStreamReceiver>>::increment_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDart2RustStreamReceiver(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner< Dart2RustStreamReceiver>>::decrement_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDart2RustStreamSink(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Dart2RustStreamSink>>::increment_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDart2RustStreamSink(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Dart2RustStreamSink>>::decrement_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerLsSignalingConnection(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LsSignalingConnection>>::increment_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerLsSignalingConnection(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LsSignalingConnection>>::decrement_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRTCFileReceiver(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCFileReceiver>>::increment_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRTCFileReceiver(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCFileReceiver>>::decrement_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRTCFileSender(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCFileSender>>::increment_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRTCFileSender(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCFileSender>>::decrement_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRTCReceiveController(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCReceiveController>>::increment_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRTCReceiveController(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCReceiveController>>::decrement_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRTCSendController(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCSendController>>::increment_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRTCSendController(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCSendController>>::decrement_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRsCancellationToken(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsCancellationToken>>::increment_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRsCancellationToken(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsCancellationToken>>::decrement_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRsDiscovery(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsDiscovery>>::increment_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRsDiscovery(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsDiscovery>>::decrement_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRsHttpClient(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpClient>>::increment_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRsHttpClient(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpClient>>::decrement_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRsHttpServer(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpServer>>::increment_strong_count(ptr as _);
}
#[unsafe(no_mangle)]
pub extern "C" fn frbgen_localsend_isolates_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRsHttpServer(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpServer>>::decrement_strong_count(ptr as _);
}
}
#[cfg(not(target_family = "wasm"))]
pub use io::*;
/// cbindgen:ignore
#[cfg(target_family = "wasm")]
mod web {
// This file is automatically generated, so please do not edit it.
// @generated by `flutter_rust_bridge`@ 2.12.0.
// Section: imports
use super::*;
use crate::api::cancel::*;
use crate::api::discovery::*;
use crate::api::http::*;
use crate::api::server::*;
use crate::api::stream::*;
use crate::api::webrtc::*;
use flutter_rust_bridge::for_generated::byteorder::{
NativeEndian, ReadBytesExt, WriteBytesExt,
};
use flutter_rust_bridge::for_generated::wasm_bindgen;
use flutter_rust_bridge::for_generated::wasm_bindgen::prelude::*;
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_web!();
#[wasm_bindgen]
pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDart2RustStreamReceiver(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner< Dart2RustStreamReceiver>>::increment_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDart2RustStreamReceiver(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner< Dart2RustStreamReceiver>>::decrement_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDart2RustStreamSink(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Dart2RustStreamSink>>::increment_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDart2RustStreamSink(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Dart2RustStreamSink>>::decrement_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerLsSignalingConnection(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LsSignalingConnection>>::increment_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerLsSignalingConnection(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LsSignalingConnection>>::decrement_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRTCFileReceiver(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCFileReceiver>>::increment_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRTCFileReceiver(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCFileReceiver>>::decrement_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRTCFileSender(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCFileSender>>::increment_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRTCFileSender(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCFileSender>>::decrement_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRTCReceiveController(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCReceiveController>>::increment_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRTCReceiveController(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCReceiveController>>::decrement_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRTCSendController(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCSendController>>::increment_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRTCSendController(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RTCSendController>>::decrement_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRsCancellationToken(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsCancellationToken>>::increment_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRsCancellationToken(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsCancellationToken>>::decrement_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRsDiscovery(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsDiscovery>>::increment_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRsDiscovery(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsDiscovery>>::decrement_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRsHttpClient(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpClient>>::increment_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRsHttpClient(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpClient>>::decrement_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRsHttpServer(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpServer>>::increment_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRsHttpServer(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RsHttpServer>>::decrement_strong_count(ptr as _);
}
}
#[cfg(target_family = "wasm")]
pub use web::*;
Reference in New Issue View Git Blame Copy Permalink